core utilities & commands

crates/cli/src/commands/analyze.rs

···
+use anyhow::Result;
+use mccabre_core::{
+    cloner::CloneDetector,
+    complexity::{CyclomaticMetrics, LocMetrics},
+    config::Config,
+    loader::FileLoader,
+    reporter::{FileReport, Report},
+};
+use owo_colors::OwoColorize;
+use std::path::PathBuf;
+
+pub fn run(
+    path: PathBuf, json: bool, threshold: Option<usize>, min_tokens: Option<usize>, config_path: Option<PathBuf>,
+    respect_gitignore: bool,
+) -> Result<()> {
+    let config = if let Some(config_path) = config_path {
+        Config::from_file(config_path)?
+    } else {
+        Config::load_default()?
+    };
+
+    let config = config.merge_with_cli(threshold, min_tokens, Some(respect_gitignore));
+    let loader = FileLoader::new().with_gitignore(config.files.respect_gitignore);
+    let files = loader.load(&path)?;
+
+    if files.is_empty() {
+        eprintln!("{}", "No supported files found".yellow());
+        return Ok(());
+    }
+
+    let mut file_reports = Vec::new();
+
+    for file in &files {
+        let loc = LocMetrics::calculate(&file.content, file.language)?;
+        let cyclomatic = CyclomaticMetrics::calculate(&file.content, file.language)?;
+
+        file_reports.push(FileReport { path: file.path.clone(), loc, cyclomatic });
+    }
+
+    let clones = if config.clones.enabled {
+        let detector = CloneDetector::new(config.clones.min_tokens);
+        let files_for_clone_detection: Vec<_> = files
+            .iter()
+            .map(|f| (f.path.clone(), f.content.clone(), f.language))
+            .collect();
+        detector.detect_across_files(&files_for_clone_detection)?
+    } else {
+        Vec::new()
+    };
+
+    let report = Report::new(file_reports, clones);
+
+    if json {
+        println!("{}", report.to_json()?);
+    } else {
+        print_pretty_report(&report, &config);
+    }
+
+    Ok(())
+}
+
+fn print_pretty_report(report: &Report, config: &Config) {
+    println!("{}", "=".repeat(80).cyan());
+    println!("{}", "MCCABRE CODE ANALYSIS REPORT".cyan().bold());
+    println!("{}", "=".repeat(80).cyan());
+    println!();
+
+    println!("{}", "SUMMARY".green().bold());
+    println!("{}", "-".repeat(80).cyan());
+    println!("Total files analyzed:        {}", report.summary.total_files.bold());
+    println!(
+        "Total physical LOC:          {}",
+        report.summary.total_physical_loc.bold()
+    );
+    println!(
+        "Total logical LOC:           {}",
+        report.summary.total_logical_loc.bold()
+    );
+    println!(
+        "Average complexity:          {}",
+        format!("{:.2}", report.summary.avg_complexity).bold()
+    );
+    println!("Maximum complexity:          {}", report.summary.max_complexity.bold());
+    println!(
+        "High complexity files:       {}",
+        report.summary.high_complexity_files.bold()
+    );
+    println!("Clone groups detected:       {}", report.summary.total_clones.bold());
+    println!();
+
+    if !report.files.is_empty() {
+        println!("{}", "FILE METRICS".green().bold());
+        println!("{}", "-".repeat(80).cyan());
+
+        for file in &report.files {
+            println!("{} {}", "FILE:".blue().bold(), file.path.display().bold());
+
+            let complexity_value = file.cyclomatic.file_complexity;
+            let complexity_text = format!("Cyclomatic Complexity:   {}", complexity_value);
+
+            if complexity_value > config.complexity.error_threshold {
+                println!("    {}", complexity_text.red().bold());
+            } else if complexity_value > config.complexity.warning_threshold {
+                println!("    {}", complexity_text.yellow());
+            } else {
+                println!("    {}", complexity_text.green());
+            }
+            println!("    Physical LOC:            {}", file.loc.physical);
+            println!("    Logical LOC:             {}", file.loc.logical);
+            println!("    Comment lines:           {}", file.loc.comments);
+            println!("    Blank lines:             {}", file.loc.blank);
+            println!();
+
+            if !file.cyclomatic.functions.is_empty() {
+                println!("    {}:", "Functions".magenta());
+                for func in &file.cyclomatic.functions {
+                    let func_text = format!(
+                        "      - {} (line {}): complexity {}",
+                        func.name, func.line, func.complexity
+                    );
+
+                    if func.complexity > config.complexity.error_threshold {
+                        println!("{}", func_text.red());
+                    } else if func.complexity > config.complexity.warning_threshold {
+                        println!("{}", func_text.yellow());
+                    } else {
+                        println!("{}", func_text);
+                    }
+                }
+                println!();
+            }
+        }
+    }
+
+    if !report.clones.is_empty() {
+        println!("{}", "DETECTED CLONES".green().bold());
+        println!("{}", "-".repeat(80).cyan());
+
+        for clone in &report.clones {
+            println!(
+                "{} {} {} {} {} {}",
+                "Clone Group".yellow(),
+                format!("#{}", clone.id).yellow().bold(),
+                "(length:".dimmed(),
+                format!("{} tokens", clone.length).bold(),
+                format!("{} occurrences)", clone.locations.len()).bold(),
+                "".dimmed()
+            );
+
+            for loc in &clone.locations {
+                println!(
+                    "  {} {}:{}",
+                    "-".dimmed(),
+                    loc.file.display(),
+                    format!("{}-{}", loc.start_line, loc.end_line).dimmed()
+                );
+            }
+            println!();
+        }
+    }
+
+    println!("{}", "=".repeat(80).cyan());
+}

crates/cli/src/commands/clones.rs

···
+use anyhow::Result;
+use mccabre_core::{cloner::CloneDetector, config::Config, loader::FileLoader, reporter::Report};
+use owo_colors::OwoColorize;
+use std::path::PathBuf;
+
+pub fn run(
+    path: PathBuf, json: bool, min_tokens: Option<usize>, config_path: Option<PathBuf>, respect_gitignore: bool,
+) -> Result<()> {
+    let config = if let Some(config_path) = config_path {
+        Config::from_file(config_path)?
+    } else {
+        Config::load_default()?
+    };
+
+    let config = config.merge_with_cli(None, min_tokens, Some(respect_gitignore));
+    let loader = FileLoader::new().with_gitignore(config.files.respect_gitignore);
+    let files = loader.load(&path)?;
+
+    if files.is_empty() {
+        eprintln!("{}", "No supported files found".yellow());
+        return Ok(());
+    }
+
+    let detector = CloneDetector::new(config.clones.min_tokens);
+    let files_for_clone_detection: Vec<_> = files
+        .iter()
+        .map(|f| (f.path.clone(), f.content.clone(), f.language))
+        .collect();
+    let clones = detector.detect_across_files(&files_for_clone_detection)?;
+
+    let report = Report::new(Vec::new(), clones);
+
+    if json {
+        println!("{}", report.to_json()?);
+    } else {
+        print_clones_report(&report);
+    }
+
+    Ok(())
+}
+
+fn print_clones_report(report: &Report) {
+    println!("{}", "=".repeat(80).cyan());
+    println!("{}", "CLONE DETECTION REPORT".cyan().bold());
+    println!("{}\n", "=".repeat(80).cyan());
+
+    if report.clones.is_empty() {
+        println!("{}", "No clones detected!".green().bold());
+    } else {
+        println!(
+            "{} {} {}",
+            "Found".green().bold(),
+            report.clones.len().to_string().yellow().bold(),
+            "clone groups".green().bold()
+        );
+        println!();
+
+        for clone in &report.clones {
+            println!(
+                "{} {} {} {} {} {}",
+                "Clone Group".yellow(),
+                format!("#{}", clone.id).yellow().bold(),
+                "(length:".dimmed(),
+                format!("{} tokens", clone.length).bold(),
+                format!("{} occurrences)", clone.locations.len()).bold(),
+                "".dimmed()
+            );
+
+            for loc in &clone.locations {
+                println!(
+                    "  {} {}:{}",
+                    "-".dimmed(),
+                    loc.file.display(),
+                    format!("{}-{}", loc.start_line, loc.end_line).dimmed()
+                );
+            }
+            println!();
+        }
+    }
+
+    println!("{}", "=".repeat(80).cyan());
+}

crates/cli/src/commands/complexity.rs

···
+use anyhow::Result;
+use mccabre_core::{
+    complexity::{CyclomaticMetrics, LocMetrics},
+    config::Config,
+    loader::FileLoader,
+    reporter::{FileReport, Report},
+};
+use owo_colors::OwoColorize;
+use std::path::PathBuf;
+
+pub fn run(
+    path: PathBuf, json: bool, threshold: Option<usize>, config_path: Option<PathBuf>, respect_gitignore: bool,
+) -> Result<()> {
+    let config = if let Some(config_path) = config_path {
+        Config::from_file(config_path)?
+    } else {
+        Config::load_default()?
+    };
+
+    let config = config.merge_with_cli(threshold, None, Some(respect_gitignore));
+    let loader = FileLoader::new().with_gitignore(config.files.respect_gitignore);
+    let files = loader.load(&path)?;
+
+    if files.is_empty() {
+        eprintln!("{}", "No supported files found".yellow());
+        return Ok(());
+    }
+
+    let mut file_reports = Vec::new();
+
+    for file in &files {
+        let loc = LocMetrics::calculate(&file.content, file.language)?;
+        let cyclomatic = CyclomaticMetrics::calculate(&file.content, file.language)?;
+
+        file_reports.push(FileReport { path: file.path.clone(), loc, cyclomatic });
+    }
+
+    let report = Report::new(file_reports, Vec::new());
+
+    if json {
+        println!("{}", report.to_json()?);
+    } else {
+        print_complexity_report(&report, &config);
+    }
+
+    Ok(())
+}
+
+fn print_complexity_report(report: &Report, config: &Config) {
+    println!("{}", "=".repeat(80).cyan());
+    println!("{}", "COMPLEXITY ANALYSIS".cyan().bold());
+    println!("{}\n", "=".repeat(80).cyan());
+
+    println!("{}", "SUMMARY".green().bold());
+    println!("{}", "-".repeat(80).cyan());
+    println!("Total files analyzed:        {}", report.summary.total_files.bold());
+    println!(
+        "Total physical LOC:          {}",
+        report.summary.total_physical_loc.bold()
+    );
+    println!(
+        "Total logical LOC:           {}",
+        report.summary.total_logical_loc.bold()
+    );
+    println!(
+        "Average complexity:          {}",
+        format!("{:.2}", report.summary.avg_complexity).bold()
+    );
+    println!("Maximum complexity:          {}", report.summary.max_complexity.bold());
+    println!(
+        "High complexity files:       {}\n",
+        report.summary.high_complexity_files.bold()
+    );
+
+    println!("{}", "FILE METRICS".green().bold());
+    println!("{}", "-".repeat(80).cyan());
+
+    for file in &report.files {
+        println!("{} {}", "FILE:".blue().bold(), file.path.display().bold());
+
+        let complexity_value = file.cyclomatic.file_complexity;
+        let complexity_text = format!("Cyclomatic Complexity:   {}", complexity_value);
+
+        if complexity_value > config.complexity.error_threshold {
+            println!("    {}", complexity_text.red().bold());
+        } else if complexity_value > config.complexity.warning_threshold {
+            println!("    {}", complexity_text.yellow());
+        } else {
+            println!("    {}", complexity_text.green());
+        }
+        println!("    Physical LOC:            {}", file.loc.physical);
+        println!("    Logical LOC:             {}", file.loc.logical);
+        println!("    Comment lines:           {}", file.loc.comments);
+        println!("    Blank lines:             {}\n", file.loc.blank);
+
+        if !file.cyclomatic.functions.is_empty() {
+            println!("    {}:", "Functions".magenta());
+            for func in &file.cyclomatic.functions {
+                let func_text = format!(
+                    "      - {} (line {}): complexity {}",
+                    func.name, func.line, func.complexity
+                );
+
+                if func.complexity > config.complexity.error_threshold {
+                    println!("{}", func_text.red());
+                } else if func.complexity > config.complexity.warning_threshold {
+                    println!("{}", func_text.yellow());
+                } else {
+                    println!("{}", func_text);
+                }
+            }
+            println!();
+        }
+    }
+
+    println!("{}", "=".repeat(80).cyan());
+}

crates/cli/src/commands/dump_config.rs

···
+use anyhow::Result;
+use mccabre_core::config::Config;
+use owo_colors::OwoColorize;
+use std::path::PathBuf;
+
+pub fn run(config_path: Option<PathBuf>) -> Result<()> {
+    let config = if let Some(path) = config_path {
+        println!("{} {}", "Loading config from:".blue(), path.display());
+        Config::from_file(&path)?
+    } else {
+        println!("{}", "Using default configuration".blue());
+        Config::load_default()?
+    };
+
+    println!();
+    println!("{}", "CONFIGURATION".green().bold());
+    println!("{}", "=".repeat(80).cyan());
+    println!();
+
+    println!("{}", "Complexity Settings:".yellow().bold());
+    println!("  Warning threshold:     {}", config.complexity.warning_threshold);
+    println!("  Error threshold:       {}", config.complexity.error_threshold);
+    println!();
+
+    println!("{}", "Clone Detection Settings:".yellow().bold());
+    println!("  Enabled:               {}", config.clones.enabled);
+    println!("  Minimum tokens:        {}", config.clones.min_tokens);
+    println!();
+
+    println!("{}", "File Settings:".yellow().bold());
+    println!("  Respect .gitignore:    {}", config.files.respect_gitignore);
+    println!();
+
+    println!("{}", "=".repeat(80).cyan());
+    println!();
+    println!("{}", "To save this configuration, create a mccabre.toml file.".dimmed());
+
+    Ok(())
+}

crates/cli/src/commands/mod.rs

···
+pub mod analyze;
+pub mod clones;
+pub mod complexity;
+pub mod dump_config;

crates/cli/src/main.rs

···
-fn main() {
-    println!("Hello, world!");
+mod commands;
+
+use anyhow::Result;
+use clap::{Parser, Subcommand};
+use std::path::PathBuf;
+
+#[derive(Parser)]
+#[command(name = "mccabre")]
+#[command(about = "Code complexity & clone detection tool", long_about = None)]
+#[command(version)]
+struct Cli {
+    #[command(subcommand)]
+    command: Commands,
+}
+
+#[derive(Subcommand)]
+enum Commands {
+    /// Run full analysis (complexity + clones + LOC)
+    Analyze {
+        /// Path to file or directory to analyze
+        #[arg(value_name = "PATH", default_value = ".")]
+        path: PathBuf,
+
+        /// Output in JSON format
+        #[arg(short, long)]
+        json: bool,
+
+        /// Complexity threshold for warnings
+        #[arg(long)]
+        threshold: Option<usize>,
+
+        /// Minimum tokens for clone detection
+        #[arg(long, default_value = "30")]
+        min_tokens: usize,
+
+        /// Path to config file
+        #[arg(short, long)]
+        config: Option<PathBuf>,
+
+        /// Disable gitignore awareness
+        #[arg(long)]
+        no_gitignore: bool,
+    },
+
+    /// Analyze cyclomatic complexity and LOC only
+    Complexity {
+        /// Path to file or directory to analyze
+        #[arg(value_name = "PATH", default_value = ".")]
+        path: PathBuf,
+
+        /// Output in JSON format
+        #[arg(short, long)]
+        json: bool,
+
+        /// Complexity threshold for warnings
+        #[arg(long)]
+        threshold: Option<usize>,
+
+        /// Path to config file
+        #[arg(short, long)]
+        config: Option<PathBuf>,
+
+        /// Disable gitignore awareness
+        #[arg(long)]
+        no_gitignore: bool,
+    },
+
+    /// Detect code clones only
+    Clones {
+        /// Path to file or directory to analyze
+        #[arg(value_name = "PATH", default_value = ".")]
+        path: PathBuf,
+
+        /// Output in JSON format
+        #[arg(short, long)]
+        json: bool,
+
+        /// Minimum tokens for clone detection
+        #[arg(long, default_value = "30")]
+        min_tokens: usize,
+
+        /// Path to config file
+        #[arg(short, long)]
+        config: Option<PathBuf>,
+
+        /// Disable gitignore awareness
+        #[arg(long)]
+        no_gitignore: bool,
+    },
+
+    /// Display current configuration
+    DumpConfig {
+        /// Path to config file (if not specified, shows defaults)
+        #[arg(short, long)]
+        config: Option<PathBuf>,
+    },
+}
+
+fn main() -> Result<()> {
+    let cli = Cli::parse();
+
+    match cli.command {
+        Commands::Analyze { path, json, threshold, min_tokens, config, no_gitignore } => {
+            commands::analyze::run(path, json, threshold, Some(min_tokens), config, !no_gitignore)
+        }
+
+        Commands::Complexity { path, json, threshold, config, no_gitignore } => {
+            commands::complexity::run(path, json, threshold, config, !no_gitignore)
+        }
+
+        Commands::Clones { path, json, min_tokens, config, no_gitignore } => {
+            commands::clones::run(path, json, Some(min_tokens), config, !no_gitignore)
+        }
+
+        Commands::DumpConfig { config } => commands::dump_config::run(config),
+    }
 }

crates/core/src/config.rs

···
+use crate::error::{MccabreError, Result};
+use serde::{Deserialize, Serialize};
+use std::fs;
+use std::path::Path;
+
+/// Configuration for mccabre analysis
+#[derive(Debug, Clone, Serialize, Deserialize, Default)]
+pub struct Config {
+    /// Cyclomatic complexity thresholds
+    #[serde(default)]
+    pub complexity: ComplexityConfig,
+
+    /// Clone detection settings
+    #[serde(default)]
+    pub clones: CloneConfig,
+
+    /// File filtering settings
+    #[serde(default)]
+    pub files: FileConfig,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct ComplexityConfig {
+    /// Threshold for warning level (default: 10)
+    #[serde(default = "default_warning_threshold")]
+    pub warning_threshold: usize,
+
+    /// Threshold for error level (default: 20)
+    #[serde(default = "default_error_threshold")]
+    pub error_threshold: usize,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct CloneConfig {
+    /// Minimum number of tokens for clone detection (default: 30)
+    #[serde(default = "default_min_tokens")]
+    pub min_tokens: usize,
+
+    /// Whether to enable clone detection (default: true)
+    #[serde(default = "default_true")]
+    pub enabled: bool,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct FileConfig {
+    /// Whether to respect .gitignore (default: true)
+    #[serde(default = "default_true")]
+    pub respect_gitignore: bool,
+}
+
+impl Default for ComplexityConfig {
+    fn default() -> Self {
+        Self { warning_threshold: default_warning_threshold(), error_threshold: default_error_threshold() }
+    }
+}
+
+impl Default for CloneConfig {
+    fn default() -> Self {
+        Self { min_tokens: default_min_tokens(), enabled: default_true() }
+    }
+}
+
+impl Default for FileConfig {
+    fn default() -> Self {
+        Self { respect_gitignore: default_true() }
+    }
+}
+
+fn default_warning_threshold() -> usize {
+    10
+}
+
+fn default_error_threshold() -> usize {
+    20
+}
+
+fn default_min_tokens() -> usize {
+    30
+}
+
+fn default_true() -> bool {
+    true
+}
+
+impl Config {
+    /// Load configuration from a TOML file
+    pub fn from_file<P: AsRef<Path>>(path: P) -> Result<Self> {
+        let content = fs::read_to_string(path.as_ref())
+            .map_err(|e| MccabreError::FileRead { path: path.as_ref().to_path_buf(), source: e })?;
+
+        toml::from_str(&content).map_err(|e| MccabreError::InvalidConfig(e.to_string()))
+    }
+
+    /// Try to load configuration from default locations
+    /// Looks for: mccabre.toml, .mccabre.toml, .mccabre/config.toml
+    pub fn load_default() -> Result<Self> {
+        let candidates = vec!["mccabre.toml", ".mccabre.toml", ".mccabre/config.toml"];
+
+        for path in candidates {
+            if Path::new(path).exists() {
+                return Self::from_file(path);
+            }
+        }
+
+        Ok(Self::default())
+    }
+
+    /// Save configuration to a TOML file
+    pub fn save<P: AsRef<Path>>(&self, path: P) -> Result<()> {
+        let content = toml::to_string_pretty(self).map_err(|e| MccabreError::InvalidConfig(e.to_string()))?;
+
+        fs::write(path.as_ref(), content)
+            .map_err(|e| MccabreError::FileRead { path: path.as_ref().to_path_buf(), source: e })?;
+
+        Ok(())
+    }
+
+    /// Merge with CLI overrides
+    pub fn merge_with_cli(
+        mut self, complexity_threshold: Option<usize>, min_tokens: Option<usize>, respect_gitignore: Option<bool>,
+    ) -> Self {
+        if let Some(threshold) = complexity_threshold {
+            self.complexity.warning_threshold = threshold;
+        }
+
+        if let Some(min) = min_tokens {
+            self.clones.min_tokens = min;
+        }
+
+        if let Some(respect) = respect_gitignore {
+            self.files.respect_gitignore = respect;
+        }
+
+        self
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use tempfile::TempDir;
+
+    #[test]
+    fn test_default_config() {
+        let config = Config::default();
+        assert_eq!(config.complexity.warning_threshold, 10);
+        assert_eq!(config.complexity.error_threshold, 20);
+        assert_eq!(config.clones.min_tokens, 30);
+        assert!(config.clones.enabled);
+        assert!(config.files.respect_gitignore);
+    }
+
+    #[test]
+    fn test_save_and_load() {
+        let temp_dir = TempDir::new().unwrap();
+        let config_path = temp_dir.path().join("test_config.toml");
+
+        let config = Config::default();
+        config.save(&config_path).unwrap();
+
+        let loaded = Config::from_file(&config_path).unwrap();
+        assert_eq!(loaded.complexity.warning_threshold, config.complexity.warning_threshold);
+        assert_eq!(loaded.clones.min_tokens, config.clones.min_tokens);
+    }
+
+    #[test]
+    fn test_merge_with_cli() {
+        let mut config = Config::default();
+        config = config.merge_with_cli(Some(15), Some(40), Some(false));
+
+        assert_eq!(config.complexity.warning_threshold, 15);
+        assert_eq!(config.clones.min_tokens, 40);
+        assert!(!config.files.respect_gitignore);
+    }
+
+    #[test]
+    fn test_partial_cli_override() {
+        let mut config = Config::default();
+        config = config.merge_with_cli(Some(25), None, None);
+
+        assert_eq!(config.complexity.warning_threshold, 25);
+        assert_eq!(config.clones.min_tokens, 30);
+        assert!(config.files.respect_gitignore);
+    }
+}

crates/core/src/error.rs

···
+use std::io;
+use std::path::PathBuf;
+use thiserror::Error;
+
+#[derive(Error, Debug)]
+pub enum MccabreError {
+    #[error("Failed to read file {path}: {source}")]
+    FileRead { path: PathBuf, source: io::Error },
+
+    #[error("Unsupported file type: {0}")]
+    UnsupportedFileType(String),
+
+    #[error("Invalid configuration: {0}")]
+    InvalidConfig(String),
+
+    #[error("Tokenization failed: {0}")]
+    TokenizationError(String),
+
+    #[error("IO error: {0}")]
+    Io(#[from] io::Error),
+}
+
+pub type Result<T> = std::result::Result<T, MccabreError>;

crates/core/src/lib.rs

···
-pub fn add(left: u64, right: u64) -> u64 {
-    left + right
-}
+pub mod cloner;
+pub mod complexity;
+pub mod config;
+pub mod error;
+pub mod loader;
+pub mod reporter;
+pub mod tokenizer;
 
-#[cfg(test)]
-mod tests {
-    use super::*;
-
-    #[test]
-    fn it_works() {
-        let result = add(2, 2);
-        assert_eq!(result, 4);
-    }
-}
+pub use error::{MccabreError, Result};

crates/core/src/loader.rs

···
+use crate::error::{MccabreError, Result};
+use crate::tokenizer::Language;
+use ignore::WalkBuilder;
+use std::path::{Path, PathBuf};
+use std::{fs, io};
+
+/// File entry with source code and metadata
+#[derive(Debug, Clone)]
+pub struct SourceFile {
+    pub path: PathBuf,
+    pub content: String,
+    pub language: Language,
+}
+
+/// File loader that respects .gitignore and supports various input types
+pub struct FileLoader {
+    /// Whether to respect .gitignore files
+    respect_gitignore: bool,
+}
+
+impl Default for FileLoader {
+    fn default() -> Self {
+        Self { respect_gitignore: true }
+    }
+}
+
+impl FileLoader {
+    pub fn new() -> Self {
+        Self::default()
+    }
+
+    /// Enable or disable gitignore awareness
+    pub fn with_gitignore(mut self, respect: bool) -> Self {
+        self.respect_gitignore = respect;
+        self
+    }
+
+    /// Load files from a path (file, directory, or list)
+    pub fn load<P: AsRef<Path>>(&self, path: P) -> Result<Vec<SourceFile>> {
+        let path = path.as_ref();
+
+        if path.is_file() {
+            let file = self.load_file(path)?;
+            Ok(vec![file])
+        } else if path.is_dir() {
+            self.load_directory(path)
+        } else {
+            Err(MccabreError::FileRead {
+                path: path.to_path_buf(),
+                source: std::io::Error::new(std::io::ErrorKind::NotFound, "Path is neither a file nor a directory"),
+            })
+        }
+    }
+
+    /// Load multiple paths
+    pub fn load_multiple<P: AsRef<Path>>(&self, paths: &[P]) -> Result<Vec<SourceFile>> {
+        let mut files = Vec::new();
+
+        for path in paths {
+            let mut loaded = self.load(path)?;
+            files.append(&mut loaded);
+        }
+
+        files.sort_by(|a, b| a.path.cmp(&b.path));
+        files.dedup_by(|a, b| a.path == b.path);
+
+        Ok(files)
+    }
+
+    /// Load a single file
+    fn load_file(&self, path: &Path) -> Result<SourceFile> {
+        let language = Language::from_path(path)?;
+        let content =
+            fs::read_to_string(path).map_err(|e| MccabreError::FileRead { path: path.to_path_buf(), source: e })?;
+
+        Ok(SourceFile { path: path.to_path_buf(), content, language })
+    }
+
+    /// Load all supported files from a directory
+    fn load_directory(&self, dir: &Path) -> Result<Vec<SourceFile>> {
+        let mut files = Vec::new();
+
+        let walker = WalkBuilder::new(dir)
+            .standard_filters(self.respect_gitignore)
+            .hidden(false)
+            .parents(true)
+            .build();
+
+        for entry in walker {
+            let entry = entry.map_err(|e| MccabreError::Io(io::Error::other(e.to_string())))?;
+            let path = entry.path();
+
+            if !path.is_file() {
+                continue;
+            }
+
+            match self.load_file(path) {
+                Ok(file) => files.push(file),
+                Err(MccabreError::UnsupportedFileType(_)) => continue,
+                Err(e) => return Err(e),
+            }
+        }
+
+        Ok(files)
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use std::fs;
+    use tempfile::TempDir;
+
+    #[test]
+    fn test_load_single_file() -> Result<()> {
+        let temp_dir = TempDir::new().unwrap();
+        let file_path = temp_dir.path().join("test.rs");
+        fs::write(&file_path, "fn main() {}").unwrap();
+
+        let loader = FileLoader::new();
+        let files = loader.load(&file_path)?;
+
+        assert_eq!(files.len(), 1);
+        assert_eq!(files[0].content, "fn main() {}");
+        assert_eq!(files[0].language, Language::Rust);
+
+        Ok(())
+    }
+
+    #[test]
+    fn test_load_directory() -> Result<()> {
+        let temp_dir = TempDir::new().unwrap();
+        fs::write(temp_dir.path().join("file1.rs"), "fn test1() {}").unwrap();
+        fs::write(temp_dir.path().join("file2.js"), "function test2() {}").unwrap();
+        fs::write(temp_dir.path().join("readme.txt"), "Not code").unwrap();
+
+        let loader = FileLoader::new();
+        let files = loader.load(temp_dir.path())?;
+
+        assert_eq!(files.len(), 2);
+
+        let has_rust = files.iter().any(|f| f.path.ends_with("file1.rs"));
+        let has_js = files.iter().any(|f| f.path.ends_with("file2.js"));
+        assert!(has_rust);
+        assert!(has_js);
+
+        Ok(())
+    }
+
+    #[test]
+    fn test_gitignore_respected() -> Result<()> {
+        let temp_dir = TempDir::new().unwrap();
+        fs::write(temp_dir.path().join("included.rs"), "fn included() {}").unwrap();
+
+        let ignored_dir = temp_dir.path().join("build");
+        fs::create_dir(&ignored_dir).unwrap();
+        fs::write(ignored_dir.join("excluded.rs"), "fn excluded() {}").unwrap();
+
+        fs::write(temp_dir.path().join(".gitignore"), "build/\n").unwrap();
+
+        let loader_with_gitignore = FileLoader::new().with_gitignore(true);
+        let files_with = loader_with_gitignore.load(temp_dir.path())?;
+
+        let loader_without_gitignore = FileLoader::new().with_gitignore(false);
+        let files_without = loader_without_gitignore.load(temp_dir.path())?;
+
+        assert!(files_with.iter().any(|f| f.path.ends_with("included.rs")));
+
+        assert!(files_without.iter().any(|f| f.path.ends_with("included.rs")));
+        assert!(files_without.iter().any(|f| f.path.ends_with("excluded.rs")));
+
+        Ok(())
+    }
+
+    #[test]
+    fn test_unsupported_file_type() {
+        let temp_dir = TempDir::new().unwrap();
+        let file_path = temp_dir.path().join("test.xyz");
+        fs::write(&file_path, "random content").unwrap();
+
+        let loader = FileLoader::new();
+        let result = loader.load(&file_path);
+
+        assert!(matches!(result, Err(MccabreError::UnsupportedFileType(_))));
+    }
+
+    #[test]
+    fn test_load_multiple() -> Result<()> {
+        let temp_dir = TempDir::new().unwrap();
+        let file1 = temp_dir.path().join("test1.rs");
+        let file2 = temp_dir.path().join("test2.js");
+
+        fs::write(&file1, "fn test1() {}").unwrap();
+        fs::write(&file2, "function test2() {}").unwrap();
+
+        let loader = FileLoader::new();
+        let files = loader.load_multiple(&[&file1, &file2])?;
+
+        assert_eq!(files.len(), 2);
+
+        Ok(())
+    }
+}

crates/core/src/reporter.rs

···
+use crate::cloner::Clone;
+use crate::complexity::{CyclomaticMetrics, LocMetrics, Severity};
+use serde::{Deserialize, Serialize};
+use std::path::PathBuf;
+
+/// Complete analysis report for a codebase
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct Report {
+    /// Per-file analysis results
+    pub files: Vec<FileReport>,
+    /// Detected clones across all files
+    pub clones: Vec<Clone>,
+    /// Summary statistics
+    pub summary: Summary,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct FileReport {
+    /// File path
+    pub path: PathBuf,
+    /// Lines of code metrics
+    pub loc: LocMetrics,
+    /// Cyclomatic complexity metrics
+    pub cyclomatic: CyclomaticMetrics,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct Summary {
+    /// Total number of files analyzed
+    pub total_files: usize,
+    /// Total physical lines of code
+    pub total_physical_loc: usize,
+    /// Total logical lines of code
+    pub total_logical_loc: usize,
+    /// Average cyclomatic complexity
+    pub avg_complexity: f64,
+    /// Maximum cyclomatic complexity
+    pub max_complexity: usize,
+    /// Number of files with high complexity
+    pub high_complexity_files: usize,
+    /// Total number of clone groups
+    pub total_clones: usize,
+}
+
+impl Report {
+    pub fn new(files: Vec<FileReport>, clones: Vec<Clone>) -> Self {
+        let summary = Summary::from_files(&files, &clones);
+        Self { files, clones, summary }
+    }
+
+    /// Serialize to JSON
+    pub fn to_json(&self) -> serde_json::Result<String> {
+        serde_json::to_string_pretty(self)
+    }
+
+    /// Generate plaintext report
+    pub fn to_plaintext(&self) -> String {
+        let mut output = String::new();
+
+        output.push_str(&"=".repeat(80));
+        output.push('\n');
+        output.push_str("MCCABRE CODE ANALYSIS REPORT\n");
+        output.push_str(&"=".repeat(80));
+        output.push_str("\n\n");
+
+        output.push_str("SUMMARY\n");
+        output.push_str(&"-".repeat(80));
+        output.push('\n');
+        output.push_str(&format!("Total files analyzed:        {}\n", self.summary.total_files));
+        output.push_str(&format!(
+            "Total physical LOC:          {}\n",
+            self.summary.total_physical_loc
+        ));
+        output.push_str(&format!(
+            "Total logical LOC:           {}\n",
+            self.summary.total_logical_loc
+        ));
+        output.push_str(&format!(
+            "Average complexity:          {:.2}\n",
+            self.summary.avg_complexity
+        ));
+        output.push_str(&format!(
+            "Maximum complexity:          {}\n",
+            self.summary.max_complexity
+        ));
+        output.push_str(&format!(
+            "High complexity files:       {}\n",
+            self.summary.high_complexity_files
+        ));
+        output.push_str(&format!(
+            "Clone groups detected:       {}\n\n",
+            self.summary.total_clones
+        ));
+
+        if !self.files.is_empty() {
+            output.push_str("FILE METRICS\n");
+            output.push_str(&"-".repeat(80));
+            output.push('\n');
+
+            for file in &self.files {
+                output.push_str(&format!("FILE: {}\n", file.path.display()));
+                output.push_str(&format!(
+                    "    Cyclomatic Complexity:   {} ({})\n",
+                    file.cyclomatic.file_complexity,
+                    match file.cyclomatic.severity() {
+                        Severity::Low => "low",
+                        Severity::Moderate => "moderate",
+                        Severity::High => "high",
+                        Severity::VeryHigh => "very high",
+                    }
+                ));
+                output.push_str(&format!("    Physical LOC:            {}\n", file.loc.physical));
+                output.push_str(&format!("    Logical LOC:             {}\n", file.loc.logical));
+                output.push_str(&format!("    Comment lines:           {}\n", file.loc.comments));
+                output.push_str(&format!("    Blank lines:             {}\n\n", file.loc.blank));
+
+                if !file.cyclomatic.functions.is_empty() {
+                    output.push_str("    Functions:\n");
+                    for func in &file.cyclomatic.functions {
+                        output.push_str(&format!(
+                            "      - {} (line {}): complexity {}\n",
+                            func.name, func.line, func.complexity
+                        ));
+                    }
+                    output.push('\n');
+                }
+            }
+        }
+
+        if !self.clones.is_empty() {
+            output.push_str("DETECTED CLONES\n");
+            output.push_str(&"-".repeat(80));
+            output.push('\n');
+
+            for clone in &self.clones {
+                output.push_str(&format!(
+                    "Clone Group #{} (length: {} tokens, {} occurrences)\n",
+                    clone.id,
+                    clone.length,
+                    clone.locations.len()
+                ));
+
+                for loc in &clone.locations {
+                    output.push_str(&format!(
+                        "  - {}:{}-{}\n",
+                        loc.file.display(),
+                        loc.start_line,
+                        loc.end_line
+                    ));
+                }
+                output.push('\n');
+            }
+        }
+
+        output.push_str(&"=".repeat(80));
+        output.push('\n');
+
+        output
+    }
+}
+
+impl Summary {
+    fn from_files(files: &[FileReport], clones: &[Clone]) -> Self {
+        let total_files = files.len();
+        let total_physical_loc = files.iter().map(|f| f.loc.physical).sum();
+        let total_logical_loc = files.iter().map(|f| f.loc.logical).sum();
+
+        let complexities: Vec<usize> = files.iter().map(|f| f.cyclomatic.file_complexity).collect();
+        let avg_complexity = if !complexities.is_empty() {
+            complexities.iter().sum::<usize>() as f64 / complexities.len() as f64
+        } else {
+            0.0
+        };
+
+        let max_complexity = complexities.iter().max().copied().unwrap_or(0);
+
+        let high_complexity_files = files
+            .iter()
+            .filter(|f| matches!(f.cyclomatic.severity(), Severity::High | Severity::VeryHigh))
+            .count();
+
+        let total_clones = clones.len();
+
+        Self {
+            total_files,
+            total_physical_loc,
+            total_logical_loc,
+            avg_complexity,
+            max_complexity,
+            high_complexity_files,
+            total_clones,
+        }
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::complexity::FunctionComplexity;
+
+    #[test]
+    fn test_empty_report() {
+        let report = Report::new(vec![], vec![]);
+        assert_eq!(report.summary.total_files, 0);
+        assert_eq!(report.summary.total_clones, 0);
+    }
+
+    #[test]
+    fn test_report_summary() {
+        let files = vec![
+            FileReport {
+                path: PathBuf::from("test1.rs"),
+                loc: LocMetrics { physical: 100, logical: 80, comments: 10, blank: 10 },
+                cyclomatic: CyclomaticMetrics { file_complexity: 5, functions: vec![] },
+            },
+            FileReport {
+                path: PathBuf::from("test2.rs"),
+                loc: LocMetrics { physical: 50, logical: 40, comments: 5, blank: 5 },
+                cyclomatic: CyclomaticMetrics { file_complexity: 15, functions: vec![] },
+            },
+        ];
+
+        let report = Report::new(files, vec![]);
+
+        assert_eq!(report.summary.total_files, 2);
+        assert_eq!(report.summary.total_physical_loc, 150);
+        assert_eq!(report.summary.total_logical_loc, 120);
+        assert_eq!(report.summary.avg_complexity, 10.0);
+        assert_eq!(report.summary.max_complexity, 15);
+    }
+
+    #[test]
+    fn test_to_json() {
+        let report = Report::new(vec![], vec![]);
+        let json = report.to_json().unwrap();
+        assert!(json.contains("files"));
+        assert!(json.contains("clones"));
+        assert!(json.contains("summary"));
+    }
+
+    #[test]
+    fn test_to_plaintext() {
+        let files = vec![FileReport {
+            path: PathBuf::from("test.rs"),
+            loc: LocMetrics { physical: 10, logical: 8, comments: 1, blank: 1 },
+            cyclomatic: CyclomaticMetrics {
+                file_complexity: 3,
+                functions: vec![FunctionComplexity { name: "test".to_string(), complexity: 3, line: 1 }],
+            },
+        }];
+
+        let report = Report::new(files, vec![]);
+        let plaintext = report.to_plaintext();
+
+        assert!(plaintext.contains("MCCABRE CODE ANALYSIS REPORT"));
+        assert!(plaintext.contains("test.rs"));
+        assert!(plaintext.contains("Cyclomatic Complexity"));
+    }
+}

crates/core/src/tokenizer.rs

···
+use crate::error::{MccabreError, Result};
+use std::path::Path;
+
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub enum Language {
+    Rust,
+    JavaScript,
+    TypeScript,
+    Go,
+    Java,
+    Cpp,
+}
+
+impl Language {
+    /// Detect language from file extension
+    pub fn from_path(path: &Path) -> Result<Self> {
+        let extension = path
+            .extension()
+            .and_then(|e| e.to_str())
+            .ok_or_else(|| MccabreError::UnsupportedFileType(path.to_string_lossy().to_string()))?;
+
+        match extension {
+            "rs" => Ok(Language::Rust),
+            "js" | "jsx" | "mjs" | "cjs" => Ok(Language::JavaScript),
+            "ts" | "tsx" => Ok(Language::TypeScript),
+            "go" => Ok(Language::Go),
+            "java" => Ok(Language::Java),
+            "cpp" | "cc" | "cxx" | "c++" | "hpp" | "h" | "hh" | "hxx" => Ok(Language::Cpp),
+            _ => Err(MccabreError::UnsupportedFileType(extension.to_string())),
+        }
+    }
+
+    /// Get single-line comment prefix
+    pub fn single_line_comment(&self) -> &'static str {
+        match self {
+            Language::Rust
+            | Language::JavaScript
+            | Language::TypeScript
+            | Language::Go
+            | Language::Java
+            | Language::Cpp => "//",
+        }
+    }
+
+    /// Get multi-line comment delimiters (start, end)
+    pub fn multi_line_comment(&self) -> (&'static str, &'static str) {
+        match self {
+            Language::Rust
+            | Language::JavaScript
+            | Language::TypeScript
+            | Language::Go
+            | Language::Java
+            | Language::Cpp => ("/*", "*/"),
+        }
+    }
+}
+
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub enum TokenType {
+    If,
+    Else,
+    ElseIf,
+    While,
+    For,
+    Loop,
+    Match,
+    Switch,
+    Case,
+    Default,
+    Catch,
+
+    LogicalAnd,
+    LogicalOr,
+    Ternary,
+
+    Operator(String),
+
+    Identifier(String),
+    Literal(String),
+
+    LeftBrace,
+    RightBrace,
+    LeftParen,
+    RightParen,
+    LeftBracket,
+    RightBracket,
+    Semicolon,
+    Comma,
+
+    Comment,
+    Whitespace,
+    Newline,
+    Unknown(char),
+}
+
+impl TokenType {
+    /// Returns true if this token contributes to cyclomatic complexity
+    pub fn is_decision_point(&self) -> bool {
+        matches!(
+            self,
+            TokenType::If
+                | TokenType::ElseIf
+                | TokenType::While
+                | TokenType::For
+                | TokenType::Loop
+                | TokenType::Match
+                | TokenType::Switch
+                | TokenType::Case
+                | TokenType::Catch
+                | TokenType::LogicalAnd
+                | TokenType::LogicalOr
+                | TokenType::Ternary
+        )
+    }
+
+    /// Returns true if this token should be included in clone detection
+    pub fn is_significant(&self) -> bool {
+        !matches!(self, TokenType::Comment | TokenType::Whitespace | TokenType::Newline)
+    }
+}
+
+#[derive(Debug, Clone)]
+pub struct Token {
+    pub token_type: TokenType,
+    pub line: usize,
+    pub column: usize,
+    pub text: String,
+}
+
+pub struct Tokenizer {
+    source: Vec<char>,
+    position: usize,
+    line: usize,
+    column: usize,
+    _language: Language,
+}
+
+impl Tokenizer {
+    pub fn new(source: &str, language: Language) -> Self {
+        Self { source: source.chars().collect(), position: 0, line: 1, column: 1, _language: language }
+    }
+
+    pub fn tokenize(mut self) -> Result<Vec<Token>> {
+        let mut tokens = Vec::new();
+
+        while !self.is_at_end() {
+            if let Some(token) = self.next_token()? {
+                tokens.push(token);
+            }
+        }
+
+        Ok(tokens)
+    }
+
+    fn next_token(&mut self) -> Result<Option<Token>> {
+        let start_line = self.line;
+        let start_column = self.column;
+        let start_pos = self.position;
+        let ch = self.current()?;
+
+        if ch.is_whitespace() {
+            if ch == '\n' {
+                self.advance();
+                return Ok(Some(Token {
+                    token_type: TokenType::Newline,
+                    line: start_line,
+                    column: start_column,
+                    text: "\n".to_string(),
+                }));
+            } else {
+                while !self.is_at_end() && self.current()?.is_whitespace() && self.current()? != '\n' {
+                    self.advance();
+                }
+                return Ok(Some(Token {
+                    token_type: TokenType::Whitespace,
+                    line: start_line,
+                    column: start_column,
+                    text: " ".to_string(),
+                }));
+            }
+        }
+
+        if ch == '/' {
+            if self.peek() == Some('/') {
+                while !self.is_at_end() && self.current()? != '\n' {
+                    self.advance();
+                }
+                return Ok(Some(Token {
+                    token_type: TokenType::Comment,
+                    line: start_line,
+                    column: start_column,
+                    text: "//".to_string(),
+                }));
+            } else if self.peek() == Some('*') {
+                self.advance();
+                self.advance();
+                while !self.is_at_end() {
+                    if self.current()? == '*' && self.peek() == Some('/') {
+                        self.advance();
+                        self.advance();
+                        break;
+                    }
+                    self.advance();
+                }
+                return Ok(Some(Token {
+                    token_type: TokenType::Comment,
+                    line: start_line,
+                    column: start_column,
+                    text: "/**/".to_string(),
+                }));
+            }
+        }
+
+        if ch == '"' || ch == '\'' {
+            let quote = ch;
+            self.advance();
+            while !self.is_at_end() && self.current()? != quote {
+                if self.current()? == '\\' {
+                    self.advance();
+                    if !self.is_at_end() {
+                        self.advance();
+                    }
+                } else {
+                    self.advance();
+                }
+            }
+            if !self.is_at_end() {
+                self.advance();
+            }
+            let text: String = self.source[start_pos..self.position].iter().collect();
+            return Ok(Some(Token {
+                token_type: TokenType::Literal(text.clone()),
+                line: start_line,
+                column: start_column,
+                text,
+            }));
+        }
+
+        if ch.is_ascii_digit() {
+            while !self.is_at_end()
+                && (self.current()?.is_ascii_alphanumeric() || self.current()? == '.' || self.current()? == '_')
+            {
+                self.advance();
+            }
+            let text: String = self.source[start_pos..self.position].iter().collect();
+            return Ok(Some(Token {
+                token_type: TokenType::Literal(text.clone()),
+                line: start_line,
+                column: start_column,
+                text,
+            }));
+        }
+
+        if ch.is_alphabetic() || ch == '_' {
+            while !self.is_at_end() && (self.current()?.is_alphanumeric() || self.current()? == '_') {
+                self.advance();
+            }
+            let text: String = self.source[start_pos..self.position].iter().collect();
+            let token_type = self.classify_keyword(&text);
+            return Ok(Some(Token { token_type, line: start_line, column: start_column, text }));
+        }
+
+        let token_type = match ch {
+            '{' => {
+                self.advance();
+                TokenType::LeftBrace
+            }
+            '}' => {
+                self.advance();
+                TokenType::RightBrace
+            }
+            '(' => {
+                self.advance();
+                TokenType::LeftParen
+            }
+            ')' => {
+                self.advance();
+                TokenType::RightParen
+            }
+            '[' => {
+                self.advance();
+                TokenType::LeftBracket
+            }
+            ']' => {
+                self.advance();
+                TokenType::RightBracket
+            }
+            ';' => {
+                self.advance();
+                TokenType::Semicolon
+            }
+            ',' => {
+                self.advance();
+                TokenType::Comma
+            }
+            '?' => {
+                self.advance();
+                TokenType::Ternary
+            }
+            '&' if self.peek() == Some('&') => {
+                self.advance();
+                self.advance();
+                TokenType::LogicalAnd
+            }
+            '|' if self.peek() == Some('|') => {
+                self.advance();
+                self.advance();
+                TokenType::LogicalOr
+            }
+            _ => {
+                let op_chars = "+-*/%=<>!&|^~";
+                if op_chars.contains(ch) {
+                    while !self.is_at_end() && op_chars.contains(self.current()?) {
+                        self.advance();
+                    }
+                    let text: String = self.source[start_pos..self.position].iter().collect();
+                    TokenType::Operator(text)
+                } else {
+                    self.advance();
+                    TokenType::Unknown(ch)
+                }
+            }
+        };
+
+        let text: String = self.source[start_pos..self.position].iter().collect();
+        Ok(Some(Token { token_type, line: start_line, column: start_column, text }))
+    }
+
+    fn classify_keyword(&self, word: &str) -> TokenType {
+        match word {
+            "if" => TokenType::If,
+            "else" => TokenType::Else,
+            "elif" => TokenType::ElseIf,
+            "while" => TokenType::While,
+            "for" => TokenType::For,
+            "loop" => TokenType::Loop,
+            "match" => TokenType::Match,
+            "switch" => TokenType::Switch,
+            "case" => TokenType::Case,
+            "default" => TokenType::Default,
+            "catch" => TokenType::Catch,
+            _ => TokenType::Identifier(word.to_string()),
+        }
+    }
+
+    fn current(&self) -> Result<char> {
+        self.source
+            .get(self.position)
+            .copied()
+            .ok_or_else(|| MccabreError::TokenizationError("Unexpected end of input".to_string()))
+    }
+
+    fn peek(&self) -> Option<char> {
+        self.source.get(self.position + 1).copied()
+    }
+
+    fn advance(&mut self) {
+        if let Some(ch) = self.source.get(self.position) {
+            if *ch == '\n' {
+                self.line += 1;
+                self.column = 1;
+            } else {
+                self.column += 1;
+            }
+            self.position += 1;
+        }
+    }
+
+    fn is_at_end(&self) -> bool {
+        self.position >= self.source.len()
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_language_detection() {
+        assert_eq!(Language::from_path(Path::new("test.rs")).unwrap(), Language::Rust);
+        assert_eq!(Language::from_path(Path::new("test.js")).unwrap(), Language::JavaScript);
+        assert_eq!(Language::from_path(Path::new("test.ts")).unwrap(), Language::TypeScript);
+        assert_eq!(Language::from_path(Path::new("test.go")).unwrap(), Language::Go);
+        assert_eq!(Language::from_path(Path::new("test.java")).unwrap(), Language::Java);
+        assert_eq!(Language::from_path(Path::new("test.cpp")).unwrap(), Language::Cpp);
+    }
+
+    #[test]
+    fn test_tokenize_simple() {
+        let source = "if (x > 5) { return true; }";
+        let tokenizer = Tokenizer::new(source, Language::Rust);
+        let tokens = tokenizer.tokenize().unwrap();
+
+        let significant: Vec<_> = tokens.iter().filter(|t| t.token_type.is_significant()).collect();
+
+        assert!(!significant.is_empty());
+        assert!(tokens.iter().any(|t| matches!(t.token_type, TokenType::If)));
+    }
+
+    #[test]
+    fn test_decision_points() {
+        let source = "if (x && y || z) { while (true) { } }";
+        let tokenizer = Tokenizer::new(source, Language::Rust);
+        let tokens = tokenizer.tokenize().unwrap();
+        let decision_count = tokens.iter().filter(|t| t.token_type.is_decision_point()).count();
+        assert_eq!(decision_count, 4);
+    }
+
+    #[test]
+    fn test_comments() {
+        let source = r#"
+// Single line comment
+/* Multi-line
+   comment */
+let x = 5;
+"#;
+        let tokenizer = Tokenizer::new(source, Language::Rust);
+        let tokens = tokenizer.tokenize().unwrap();
+
+        let comments: Vec<_> = tokens
+            .iter()
+            .filter(|t| matches!(t.token_type, TokenType::Comment))
+            .collect();
+
+        assert_eq!(comments.len(), 2);
+    }
+
+    #[test]
+    fn test_strings() {
+        let source = r#"let s = "hello \"world\""; let c = 'x';"#;
+        let tokenizer = Tokenizer::new(source, Language::Rust);
+        let tokens = tokenizer.tokenize().unwrap();
+
+        let literals: Vec<_> = tokens
+            .iter()
+            .filter(|t| matches!(t.token_type, TokenType::Literal(_)))
+            .collect();
+
+        assert!(literals.len() >= 2);
+    }
+}