Bump version to 0.1.3

Author: d-oit

.opencode/agent/agent-coordinator.md

@@ -37,8 +37,7 @@ tools:
   list: true
   webfetch: false
   todowrite: true
-  todoread: true
-  task: true
+  todoread: true 
   bash: false  
 ---
 ## Overview

.opencode/agent/context7-mcp-agent.md

@@ -18,6 +18,8 @@ tools:
   bash: false
   write: false
   edit: false
+  batch: false
+  grop: false
   context7_resolve_library_id: true
   context7_get_library_docs: true
 ---

.opencode/package.json

@@ -1,5 +1,5 @@
 {
   "dependencies": {
-    "@opencode-ai/plugin": "0.15.0"
+    "@opencode-ai/plugin": "0.15.3"
   }
 }

Cargo.lock

@@ -1,6 +1,6 @@
 [package]
 name = "code_guardian_cli"
-version = "0.1.2"
+version = "0.1.3"
 edition = "2021"
 
 [dependencies]
@@ -24,6 +24,7 @@ tokio = { workspace = true }
 tracing = { workspace = true }
 tracing-subscriber = { workspace = true }
 sysinfo = { workspace = true }
+rand = "0.8"
 
 code-guardian-core = { path = "../core" }
 code-guardian-storage = { path = "../storage" }

crates/cli/Cargo.toml

@@ -1,6 +1,7 @@
 use anyhow::Result;
 use code_guardian_core::{
     DetectorFactory, DetectorProfile, OptimizedScanner, Scanner, StreamingScanner,
+    BenchmarkSuite, BenchmarkConfigurations, PerformanceAnalyzer,
 };
 use std::path::Path;
 use std::time::Instant;
@@ -120,6 +121,180 @@ pub fn run_benchmark(path: &Path) -> Result<()> {
     Ok(())
 }
 
+/// Run comprehensive benchmark suite
+pub fn run_comprehensive_benchmark(path: &Path, suite_type: &str) -> Result<()> {
+    println!("🚀 Code-Guardian Comprehensive Benchmark");
+    println!("=========================================\n");
+
+    let mut suite = match suite_type {
+        "small" => BenchmarkConfigurations::small_project(),
+        "medium" => BenchmarkConfigurations::medium_project(),
+        "large" => BenchmarkConfigurations::large_project(),
+        "regression" => BenchmarkConfigurations::regression_detection(),
+        "all" => {
+            // Run all benchmark suites
+            run_all_benchmark_suites(path)?;
+            return Ok(());
+        }
+        _ => {
+            println!("❌ Unknown benchmark suite: {}", suite_type);
+            println!("Available suites: small, medium, large, regression, all");
+            return Ok(());
+        }
+    };
+
+    suite.run_benchmarks(path)?;
+    
+    // Generate detailed report
+    generate_benchmark_report(&suite)?;
+    
+    Ok(())
+}
+
+/// Run all benchmark suites
+pub fn run_all_benchmark_suites(path: &Path) -> Result<()> {
+    println!("🏃‍♂️ Running All Benchmark Suites");
+    println!("==================================\n");
+
+    let suites = vec![
+        ("Small Project", BenchmarkConfigurations::small_project()),
+        ("Medium Project", BenchmarkConfigurations::medium_project()),
+        ("Large Project", BenchmarkConfigurations::large_project()),
+        ("Regression Detection", BenchmarkConfigurations::regression_detection()),
+    ];
+
+    let mut all_results = Vec::new();
+    let mut total_passed = 0;
+    let mut total_tests = 0;
+
+    for (name, mut suite) in suites {
+        println!("🔄 Running {} Suite...", name);
+        suite.run_benchmarks(path)?;
+        
+        total_passed += suite.summary.passed_tests;
+        total_tests += suite.summary.total_tests;
+        all_results.push((name, suite));
+    }
+
+    // Overall summary
+    println!("\n🏁 Overall Benchmark Results");
+    println!("=============================");
+    println!("Total Suites: {}", all_results.len());
+    println!("Total Tests: {}", total_tests);
+    println!("Total Passed: ✅ {}", total_passed);
+    println!("Total Failed: ❌ {}", total_tests - total_passed);
+    
+    let success_rate = (total_passed as f64 / total_tests as f64) * 100.0;
+    println!("Success Rate: {:.1}%", success_rate);
+
+    if success_rate >= 90.0 {
+        println!("🎉 Excellent performance across all benchmarks!");
+    } else if success_rate >= 70.0 {
+        println!("✅ Good performance with some areas for improvement");
+    } else {
+        println!("⚠️ Performance issues detected - optimization recommended");
+    }
+
+    Ok(())
+}
+
+/// Run performance analysis with detailed metrics
+pub fn run_performance_analysis(path: &Path) -> Result<()> {
+    println!("🔍 Performance Analysis");
+    println!("======================\n");
+
+    let mut analyzer = PerformanceAnalyzer::new();
+    
+    analyzer.analyze_performance(|| {
+        // Run a comprehensive scan for analysis
+        let scanner = OptimizedScanner::new(DetectorProfile::Comprehensive.get_detectors())
+            .with_cache_size(10000);
+        let (_matches, _metrics) = scanner.scan_optimized(path)?;
+        Ok(())
+    })?;
+
+    // Generate and display performance report
+    let report = analyzer.generate_report();
+    println!("{}", report);
+
+    // Save analysis to file
+    save_performance_analysis(&analyzer, path)?;
+
+    Ok(())
+}
+
+/// Generate comprehensive benchmark report
+fn generate_benchmark_report(suite: &BenchmarkSuite) -> Result<()> {
+    println!("\n📊 Detailed Benchmark Report");
+    println!("============================");
+    
+    println!("Suite: {}", suite.name);
+    println!("Performance Score: {:.1}/100", suite.summary.performance_score);
+    
+    if !suite.results.is_empty() {
+        println!("\n📈 Individual Test Results:");
+        for result in &suite.results {
+            println!("\n🔍 {}", result.name);
+            println!("   Duration: {:?}", result.duration);
+            println!("   Files/sec: {:.1}", result.throughput.files_per_second);
+            println!("   Lines/sec: {:.0}", result.throughput.lines_per_second);
+            println!("   Memory: {:.1} MB", result.resource_usage.memory_mb);
+            println!("   Score: {:.1}/100", result.performance_score);
+        }
+    }
+
+    if !suite.summary.improvement_areas.is_empty() {
+        println!("\n💡 Recommendations:");
+        for area in &suite.summary.improvement_areas {
+            println!("   • {}", area);
+        }
+    }
+
+    // Save report to file
+    save_benchmark_report(suite)?;
+
+    Ok(())
+}
+
+/// Save benchmark report to file
+fn save_benchmark_report(suite: &BenchmarkSuite) -> Result<()> {
+    use std::fs;
+    use std::path::PathBuf;
+    
+    let timestamp = chrono::Utc::now().format("%Y%m%d_%H%M%S");
+    let filename = format!("benchmark_report_{}_{}.json", 
+        suite.name.replace(" ", "_").to_lowercase(), timestamp);
+    
+    let reports_dir = PathBuf::from("reports");
+    fs::create_dir_all(&reports_dir)?;
+    
+    let report_path = reports_dir.join(filename);
+    let json_report = serde_json::to_string_pretty(suite)?;
+    fs::write(&report_path, json_report)?;
+    
+    println!("\n📄 Report saved to: {}", report_path.display());
+    Ok(())
+}
+
+/// Save performance analysis to file
+fn save_performance_analysis(analyzer: &PerformanceAnalyzer, path: &Path) -> Result<()> {
+    use std::fs;
+    use std::path::PathBuf;
+    
+    let timestamp = chrono::Utc::now().format("%Y%m%d_%H%M%S");
+    let filename = format!("performance_analysis_{}.json", timestamp);
+    
+    let reports_dir = PathBuf::from("reports");
+    fs::create_dir_all(&reports_dir)?;
+    
+    let report_path = reports_dir.join(filename);
+    let json_analysis = serde_json::to_string_pretty(analyzer)?;
+    fs::write(&report_path, json_analysis)?;
+    
+    println!("\n📄 Analysis saved to: {}", report_path.display());
+    Ok(())
+}
+
 /// Quick performance test
 pub fn quick_performance_test(path: &Path) -> Result<()> {
     println!("⚡ Quick Performance Test");

crates/cli/src/benchmark.rs

@@ -55,6 +55,18 @@ pub fn handle_benchmark(path: Option<PathBuf>, quick: bool) -> Result<()> {
     }
 }
 
+/// Handle comprehensive benchmark command with suite selection
+pub fn handle_comprehensive_benchmark(path: Option<PathBuf>, suite: String) -> Result<()> {
+    let benchmark_path = path.unwrap_or_else(|| std::env::current_dir().unwrap());
+    benchmark::run_comprehensive_benchmark(&benchmark_path, &suite)
+}
+
+/// Handle performance analysis command
+pub fn handle_performance_analysis(path: Option<PathBuf>) -> Result<()> {
+    let analysis_path = path.unwrap_or_else(|| std::env::current_dir().unwrap());
+    benchmark::run_performance_analysis(&analysis_path)
+}
+
 // These functions are re-exported from advanced_handlers
 pub use crate::advanced_handlers::{
     handle_custom_detectors, handle_distributed, handle_incremental,