chore: initial clean commit

src/main.rs

@@ -0,0 +1,141 @@
+use anyhow::Result;
+use axum::{Router, routing::get};
+use std::net::SocketAddr;
+use std::sync::Arc;
+use tracing::{info, error};
+
+use llm_proxy::{
+    config::AppConfig, 
+    state::AppState,
+    providers::{
+        ProviderManager, 
+        openai::OpenAIProvider,
+        gemini::GeminiProvider,
+        deepseek::DeepSeekProvider,
+        grok::GrokProvider,
+        ollama::OllamaProvider,
+    },
+    database,
+    server,
+    dashboard,
+    rate_limiting::{RateLimitManager, RateLimiterConfig, CircuitBreakerConfig},
+};
+
+#[tokio::main]
+async fn main() -> Result<()> {
+    // Initialize tracing (logging)
+    tracing_subscriber::fmt()
+        .with_max_level(tracing::Level::INFO)
+        .with_target(false)
+        .init();
+
+    info!("Starting LLM Proxy Gateway v{}", env!("CARGO_PKG_VERSION"));
+
+    // Load configuration
+    let config = AppConfig::load().await?;
+    info!("Configuration loaded from {:?}", config.config_path);
+
+    // Initialize database connection pool
+    let db_pool = database::init(&config.database).await?;
+    info!("Database initialized at {:?}", config.database.path);
+
+    // Initialize provider manager with configured providers
+    let mut provider_manager = ProviderManager::new();
+    
+    // Initialize OpenAI
+    if config.providers.openai.enabled {
+        match OpenAIProvider::new(&config.providers.openai, &config) {
+            Ok(p) => {
+                provider_manager.add_provider(Arc::new(p));
+                info!("OpenAI provider initialized");
+            }
+            Err(e) => error!("Failed to initialize OpenAI provider: {}", e),
+        }
+    }
+    
+    // Initialize Gemini
+    if config.providers.gemini.enabled {
+        match GeminiProvider::new(&config.providers.gemini, &config) {
+            Ok(p) => {
+                provider_manager.add_provider(Arc::new(p));
+                info!("Gemini provider initialized");
+            }
+            Err(e) => error!("Failed to initialize Gemini provider: {}", e),
+        }
+    }
+    
+    // Initialize DeepSeek
+    if config.providers.deepseek.enabled {
+        match DeepSeekProvider::new(&config.providers.deepseek, &config) {
+            Ok(p) => {
+                provider_manager.add_provider(Arc::new(p));
+                info!("DeepSeek provider initialized");
+            }
+            Err(e) => error!("Failed to initialize DeepSeek provider: {}", e),
+        }
+    }
+    
+    // Initialize Grok
+    if config.providers.grok.enabled {
+        match GrokProvider::new(&config.providers.grok, &config) {
+            Ok(p) => {
+                provider_manager.add_provider(Arc::new(p));
+                info!("Grok provider initialized");
+            }
+            Err(e) => error!("Failed to initialize Grok provider: {}", e),
+        }
+    }
+
+    // Initialize Ollama
+    if config.providers.ollama.enabled {
+        match OllamaProvider::new(&config.providers.ollama, &config) {
+            Ok(p) => {
+                provider_manager.add_provider(Arc::new(p));
+                info!("Ollama provider initialized at {}", config.providers.ollama.base_url);
+            }
+            Err(e) => error!("Failed to initialize Ollama provider: {}", e),
+        }
+    }
+
+    // Create rate limit manager
+    let rate_limit_manager = RateLimitManager::new(
+        RateLimiterConfig::default(),
+        CircuitBreakerConfig::default(),
+    );
+    
+    // Fetch model registry from models.dev
+    let model_registry = match llm_proxy::utils::registry::fetch_registry().await {
+        Ok(registry) => registry,
+        Err(e) => {
+            error!("Failed to fetch model registry: {}. Using empty registry.", e);
+            llm_proxy::models::registry::ModelRegistry { providers: std::collections::HashMap::new() }
+        }
+    };
+    
+    // Create application state
+    let state = AppState::new(provider_manager, db_pool, rate_limit_manager, model_registry);
+
+    // Create application router
+    let app = Router::new()
+        .route("/health", get(health_check))
+        .route("/", get(root))
+        .merge(server::router(state.clone()))
+        .merge(dashboard::router(state.clone()));
+
+    // Start server
+    let addr = SocketAddr::from(([0, 0, 0, 0], config.server.port));
+    info!("Server listening on http://{}", addr);
+
+    let listener = tokio::net::TcpListener::bind(&addr).await?;
+    axum::serve(listener, app).await?;
+
+    Ok(())
+}
+
+async fn health_check() -> &'static str {
+    "OK"
+}
+
+async fn root() -> &'static str {
+    "LLM Proxy Gateway - Unified interface for OpenAI, Gemini, DeepSeek, and Grok"
+}