feat(main): implement multi-profile CLI with config-driven analysis

Replace single --repo flag with --config (default: config.toml).
For each profile and each repo in config:
- Clone or fetch repo into ~/.cache/git-reports/
- Analyze commits filtered by profile email and --period
- Serialize results as JSON array to --output or stdout

Author: madkoding

src/main.rs

@@ -1,27 +1,102 @@
 use clap::Parser;
+use git_reports::analysis::{analyze_repo, clone_or_update};
+use git_reports::config::load_config;
+use serde_json;
 
 #[derive(Parser, Debug)]
 #[command(name = "git-reports")]
 #[command(about = "Automated Git analytics engine for work summaries", long_about = None)]
 struct Args {
-    /// Path to the Git repository
-    #[arg(short, long, default_value = ".")]
-    repo: String,
+    /// Ruta al archivo de configuración (config.toml)
+    #[arg(short, long, default_value = "config.toml")]
+    config: String,
 
-    /// Output file path (JSON)
+    /// Archivo de salida JSON (por defecto imprime a stdout)
     #[arg(short, long)]
     output: Option<String>,
 
-    /// Time period: week, month, all
+    /// Periodo de análisis: week, month, all
     #[arg(short, long, default_value = "week")]
     period: String,
 }
 
 fn main() {
     let args = Args::parse();
-    println!("Git Reports - Analyzing repository: {}", args.repo);
-    println!("Period: {}", args.period);
-    
-    // TODO: Implement Git analysis
-    println!("Analysis complete!");
+
+    // Cargar configuración
+    let config = match load_config(&args.config) {
+        Ok(c) => c,
+        Err(e) => {
+            eprintln!("Error: {}", e);
+            std::process::exit(1);
+        }
+    };
+
+    eprintln!(
+        "Git Reports — {} perfil(es) encontrado(s), periodo: {}",
+        config.profile.len(),
+        args.period
+    );
+
+    let mut all_reports: Vec<serde_json::Value> = Vec::new();
+
+    for profile in &config.profile {
+        eprintln!("\n[perfil: {}] email: {}", profile.name, profile.email);
+
+        let mut profile_reports: Vec<serde_json::Value> = Vec::new();
+
+        for entry in &profile.repo {
+            let label = format!("{}/{}/{}", entry.provider, entry.owner, entry.name);
+            eprintln!("  Procesando {}", label);
+
+            // Clonar o actualizar el repo en caché
+            let repo = match clone_or_update(entry, profile) {
+                Ok(r) => r,
+                Err(e) => {
+                    eprintln!("  ✗ Error: {}", e);
+                    continue;
+                }
+            };
+
+            // Analizar commits filtrados por email y periodo
+            let report = match analyze_repo(&repo, &args.period, &profile.email, &label) {
+                Ok(r) => r,
+                Err(e) => {
+                    eprintln!("  ✗ Error al analizar: {}", e);
+                    continue;
+                }
+            };
+
+            eprintln!(
+                "  ✓ {} commit(s) encontrado(s) para {}",
+                report.total_commits, profile.email
+            );
+
+            profile_reports.push(serde_json::to_value(&report).unwrap());
+        }
+
+        all_reports.push(serde_json::json!({
+            "profile": profile.name,
+            "email": profile.email,
+            "repos": profile_reports,
+        }));
+    }
+
+    // Serializar resultado final
+    let json = serde_json::to_string_pretty(&all_reports).unwrap_or_else(|e| {
+        eprintln!("Error al serializar JSON: {}", e);
+        std::process::exit(1);
+    });
+
+    match &args.output {
+        Some(path) => {
+            std::fs::write(path, &json).unwrap_or_else(|e| {
+                eprintln!("Error al escribir '{}': {}", path, e);
+                std::process::exit(1);
+            });
+            eprintln!("\nReporte guardado en: {}", path);
+        }
+        None => println!("{}", json),
+    }
 }
+