Fixing build errors

Author: matteius

crates/cli/src/cli.rs

@@ -10,11 +10,11 @@ use std::path::PathBuf;
 pub struct Cli {
     #[command(subcommand)]
     pub command: Commands,
-    
+
     /// Enable verbose output
     #[arg(short, long)]
     pub verbose: bool,
-    
+
     /// Configuration file path
     #[arg(short, long)]
     pub config: Option<PathBuf>,
@@ -27,32 +27,32 @@ pub enum Commands {
         /// First file or directory to compare
         #[arg(value_name = "FILE1")]
         file1: PathBuf,
-        
+
         /// Second file or directory to compare
         #[arg(value_name = "FILE2")]
         file2: PathBuf,
-        
+
         /// Output format
         #[arg(short, long, default_value = "text")]
         format: OutputFormat,
-        
+
         /// Compare directories recursively
         #[arg(short, long)]
         recursive: bool,
-        
+
         /// Ignore whitespace changes
         #[arg(long)]
         ignore_whitespace: bool,
-        
+
         /// Minimum similarity threshold (0.0-1.0)
         #[arg(long, default_value = "0.7")]
         threshold: f64,
-        
+
         /// Output file path
         #[arg(short, long)]
         output: Option<PathBuf>,
     },
-    
+
     /// Configuration management
     Config {
         #[command(subcommand)]
@@ -72,15 +72,15 @@ pub enum OutputFormat {
 pub enum ConfigAction {
     /// Show current configuration
     Show,
-    
+
     /// Set configuration value
     Set {
         /// Configuration key
         key: String,
         /// Configuration value
         value: String,
     },
-    
+
     /// Reset configuration to defaults
     Reset,
 }

crates/cli/src/commands/compare.rs

@@ -5,29 +5,30 @@ use anyhow::Result;
 
 pub async fn run(cli: Cli) -> Result<()> {
     println!("Compare command - placeholder implementation");
-    
-    if let crate::cli::Commands::Compare { 
-        file1, 
-        file2, 
+
+    if let crate::cli::Commands::Compare {
+        file1,
+        file2,
         format,
         recursive,
         ignore_whitespace,
         threshold,
         output,
-    } = cli.command {
+    } = cli.command
+    {
         println!("Comparing {} and {}", file1.display(), file2.display());
         println!("Format: {:?}", format);
         println!("Recursive: {}", recursive);
         println!("Ignore whitespace: {}", ignore_whitespace);
         println!("Threshold: {}", threshold);
-        
+
         if let Some(output_path) = output {
             println!("Output will be written to: {}", output_path.display());
         }
-        
+
         // TODO: Implement actual comparison logic
         println!("Comparison complete (placeholder)");
     }
-    
+
     Ok(())
 }

crates/cli/src/commands/config.rs

@@ -5,7 +5,7 @@ use anyhow::Result;
 
 pub async fn run(cli: Cli) -> Result<()> {
     println!("Config command - placeholder implementation");
-    
+
     if let crate::cli::Commands::Config { action } = cli.command {
         match action {
             crate::cli::ConfigAction::Show => {
@@ -24,6 +24,6 @@ pub async fn run(cli: Cli) -> Result<()> {
             }
         }
     }
-    
+
     Ok(())
 }

crates/cli/src/main.rs

@@ -1,5 +1,5 @@
 //! Smart Code Diff CLI
-//! 
+//!
 //! Command-line interface for the smart code diffing tool.
 
 use anyhow::Result;
@@ -20,11 +20,7 @@ async fn main() -> Result<()> {
     let cli = Cli::parse();
 
     match cli.command {
-        Commands::Compare { .. } => {
-            commands::compare::run(cli).await
-        }
-        Commands::Config { .. } => {
-            commands::config::run(cli).await
-        }
+        Commands::Compare { .. } => commands::compare::run(cli).await,
+        Commands::Config { .. } => commands::config::run(cli).await,
     }
 }

crates/cli/src/output.rs

@@ -8,7 +8,7 @@ pub struct OutputFormatter;
 impl OutputFormatter {
     pub fn format_diff_text(changes: &[String]) -> String {
         let mut output = String::new();
-        
+
         for change in changes {
             if change.starts_with('+') {
                 output.push_str(&format!("{}\n", change.green()));
@@ -18,17 +18,17 @@ impl OutputFormatter {
                 output.push_str(&format!("{}\n", change));
             }
         }
-        
+
         output
     }
-    
+
     pub fn format_diff_json(changes: &[String]) -> Result<String, serde_json::Error> {
         serde_json::to_string_pretty(changes)
     }
-    
+
     pub fn format_diff_html(changes: &[String]) -> String {
         let mut html = String::from("<div class=\"diff\">\n");
-        
+
         for change in changes {
             if change.starts_with('+') {
                 html.push_str(&format!("  <div class=\"addition\">{}</div>\n", change));
@@ -38,7 +38,7 @@ impl OutputFormatter {
                 html.push_str(&format!("  <div class=\"context\">{}</div>\n", change));
             }
         }
-        
+
         html.push_str("</div>");
         html
     }

crates/diff-engine/src/changes.rs

@@ -1,14 +1,18 @@
 //! Change classification and analysis
 
-use smart_diff_parser::{Change, ChangeType, CodeElement};
 use serde::{Deserialize, Serialize};
+use smart_diff_parser::{Change, ChangeType, CodeElement};
 
 /// Change classifier that categorizes detected changes
 pub struct ChangeClassifier;
 
 impl ChangeClassifier {
     /// Classify a change based on its characteristics
-    pub fn classify_change(&self, source: Option<&CodeElement>, target: Option<&CodeElement>) -> ChangeType {
+    pub fn classify_change(
+        &self,
+        source: Option<&CodeElement>,
+        target: Option<&CodeElement>,
+    ) -> ChangeType {
         match (source, target) {
             (None, Some(_)) => ChangeType::Add,
             (Some(_), None) => ChangeType::Delete,
@@ -30,18 +34,20 @@ impl ChangeClassifier {
             (None, None) => ChangeType::Modify, // Shouldn't happen
         }
     }
-    
+
     /// Detect if a change represents a function split
     pub fn detect_split(&self, source: &CodeElement, targets: &[CodeElement]) -> bool {
-        targets.len() > 1 && targets.iter().all(|t| {
-            t.name.contains(&source.name) || source.name.contains(&t.name)
-        })
+        targets.len() > 1
+            && targets
+                .iter()
+                .all(|t| t.name.contains(&source.name) || source.name.contains(&t.name))
     }
-    
+
     /// Detect if changes represent a function merge
     pub fn detect_merge(&self, sources: &[CodeElement], target: &CodeElement) -> bool {
-        sources.len() > 1 && sources.iter().all(|s| {
-            s.name.contains(&target.name) || target.name.contains(&s.name)
-        })
+        sources.len() > 1
+            && sources
+                .iter()
+                .all(|s| s.name.contains(&target.name) || target.name.contains(&s.name))
     }
 }

crates/diff-engine/src/engine.rs

@@ -1,12 +1,12 @@
 //! Main diff engine
 
-use crate::matching::FunctionMatcher;
-use crate::tree_edit::{TreeEditDistance, EditCost};
 use crate::changes::ChangeClassifier;
+use crate::matching::FunctionMatcher;
 use crate::refactoring::RefactoringDetector;
+use crate::tree_edit::{EditCost, TreeEditDistance};
+use serde::{Deserialize, Serialize};
 use smart_diff_parser::{Function, MatchResult};
 use thiserror::Error;
-use serde::{Deserialize, Serialize};
 
 /// Main diff engine that orchestrates the comparison process
 pub struct DiffEngine {
@@ -41,10 +41,10 @@ pub struct DiffStatistics {
 pub enum DiffError {
     #[error("Comparison failed: {0}")]
     ComparisonFailed(String),
-    
+
     #[error("Invalid input: {0}")]
     InvalidInput(String),
-    
+
     #[error("Processing error: {0}")]
     ProcessingError(String),
 }
@@ -58,39 +58,55 @@ impl DiffEngine {
             refactoring_detector: RefactoringDetector::new(),
         }
     }
-    
+
     /// Compare two sets of functions
-    pub fn compare_functions(&self, source_functions: &[Function], target_functions: &[Function]) -> Result<DiffResult, DiffError> {
+    pub fn compare_functions(
+        &self,
+        source_functions: &[Function],
+        target_functions: &[Function],
+    ) -> Result<DiffResult, DiffError> {
         let start_time = std::time::Instant::now();
-        
+
         // Match functions
-        let match_result = self.function_matcher.match_functions(source_functions, target_functions);
-        
+        let match_result = self
+            .function_matcher
+            .match_functions(source_functions, target_functions);
+
         // Detect refactoring patterns
-        let refactoring_patterns = self.refactoring_detector.detect_patterns(&match_result.changes);
-        
+        let refactoring_patterns = self
+            .refactoring_detector
+            .detect_patterns(&match_result.changes);
+
         // Calculate statistics
-        let statistics = self.calculate_statistics(source_functions, target_functions, &match_result);
-        
+        let statistics =
+            self.calculate_statistics(source_functions, target_functions, &match_result);
+
         let execution_time_ms = start_time.elapsed().as_millis() as u64;
-        
+
         Ok(DiffResult {
             match_result,
             refactoring_patterns,
             execution_time_ms,
             statistics,
         })
     }
-    
-    fn calculate_statistics(&self, source: &[Function], target: &[Function], match_result: &MatchResult) -> DiffStatistics {
+
+    fn calculate_statistics(
+        &self,
+        source: &[Function],
+        target: &[Function],
+        match_result: &MatchResult,
+    ) -> DiffStatistics {
         let functions_compared = source.len() + target.len();
         let functions_matched = match_result.mapping.len();
         let functions_added = match_result.unmatched_target.len();
         let functions_removed = match_result.unmatched_source.len();
-        let functions_modified = match_result.changes.iter()
+        let functions_modified = match_result
+            .changes
+            .iter()
             .filter(|c| matches!(c.change_type, smart_diff_parser::ChangeType::Modify))
             .count();
-        
+
         DiffStatistics {
             functions_compared,
             functions_matched,

crates/diff-engine/src/lib.rs

@@ -1,25 +1,27 @@
 //! Smart Code Diff Engine
-//! 
+//!
 //! Core diff computation engine that implements tree edit distance algorithms,
 //! function matching, and change classification.
 
-pub mod matching;
-pub mod tree_edit;
 pub mod changes;
+pub mod engine;
+pub mod matching;
 pub mod refactoring;
 pub mod similarity_scorer;
-pub mod engine;
+pub mod tree_edit;
 
-pub use matching::{FunctionMatcher, MatchResult, SimilarityScore};
-pub use tree_edit::{TreeEditDistance, EditOperation, EditCost};
-pub use changes::{Change, ChangeType, ChangeClassifier};
+pub use changes::ChangeClassifier;
+pub use smart_diff_parser::{Change, ChangeType};
+pub use engine::{DiffEngine, DiffError, DiffResult};
+pub use matching::{FunctionMatcher, SimilarityScore};
+pub use smart_diff_parser::MatchResult;
 pub use refactoring::{RefactoringDetector, RefactoringPattern};
 pub use similarity_scorer::{
-    SimilarityScorer, SimilarityScoringConfig, ComprehensiveSimilarityScore,
-    ASTSimilarityScore, ContextSimilarityScore, SemanticSimilarityMetrics,
-    MatchType, DetailedSimilarityBreakdown, SimilarityFactor
+    ASTSimilarityScore, ComprehensiveSimilarityScore, ContextSimilarityScore,
+    DetailedSimilarityBreakdown, MatchType, SemanticSimilarityMetrics, SimilarityFactor,
+    SimilarityScorer, SimilarityScoringConfig,
 };
-pub use engine::{DiffEngine, DiffResult, DiffError};
+pub use tree_edit::{EditCost, EditOperation, TreeEditDistance};
 
 /// Re-export commonly used types
 pub type Result<T> = std::result::Result<T, DiffError>;