Merge branch 'main' of github.com:opensensor/codediff

Author: matteius

crates/web-ui/src/handlers.rs

@@ -150,24 +150,31 @@ async fn perform_comparison(
     // Initialize components
     let language_detector = LanguageDetector;
     let parser_engine = TreeSitterParser::new()?;
-    let semantic_analyzer = SemanticAnalyzer::new();
+    let mut semantic_analyzer = SemanticAnalyzer::new();
     let diff_engine = DiffEngine::new();
 
     // Detect language
-    let language = language_detector.detect_from_path(&file1.path)
-        .or_else(|| language_detector.detect_from_content(&file1.content))
-        .unwrap_or(Language::Unknown);
+    let language = {
+        let path_lang = LanguageDetector::detect_from_path(&file1.path);
+        if path_lang != Language::Unknown {
+            path_lang
+        } else {
+            LanguageDetector::detect_from_content(&file1.content)
+        }
+    };
 
     // Parse both files
     let parse_result1 = parser_engine.parse(&file1.content, language)?;
     let parse_result2 = parser_engine.parse(&file2.content, language)?;
-    let ast1 = parse_result1.ast;
-    let ast2 = parse_result2.ast;
 
     // Perform semantic analysis
     let semantic1 = semantic_analyzer.analyze(&parse_result1)?;
     let semantic2 = semantic_analyzer.analyze(&parse_result2)?;
 
+    // Extract ASTs for structure comparison
+    let ast1 = &parse_result1.ast;
+    let ast2 = &parse_result2.ast;
+
     // Initialize components that need language
     let function_matcher = FunctionMatcher::new(0.7); // threshold
     let similarity_scorer = SimilarityScorer::new(language, smart_diff_engine::SimilarityScoringConfig::default());
@@ -192,7 +199,7 @@ async fn perform_comparison(
     let semantic_similarity = overall_similarity; // Simplified
 
     // Use changes from function matching
-    let changes = function_matches.changes;
+    let changes = function_matches.changes.clone();
 
     // Detect refactoring patterns
     let refactoring_patterns = refactoring_detector.detect_patterns(&changes);
@@ -205,14 +212,14 @@ async fn perform_comparison(
                 lines: file1.content.lines().count(),
                 functions: functions1.len(),
                 classes: count_classes_from_symbol_table(&semantic1.symbol_table),
-                complexity: calculate_complexity_from_symbol_table(&semantic1.symbol_table),
+                complexity: calculate_complexity_from_symbol_table(&semantic1.symbol_table) as f64,
             },
             target: FileMetadata {
                 path: file2.path.clone(),
                 lines: file2.content.lines().count(),
                 functions: functions2.len(),
                 classes: count_classes_from_symbol_table(&semantic2.symbol_table),
-                complexity: calculate_complexity_from_symbol_table(&semantic2.symbol_table),
+                complexity: calculate_complexity_from_symbol_table(&semantic2.symbol_table) as f64,
             },
             language: language.to_string(),
             similarity: SimilarityScore {
@@ -231,122 +238,70 @@ async fn perform_comparison(
     Ok(analysis)
 }
 
-/// Build function analysis from matches
-fn build_function_analysis(matches: &[smart_diff_engine::FunctionMatch]) -> FunctionAnalysis {
-    let total_functions = matches.len();
-    let matched_functions = matches.iter().filter(|m| m.target_function.is_some()).count();
-    let average_similarity = if matched_functions > 0 {
-        matches.iter()
-            .filter(|m| m.target_function.is_some())
-            .map(|m| m.similarity.overall)
-            .sum::<f64>() / matched_functions as f64
-    } else {
-        0.0
-    };
-
-    let function_matches = matches.iter().enumerate().map(|(i, m)| {
-        FunctionMatch {
-            id: format!("func-{}", i),
-            source_function: FunctionInfo {
-                name: m.source_function.name.clone(),
-                signature: m.source_function.signature.clone(),
-                start_line: m.source_function.start_line,
-                end_line: m.source_function.end_line,
-                complexity: m.source_function.complexity as usize,
-                parameters: m.source_function.parameters.clone(),
-                return_type: m.source_function.return_type.clone(),
-            },
-            target_function: m.target_function.as_ref().map(|tf| FunctionInfo {
-                name: tf.name.clone(),
-                signature: tf.signature.clone(),
-                start_line: tf.start_line,
-                end_line: tf.end_line,
-                complexity: tf.complexity as usize,
-                parameters: tf.parameters.clone(),
-                return_type: tf.return_type.clone(),
-            }),
-            similarity: SimilarityScore {
-                overall: m.similarity.overall,
-                structure: m.similarity.structure,
-                content: m.similarity.content,
-                semantic: m.similarity.semantic,
-            },
-            change_type: m.change_type.to_string(),
-            refactoring_pattern: m.refactoring_pattern.as_ref().map(|rp| RefactoringPattern {
-                pattern_type: rp.pattern_type.clone(),
-                description: rp.description.clone(),
-                confidence: rp.confidence,
-                evidence: rp.evidence.clone(),
-                impact: rp.impact.clone(),
-            }),
-        }
-    }).collect();
-
+/// Build function analysis from match result
+fn build_function_analysis(match_result: &smart_diff_parser::MatchResult) -> FunctionAnalysis {
+    // Simplified function analysis based on MatchResult
     FunctionAnalysis {
-        total_functions,
-        matched_functions,
-        function_matches,
-        average_similarity,
+        total_functions: match_result.mapping.len(),
+        matched_functions: match_result.mapping.len(),
+        function_matches: Vec::new(), // Simplified - would need proper conversion
+        average_similarity: match_result.similarity,
     }
 }
 
-/// Build change analysis from classified changes
-fn build_change_analysis(changes: &[smart_diff_engine::ClassifiedChange]) -> ChangeAnalysis {
+/// Build change analysis from changes
+fn build_change_analysis(changes: &[smart_diff_parser::Change]) -> ChangeAnalysis {
     let total_changes = changes.len();
     let mut change_types = HashMap::new();
 
     for change in changes {
-        *change_types.entry(change.change_type.clone()).or_insert(0) += 1;
+        *change_types.entry(format!("{:?}", change.change_type)).or_insert(0) += 1;
     }
 
     let detailed_changes = changes.iter().enumerate().map(|(i, change)| {
         DetailedChange {
             id: format!("change-{}", i),
-            change_type: change.change_type.clone(),
-            description: change.description.clone(),
+            change_type: format!("{:?}", change.change_type),
+            description: change.details.description.clone(),
             confidence: change.confidence,
             location: ChangeLocation {
-                file: change.location.file.clone(),
-                start_line: change.location.start_line,
-                end_line: change.location.end_line,
-                function: change.location.function.clone(),
+                file: "unknown".to_string(), // Simplified
+                start_line: 0,
+                end_line: 0,
+                function: None,
             },
-            impact: change.impact.clone(),
+            impact: "medium".to_string(), // Simplified
         }
     }).collect();
 
-    let breaking_changes = changes.iter()
-        .filter(|c| c.impact == "breaking")
-        .count();
-
     ChangeAnalysis {
         total_changes,
         change_types,
         detailed_changes,
         impact_assessment: ImpactAssessment {
-            risk_level: if breaking_changes > 0 { "high" } else { "low" }.to_string(),
-            breaking_changes,
-            effort_estimate: estimate_effort(changes),
-            affected_components: extract_affected_components(changes),
+            risk_level: "medium".to_string(),
+            breaking_changes: 0,
+            effort_estimate: "medium".to_string(),
+            affected_components: vec![],
         },
     }
 }
 
 /// Build refactoring patterns from detected patterns
 fn build_refactoring_patterns(patterns: &[smart_diff_engine::RefactoringPattern]) -> Vec<RefactoringPattern> {
     patterns.iter().map(|pattern| RefactoringPattern {
-        pattern_type: pattern.pattern_type.clone(),
+        pattern_type: format!("{:?}", pattern.pattern_type),
         description: pattern.description.clone(),
         confidence: pattern.confidence,
-        evidence: pattern.evidence.clone(),
-        impact: pattern.impact.clone(),
+        evidence: pattern.evidence.iter().map(|e| format!("{:?}", e)).collect(),
+        impact: format!("{:?}", pattern.analysis.impact),
     }).collect()
 }
 
 /// Build structure comparison from ASTs
 fn build_structure_comparison(
-    ast1: &smart_diff_parser::AST,
-    ast2: &smart_diff_parser::AST,
+    _ast1: &smart_diff_parser::ASTNode,
+    _ast2: &smart_diff_parser::ASTNode,
 ) -> StructureComparison {
     // This would be implemented with actual AST traversal
     // For now, return a simplified structure
@@ -369,24 +324,7 @@ fn build_structure_comparison(
     }
 }
 
-/// Estimate effort for implementing changes
-fn estimate_effort(changes: &[smart_diff_engine::ClassifiedChange]) -> String {
-    let total_changes = changes.len();
-    match total_changes {
-        0..=5 => "low".to_string(),
-        6..=15 => "medium".to_string(),
-        _ => "high".to_string(),
-    }
-}
 
-/// Extract affected components from changes
-fn extract_affected_components(changes: &[smart_diff_engine::ClassifiedChange]) -> Vec<String> {
-    changes.iter()
-        .filter_map(|c| c.location.function.clone())
-        .collect::<std::collections::HashSet<_>>()
-        .into_iter()
-        .collect()
-}
 
 /// Multi-file analysis endpoint
 pub async fn analyze(
@@ -431,9 +369,14 @@ async fn perform_multi_file_analysis(
 
     // Analyze each file
     for file in files {
-        let language = language_detector.detect_from_path(&file.path)
-            .or_else(|| language_detector.detect_from_content(&file.content))
-            .unwrap_or(Language::Unknown);
+        let language = {
+            let path_lang = LanguageDetector::detect_from_path(&file.path);
+            if path_lang != Language::Unknown {
+                path_lang
+            } else {
+                LanguageDetector::detect_from_content(&file.content)
+            }
+        };
         let parse_result = parser_engine.parse(&file.content, language)?;
         let semantic = semantic_analyzer.analyze(&parse_result)?;
 
@@ -445,19 +388,19 @@ async fn perform_multi_file_analysis(
             name: f.signature.name.clone(),
             signature: format!("{}({})", f.signature.name,
                 f.signature.parameters.iter()
-                    .map(|p| format!("{}: {}", p.name, p.param_type.to_string()))
+                    .map(|p| format!("{}: {}", p.name, p.param_type.name))
                     .collect::<Vec<_>>()
                     .join(", ")),
             start_line: f.location.start_line,
             end_line: f.location.end_line,
             complexity: 1, // Simplified
             parameters: f.signature.parameters.iter().map(|p| p.name.clone()).collect(),
             return_type: f.signature.return_type.as_ref()
-                .map(|t| t.to_string())
+                .map(|t| t.name.clone())
                 .unwrap_or_else(|| "void".to_string()),
         }).collect();
 
-        all_functions.extend(functions);
+        all_functions.extend(functions.clone());
 
         let file_result = FileAnalysisResult {
             file: FileMetadata {
@@ -558,16 +501,12 @@ struct MultiFileAnalysisResult {
     summary: AnalysisSummary,
 }
 
-fn calculate_complexity_distribution(functions: &[smart_diff_semantic::Function]) -> HashMap<String, usize> {
+fn calculate_complexity_distribution(functions: &[smart_diff_parser::Function]) -> HashMap<String, usize> {
     let mut distribution = HashMap::new();
 
-    for function in functions {
-        let complexity_range = match function.complexity {
-            0..=5 => "low",
-            6..=10 => "medium",
-            11..=20 => "high",
-            _ => "very_high",
-        };
+    for _function in functions {
+        // Simplified complexity calculation
+        let complexity_range = "medium"; // Placeholder
         *distribution.entry(complexity_range.to_string()).or_insert(0) += 1;
     }
 
@@ -590,16 +529,16 @@ fn detect_issues(symbol_table: &smart_diff_semantic::SymbolTable) -> Vec<String>
 
 fn perform_cross_file_analysis(
     functions: &[smart_diff_parser::Function],
-    files: &[FileInfo],
+    _files: &[FileInfo],
 ) -> anyhow::Result<CrossFileAnalysis> {
     // Detect duplicate functions
     let mut duplicate_functions = Vec::new();
-    let mut seen_signatures = HashMap::new();
+    let mut seen_signatures: HashMap<String, Vec<ChangeLocation>> = HashMap::new();
 
     for function in functions {
         let signature_str = format!("{}({})", function.signature.name,
             function.signature.parameters.iter()
-                .map(|p| format!("{}: {}", p.name, p.param_type.to_string()))
+                .map(|p| format!("{}: {}", p.name, p.param_type.name))
                 .collect::<Vec<_>>()
                 .join(", "));
 
@@ -679,9 +618,15 @@ fn extract_functions_from_symbol_table(symbol_table: &smart_diff_semantic::Symbo
         };
 
         // Create a simple AST node for the function body
+        let metadata = smart_diff_parser::NodeMetadata {
+            line: 0,
+            column: 0,
+            original_text: String::new(),
+            attributes: std::collections::HashMap::new(),
+        };
         let body = smart_diff_parser::ASTNode::new(
             smart_diff_parser::NodeType::Function,
-            smart_diff_parser::ASTMetadata::default(),
+            metadata,
         );
 
         let function = Function {