feat: add Git CLI commands and refactor stack preset handler

Author: d-oit

crates/cli/src/main.rs

@@ -8,12 +8,14 @@ use std::path::PathBuf;
 mod advanced_handlers;
 mod benchmark;
 mod comparison_handlers;
+mod git_integration;
 mod production_handlers;
 mod report_handlers;
 mod scan_handlers;
 mod utils;
 
 use advanced_handlers::*;
+use git_integration::GitIntegration;
 use production_handlers::*;
 
 #[derive(Parser)]
@@ -243,6 +245,11 @@ enum Commands {
         #[arg(long, default_value = "500")]
         delay: u64,
     },
+    /// Git integration and hook management
+    Git {
+        #[command(subcommand)]
+        action: GitAction,
+    },
 }
 
 #[derive(Subcommand)]
@@ -349,6 +356,28 @@ enum StackPreset {
     },
 }
 
+#[derive(Subcommand)]
+enum GitAction {
+    /// Install pre-commit hook
+    InstallHook {
+        /// Path to git repository (default: current directory)
+        #[arg(default_value = ".")]
+        path: PathBuf,
+    },
+    /// Uninstall pre-commit hook
+    UninstallHook {
+        /// Path to git repository (default: current directory)
+        #[arg(default_value = ".")]
+        path: PathBuf,
+    },
+    /// List staged files that would be scanned
+    Staged {
+        /// Path to git repository (default: current directory)
+        #[arg(default_value = ".")]
+        path: PathBuf,
+    },
+}
+
 fn main() -> Result<()> {
     let cli = Cli::parse();
 
@@ -435,13 +464,14 @@ fn main() -> Result<()> {
             format,
             production,
         } => handle_lang_scan(languages, path, format, production),
-        Commands::Stack { preset } => handle_stack_preset(preset),
+        Commands::Stack { preset } => handle_stack_preset_main(preset),
         Commands::Watch {
             path,
             include,
             exclude,
             delay,
         } => handle_watch(path, include, exclude, delay),
+        Commands::Git { action } => handle_git(action),
     }
 }
 
@@ -484,6 +514,116 @@ fn handle_benchmark(path: Option<PathBuf>, quick: bool) -> Result<()> {
     }
 }
 
+fn handle_stack_preset_main(preset: StackPreset) -> Result<()> {
+    match preset {
+        StackPreset::Web { path, production } => {
+            let languages = vec![
+                "js".to_string(),
+                "ts".to_string(),
+                "jsx".to_string(),
+                "tsx".to_string(),
+                "vue".to_string(),
+                "svelte".to_string(),
+            ];
+            handle_lang_scan(languages, path, "text".to_string(), production)
+        }
+        StackPreset::Backend { path, production } => {
+            let languages = vec![
+                "py".to_string(),
+                "java".to_string(),
+                "go".to_string(),
+                "cs".to_string(),
+                "php".to_string(),
+                "rb".to_string(),
+            ];
+            handle_lang_scan(languages, path, "text".to_string(), production)
+        }
+        StackPreset::Fullstack { path, production } => {
+            let languages = vec![
+                "js".to_string(),
+                "ts".to_string(),
+                "py".to_string(),
+                "java".to_string(),
+                "go".to_string(),
+                "rs".to_string(),
+            ];
+            handle_lang_scan(languages, path, "text".to_string(), production)
+        }
+        StackPreset::Mobile { path, production } => {
+            let languages = vec![
+                "js".to_string(),
+                "ts".to_string(),
+                "swift".to_string(),
+                "kt".to_string(),
+                "dart".to_string(),
+            ];
+            handle_lang_scan(languages, path, "text".to_string(), production)
+        }
+        StackPreset::Systems { path, production } => {
+            let languages = vec![
+                "rs".to_string(),
+                "cpp".to_string(),
+                "c".to_string(),
+                "go".to_string(),
+            ];
+            handle_lang_scan(languages, path, "text".to_string(), production)
+        }
+    }
+}
+
+fn handle_git(action: GitAction) -> Result<()> {
+    match action {
+        GitAction::InstallHook { path } => {
+            println!("🔧 Installing Code-Guardian pre-commit hook...");
+
+            if !GitIntegration::is_git_repo(&path) {
+                eprintln!("❌ Error: {} is not a git repository", path.display());
+                std::process::exit(1);
+            }
+
+            let repo_root = GitIntegration::get_repo_root(&path)?;
+            GitIntegration::install_pre_commit_hook(&repo_root)?;
+
+            println!("💡 Usage: The hook will automatically run on 'git commit'");
+            println!("💡 Manual run: code-guardian pre-commit --staged-only --fast");
+            Ok(())
+        }
+        GitAction::UninstallHook { path } => {
+            println!("🗑️  Uninstalling Code-Guardian pre-commit hook...");
+
+            if !GitIntegration::is_git_repo(&path) {
+                eprintln!("❌ Error: {} is not a git repository", path.display());
+                std::process::exit(1);
+            }
+
+            let repo_root = GitIntegration::get_repo_root(&path)?;
+            GitIntegration::uninstall_pre_commit_hook(&repo_root)?;
+            Ok(())
+        }
+        GitAction::Staged { path } => {
+            println!("📋 Listing staged files...");
+
+            if !GitIntegration::is_git_repo(&path) {
+                eprintln!("❌ Error: {} is not a git repository", path.display());
+                std::process::exit(1);
+            }
+
+            let repo_root = GitIntegration::get_repo_root(&path)?;
+            let staged_files = GitIntegration::get_staged_files(&repo_root)?;
+
+            if staged_files.is_empty() {
+                println!("ℹ️  No staged files found.");
+            } else {
+                println!("🔍 Found {} staged file(s):", staged_files.len());
+                for (i, file) in staged_files.iter().enumerate() {
+                    println!("  {}. {}", i + 1, file.display());
+                }
+            }
+            Ok(())
+        }
+    }
+}
+
 #[cfg(test)]
 mod tests {
     use super::*;

crates/cli/src/production_handlers.rs

@@ -1,3 +1,4 @@
+use crate::git_integration::GitIntegration;
 use anyhow::Result;
 use code_guardian_core::{AlertDetector, ConsoleLogDetector, DebuggerDetector};
 use code_guardian_core::{DetectorFactory, Match, PatternDetector, Scanner};
@@ -102,9 +103,48 @@ pub fn handle_pre_commit(path: PathBuf, staged_only: bool, fast: bool) -> Result
     };
 
     let scanner = Scanner::new(detectors);
+
     let matches = if staged_only {
-        // TODO: Implement git diff --cached integration
-        scanner.scan(&path)?
+        // Check if we're in a git repository
+        if !GitIntegration::is_git_repo(&path) {
+            println!("⚠️  Not in a git repository. Scanning entire directory instead.");
+            scanner.scan(&path)?
+        } else {
+            // Get repo root and staged files
+            let repo_root = GitIntegration::get_repo_root(&path)?;
+            let staged_files = GitIntegration::get_staged_files(&repo_root)?;
+
+            if staged_files.is_empty() {
+                println!("ℹ️  No staged files found. Nothing to scan.");
+                return Ok(());
+            }
+
+            println!("🔍 Scanning {} staged file(s)...", staged_files.len());
+            if !fast {
+                for file in &staged_files {
+                    println!("  📄 {}", file.display());
+                }
+            }
+
+            // Scan only staged files
+            let mut all_matches = Vec::new();
+            for file_path in staged_files {
+                if file_path.is_file() {
+                    // For now, use the directory scanner on each file's parent
+                    // This is a workaround until we implement file-specific scanning
+                    if let Some(parent) = file_path.parent() {
+                        let file_matches = scanner.scan(parent)?;
+                        // Filter matches to only include the specific file
+                        let filtered_matches: Vec<_> = file_matches
+                            .into_iter()
+                            .filter(|m| m.file_path == file_path.to_string_lossy())
+                            .collect();
+                        all_matches.extend(filtered_matches);
+                    }
+                }
+            }
+            all_matches
+        }
     } else {
         scanner.scan(&path)?
     };
@@ -265,66 +305,6 @@ pub fn handle_lang_scan(
     Ok(())
 }
 
-/// Handle technology stack presets
-pub fn handle_stack_preset(preset: crate::StackPreset) -> Result<()> {
-    use crate::StackPreset;
-
-    match preset {
-        StackPreset::Web { path, production } => {
-            let languages = vec![
-                "js".to_string(),
-                "ts".to_string(),
-                "jsx".to_string(),
-                "tsx".to_string(),
-                "vue".to_string(),
-                "svelte".to_string(),
-            ];
-            handle_lang_scan(languages, path, "text".to_string(), production)
-        }
-        StackPreset::Backend { path, production } => {
-            let languages = vec![
-                "py".to_string(),
-                "java".to_string(),
-                "go".to_string(),
-                "cs".to_string(),
-                "php".to_string(),
-                "rb".to_string(),
-            ];
-            handle_lang_scan(languages, path, "text".to_string(), production)
-        }
-        StackPreset::Fullstack { path, production } => {
-            let languages = vec![
-                "js".to_string(),
-                "ts".to_string(),
-                "py".to_string(),
-                "java".to_string(),
-                "go".to_string(),
-                "rs".to_string(),
-            ];
-            handle_lang_scan(languages, path, "text".to_string(), production)
-        }
-        StackPreset::Mobile { path, production } => {
-            let languages = vec![
-                "js".to_string(),
-                "ts".to_string(),
-                "swift".to_string(),
-                "kt".to_string(),
-                "dart".to_string(),
-            ];
-            handle_lang_scan(languages, path, "text".to_string(), production)
-        }
-        StackPreset::Systems { path, production } => {
-            let languages = vec![
-                "rs".to_string(),
-                "cpp".to_string(),
-                "c".to_string(),
-                "go".to_string(),
-            ];
-            handle_lang_scan(languages, path, "text".to_string(), production)
-        }
-    }
-}
-
 /// Handle file watching command
 pub fn handle_watch(
     _path: PathBuf,