soma-core 2.0.2

// Issue #25 - EditClassificationSystem Demo
// Comprehensive demonstration of intelligent edit classification and filtering

use soma_core::classification::{
    EditClassificationSystem, ClassificationConfig, FilterCriteria, 
    ClassificationRecommendation
};
use soma_core::agents::gpt4_agent::ProposedEdit;
use soma_core::edit_control::ModifiableEdit;
use soma_core::cli::edit_classification::EditClassificationCLI;
use anyhow::Result;

fn main() -> Result<()> {
    println!("🚀 SOMA-CORE Edit Classification System Demo");
    println!("============================================");
    println!("Issue #25 - Smart Classification and Filtering of Edit Proposals\n");

    // Demo 1: Basic Classification System
    demo_basic_classification()?;
    
    // Demo 2: Pattern Detection
    demo_pattern_detection()?;
    
    // Demo 3: Batch Classification with Filtering
    demo_batch_classification()?;
    
    // Demo 4: CLI Integration
    demo_cli_integration()?;
    
    // Demo 5: Risk Assessment and Scoring
    demo_risk_assessment()?;
    
    // Demo 6: Cognitive Integration
    demo_cognitive_integration()?;

    println!("\n🎉 EditClassificationSystem Demo Complete!");
    println!("====================");
    println!("All classification features working perfectly!");
    println!("✅ Smart categorization");
    println!("✅ Risk assessment");
    println!("✅ Priority scoring");
    println!("✅ Pattern detection");
    println!("✅ Batch processing");
    println!("✅ Filtering capabilities");
    println!("✅ CLI integration");
    println!("✅ Cognitive enhancement");

    Ok(())
}

fn demo_basic_classification() -> Result<()> {
    println!("📊 Demo 1: Basic Classification System");
    println!("=====================================\n");

    let system = EditClassificationSystem::new();
    
    // Create test edits
    let doc_edit = create_test_edit(
        "docs/README.md",
        "# Updated Documentation\nThis is improved documentation.",
        "Update project documentation with better examples"
    );
    
    let code_edit = create_test_edit(
        "src/lib.rs", 
        "pub fn main() { println!(\"Hello world!\"); }",
        "Add main function to library"
    );
    
    // Classify edits
    let classified_doc = system.classify_edit(&doc_edit)?;
    let classified_code = system.classify_edit(&code_edit)?;
    
    println!("🔍 Documentation Edit Classification:");
    print_classification_summary(&classified_doc);
    
    println!("\n🔍 Code Edit Classification:");
    print_classification_summary(&classified_code);
    
    println!("✅ Demo 1 Complete: Basic classification working!\n");
    Ok(())
}

fn demo_pattern_detection() -> Result<()> {
    println!("🔍 Demo 2: Pattern Detection");
    println!("============================\n");

    let system = EditClassificationSystem::new();
    
    // Security-sensitive edit
    let security_edit = create_test_edit(
        "src/auth.rs",
        "let password = \"secret123\";\nlet auth_token = \"Bearer xyz\";",
        "Add authentication credentials"
    );
    
    // Performance-sensitive edit
    let perf_edit = create_test_edit(
        "src/optimization.rs",
        "for i in 0..1000000 { let x = allocate_memory(); }",
        "Add performance optimization loop"
    );
    
    // TODO pattern edit
    let todo_edit = create_test_edit(
        "src/feature.rs",
        "// TODO: Implement this feature\nfn placeholder() {}",
        "Add placeholder for new feature"
    );
    
    let classified_security = system.classify_edit(&security_edit)?;
    let classified_perf = system.classify_edit(&perf_edit)?;
    let classified_todo = system.classify_edit(&todo_edit)?;
    
    println!("🔒 Security Pattern Detection:");
    print_classification_summary(&classified_security);
    
    println!("\n⚡ Performance Pattern Detection:");
    print_classification_summary(&classified_perf);
    
    println!("\n📝 TODO Pattern Detection:");
    print_classification_summary(&classified_todo);
    
    println!("✅ Demo 2 Complete: Pattern detection working!\n");
    Ok(())
}

fn demo_batch_classification() -> Result<()> {
    println!("📦 Demo 3: Batch Classification with Filtering");
    println!("==============================================\n");

    let system = EditClassificationSystem::new();
    
    // Create multiple test edits
    let edits = vec![
        create_test_edit("README.md", "Documentation update", "Update docs"),
        create_test_edit("src/security.rs", "let password = \"secret\";", "Security update"),
        create_test_edit("src/main.rs", "fn main() {}", "Main function"),
        create_test_edit("Cargo.toml", "version = \"1.0.1\"", "Bump version"),
        create_test_edit("src/lib.rs", "// Comment", "Add comment"),
    ];
    
    // Classify batch
    let classified_edits = system.classify_batch(&edits)?;
    
    println!("📈 Batch Classification Results:");
    let stats = system.get_classification_stats(&classified_edits);
    println!("   Total Edits: {}", stats.total_count);
    println!("   Average Risk: {:.3}", stats.average_risk);
    println!("   Average Priority: {:.3}", stats.average_priority);
    println!("   Average Confidence: {:.3}", stats.average_confidence);
    
    // Demo filtering
    println!("\n🔧 Filtering Demonstrations:");
    
    // Filter by high risk
    let mut criteria = FilterCriteria::default();
    criteria.max_risk = Some(0.5);
    let low_risk_edits = system.filter_edits(&classified_edits, &criteria);
    println!("   Low risk edits (≤ 0.5): {}", low_risk_edits.len());
    
    // Filter by high priority
    criteria = FilterCriteria::default();
    criteria.min_priority = Some(0.5);
    let high_priority_edits = system.filter_edits(&classified_edits, &criteria);
    println!("   High priority edits (≥ 0.5): {}", high_priority_edits.len());
    
    // Filter by high confidence
    criteria = FilterCriteria::default();
    criteria.min_confidence = Some(0.8);
    let high_confidence_edits = system.filter_edits(&classified_edits, &criteria);
    println!("   High confidence edits (≥ 0.8): {}", high_confidence_edits.len());
    
    println!("✅ Demo 3 Complete: Batch processing and filtering working!\n");
    Ok(())
}

fn demo_cli_integration() -> Result<()> {
    println!("💻 Demo 4: CLI Integration");
    println!("==========================\n");

    let mut cli = EditClassificationCLI::new()?;
    
    let test_edit = create_test_edit(
        "src/example.rs",
        "fn example() { println!(\"Hello\"); }",
        "Add example function"
    );
    
    println!("🖥️  Running CLI classification for single edit...");
    let _classified = cli.classify_single_edit(&test_edit)?;
    
    println!("✅ Demo 4 Complete: CLI integration working!\n");
    Ok(())
}

fn demo_risk_assessment() -> Result<()> {
    println!("⚠️  Demo 5: Risk Assessment and Scoring");
    println!("======================================\n");

    let system = EditClassificationSystem::new();
    
    // Create edits with different risk profiles
    let low_risk_edit = create_test_edit("docs/guide.md", "Documentation", "Safe docs");
    let medium_risk_edit = create_test_edit("src/feature.rs", "new_feature()", "New feature");
    let high_risk_edit = create_test_edit("Cargo.toml", "dependencies", "Change deps");
    
    let low_classified = system.classify_edit(&low_risk_edit)?;
    let medium_classified = system.classify_edit(&medium_risk_edit)?;
    let high_classified = system.classify_edit(&high_risk_edit)?;
    
    println!("📊 Risk Assessment Comparison:");
    println!("   Low Risk ({:.3}): {}", 
        low_classified.risk_assessment.overall_score,
        low_classified.risk_assessment.explanation);
    println!("   Medium Risk ({:.3}): {}", 
        medium_classified.risk_assessment.overall_score,
        medium_classified.risk_assessment.explanation);
    println!("   High Risk ({:.3}): {}", 
        high_classified.risk_assessment.overall_score,
        high_classified.risk_assessment.explanation);
    
    println!("\n🎯 Priority Scoring:");
    println!("   Low Risk Priority: {:.3}", low_classified.priority_score);
    println!("   Medium Risk Priority: {:.3}", medium_classified.priority_score);
    println!("   High Risk Priority: {:.3}", high_classified.priority_score);
    
    println!("✅ Demo 5 Complete: Risk assessment and scoring working!\n");
    Ok(())
}

fn demo_cognitive_integration() -> Result<()> {
    println!("🧠 Demo 6: Cognitive Integration");
    println!("================================\n");

    // Create system with cognitive analysis enabled
    let mut config = ClassificationConfig::default();
    config.use_cognitive_analysis = true;
    config.verbose_logging = true;
    
    let system = EditClassificationSystem::with_config(config);
    
    let test_edit = create_test_edit(
        "src/complex.rs",
        "complex_algorithm_implementation",
        "Implement complex algorithm with optimization"
    );
    
    let classified = system.classify_edit(&test_edit)?;
    
    println!("🔍 Cognitive Analysis Results:");
    if let Some(ref cognitive_ctx) = classified.cognitive_analysis {
        println!("   Cognitive analysis enabled and executed");
        println!("   Context keys: {:?}", cognitive_ctx.flatten().keys().collect::<Vec<_>>());
    } else {
        println!("   Cognitive analysis not available");
    }
    
    println!("   Classification Confidence: {:.3}", classified.classification_confidence);
    println!("   Enhanced reasoning available: {}", !classified.reasoning.is_empty());
    
    println!("✅ Demo 6 Complete: Cognitive integration working!\n");
    Ok(())
}

fn create_test_edit(path: &str, content: &str, reason: &str) -> ModifiableEdit {
    let proposed = ProposedEdit {
        file: path.to_string(),
        line_range: (1, 5),
        new_code: content.to_string(),
        reason: reason.to_string(),
        confidence: 0.9,
    };
    ModifiableEdit::from_proposed_edit(proposed)
}

fn print_classification_summary(classified: &soma_core::classification::ClassifiedEdit) {
    println!("   📂 File: {}", classified.edit.base_edit.file);
    println!("   📊 Category: {:?}", classified.category);
    println!("   ⚠️  Risk Score: {:.3}", classified.risk_assessment.overall_score);
    println!("   🎯 Priority Score: {:.3}", classified.priority_score);
    println!("   🔒 Confidence: {:.3}", classified.classification_confidence);
    
    match &classified.recommendation {
        ClassificationRecommendation::AutoApprove { confidence } => {
            println!("   ✅ Recommendation: Auto-approve ({:.1}%)", confidence * 100.0);
        }
        ClassificationRecommendation::RequireReview { concerns } => {
            println!("   🔍 Recommendation: Review required");
            if !concerns.is_empty() {
                println!("      Concerns: {}", concerns.join(", "));
            }
        }
        ClassificationRecommendation::Escalate { target_level, reason } => {
            println!("   ⬆️  Recommendation: Escalate to {}", target_level);
            println!("      Reason: {}", reason);
        }
        ClassificationRecommendation::Reject { reason } => {
            println!("   ❌ Recommendation: Reject - {}", reason);
        }
        ClassificationRecommendation::RequestInfo { questions } => {
            println!("   ❓ Recommendation: Request info");
            if !questions.is_empty() {
                println!("      Questions: {}", questions.join(", "));
            }
        }
    }
}