feat: basic lcov ingestion and reporting

.gitignore

···
 #  and can be added to the global gitignore or merged into this file.  For a more nuclear
 #  option (not recommended) you can uncomment the following to ignore the entire idea folder.
 #.idea/
+.sandbox/
+lcov.info

CHANGELOG.md

···
+# Changelog
+
+All notable changes to this project will be documented in this file.
+
+The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
+and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
+
+## [0.1.0] - 2026-01-13
+
+### Added
+
+- LOC command extension: file ranking and directory aggregation.
+- Syntax highlighting using `syntect`.
+- Configuration saving functionality.
+- Core utilities and commands.
+- Clone detector implementation (Rabin-Karp).
+- Cyclomatic complexity and LOC metrics.
+- mdbook Documentation with example/sample files.

Cargo.lock

···
 checksum = "4a5f13b858c8d314ee3e8f639011f7ccefe71f97f96e50151fb991f267928e2c"
 
 [[package]]
+name = "lcov"
+version = "0.8.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1ccfa6d5e585a884db65b37f38184e4364eaf74d884ac35d0a90fe9baf80b723"
+dependencies = [
+ "thiserror 1.0.69",
+]
+
+[[package]]
 name = "libc"
 version = "0.2.177"
 source = "registry+https://github.com/rust-lang/crates.io-index"
···
 dependencies = [
  "anyhow",
  "ignore",
+ "lcov",
+ "owo-colors",
  "serde",
  "serde_json",
  "tempfile",
- "thiserror",
+ "thiserror 2.0.17",
  "toml",
  "walkdir",
 ]
···
  "serde",
  "serde_derive",
  "serde_json",
- "thiserror",
+ "thiserror 2.0.17",
  "walkdir",
  "yaml-rust",
 ]
···
 
 [[package]]
 name = "thiserror"
+version = "1.0.69"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b6aaf5339b578ea85b50e080feb250a3e8ae8cfcdff9a461c9ec2904bc923f52"
+dependencies = [
+ "thiserror-impl 1.0.69",
+]
+
+[[package]]
+name = "thiserror"
 version = "2.0.17"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "f63587ca0f12b72a0600bcba1d40081f830876000bb46dd2337a3051618f4fc8"
 dependencies = [
- "thiserror-impl",
+ "thiserror-impl 2.0.17",
+]
+
+[[package]]
+name = "thiserror-impl"
+version = "1.0.69"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "4fee6c4efc90059e10f81e6d42c60a18f76588c3d74cb83a0b242a2b6c7504c1"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn",
 ]
 
 [[package]]

README

···
   - Goals and metrics
   - Algorithms used
   - Project structure
-  - Beyond-MVP roadmap
   - Outputs
   - Philosophy
 
···
 ===============================================================================
 FUTURE
 -------------------------------------------------------------------------------
-A. AST-Based Clone Detection
-   - Compare abstract syntax trees or subtrees.
-   - Identifies clones resilient to renamed variables or formatting changes.
-   - Requires per-language AST adapters.
-
-B. Cognitive Complexity
-   - Scores human comprehension cost.
-   - Rewards flattened control flow, penalizes deep nesting.
-   - Requires AST-level traversal.
-
-C. Maintainability Index
-   - Combines Cyclomatic, Halstead, and LOC into a single number.
-   - Good for dashboards and longitudinal tracking.
-
-D. Semantic Clone Detection
-   - Goes beyond syntax: identifies logically equivalent code.
-   - Requires control/data-flow analysis.
-
-E. Dependency Metrics
-   - Coupling, fan-in/fan-out, depth of inheritance.
-   - Requires language-specific type-resolution or symbol graph extraction.
-
-F. Hotspot Analysis
-   - Combine Git history + complexity metrics.
-   - Identify files that change often AND are complex.
-
-G. Incremental Mode
-   - Cache hashes/graphs.
-   - Analyze only changed files and touched boundaries.
-
-H. Rich Reports
-   - HTML dashboards
-   - SVG graphs (CFG visualization)
-   - JSON with stable schema for CI systems
-
+See todo.txt
 ===============================================================================
 CRATES
-
 --------------------------------------------------------------------------------
 core
   tokenizer
···
 4. No global state; everything streamed and incremental.
 5. Developer-friendly reporting and clear severity levels.
 6. Configurable thresholds
-
-===============================================================================
-SUMMARY
-
-MVP:
-  - LOC
-  - Cyclomatic Complexity
-  - Rabin-Karp Clone Detection
-  - Halstead Complexity
-
-Beyond MVP:
-  - AST-based clones
-  - Cognitive Complexity
-  - Maintainability Index
-  - Coupling metrics
-  - Call graphs and data-flow graphs
-  - Hotspot analysis
-  - Incremental scanning
 
 ===============================================================================
 REFERENCES

crates/cli/src/commands/coverage.rs

···
+use anyhow::Result;
+use mccabre_core::coverage::{FileCoverage, parse_coverage_from_file};
+use mccabre_core::reporter::{coverage_jsonl::JsonlReporter, coverage_term::report_coverage};
+use owo_colors::OwoColorize;
+use std::path::PathBuf;
+
+pub fn run(from: PathBuf, jsonl: Option<PathBuf>, repo_root: Option<PathBuf>) -> Result<()> {
+    if !from.exists() {
+        eprintln!("{}", format!("LCOV file not found: {}", from.display()).red());
+        std::process::exit(1);
+    }
+
+    let report = parse_coverage_from_file(&from, repo_root.as_deref())?;
+
+    if report.files.is_empty() {
+        eprintln!("{}", "No coverage data found".yellow());
+        return Ok(());
+    }
+
+    if let Some(jsonl_path) = jsonl {
+        let mut reporter = JsonlReporter::new();
+        reporter.add_report(&report);
+        reporter.write_to_file(&jsonl_path)?;
+
+        println!(
+            "{}",
+            format!("JSONL report written to: {}", jsonl_path.display())
+                .green()
+                .bold()
+        );
+    }
+
+    println!("{}", report_coverage(&report));
+
+    Ok(())
+}
+
+pub fn run_file_view(path: PathBuf, from: PathBuf) -> Result<()> {
+    if !from.exists() {
+        eprintln!("{}", format!("LCOV file not found: {}", from.display()).red());
+        std::process::exit(1);
+    }
+
+    let report = parse_coverage_from_file(&from, None)?;
+
+    let file_coverage = report.files.iter().find(|f| f.path == path.to_string_lossy());
+
+    match file_coverage {
+        Some(file) => {
+            println!("{}", report_coverage_for_file(file));
+        }
+        None => {
+            eprintln!(
+                "{}",
+                format!("File not found in coverage data: {}", path.display()).red()
+            );
+            std::process::exit(1);
+        }
+    }
+
+    Ok(())
+}
+
+fn report_coverage_for_file(file: &FileCoverage) -> String {
+    mccabre_core::reporter::coverage_term::format_file_coverage(file, 0)
+}

crates/cli/src/commands/mod.rs

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

crates/cli/src/main.rs

···
         #[arg(long)]
         no_gitignore: bool,
     },
+
+    /// Analyze code coverage from LCOV data
+    Coverage {
+        /// Path to LCOV file
+        #[arg(long, value_name = "PATH")]
+        from: PathBuf,
+
+        /// Output as JSONL to file
+        #[arg(long, value_name = "PATH")]
+        jsonl: Option<PathBuf>,
+
+        /// Repository root for path normalization
+        #[arg(long, value_name = "PATH")]
+        repo_root: Option<PathBuf>,
+
+        /// View detailed coverage for a specific file
+        #[arg(long, value_name = "PATH")]
+        file: Option<PathBuf>,
+    },
 }
 
 fn main() -> Result<()> {
···
             };
 
             commands::loc::run(path, json, rank_by, rank_dirs, config, !no_gitignore)
+        }
+        Commands::Coverage { from, jsonl, repo_root, file } => {
+            if let Some(file) = file {
+                commands::coverage::run_file_view(file, from)
+            } else {
+                commands::coverage::run(from, jsonl, repo_root)
+            }
         }
     }
 }

crates/core/Cargo.toml

···
 
 [dependencies]
 ignore = "0.4.25"
+lcov = "0.8"
+owo-colors = "4.2.3"
 serde = { version = "1.0", features = ["derive"] }
 serde_json = "1.0"
 thiserror = "2.0"

crates/core/src/coverage/lcov.rs

···
+use crate::{MccabreError, Result};
+use std::collections::BTreeMap;
+use std::path::Path;
+
+pub fn parse_lcov_file(path: &Path, repo_root: Option<&Path>) -> Result<Vec<FileCoverage>> {
+    let content = std::fs::read_to_string(path)
+        .map_err(|e| MccabreError::Io(std::io::Error::other(format!("Failed to read LCOV file: {e}"))))?;
+
+    parse_lcov_content(&content, repo_root)
+}
+
+pub fn parse_lcov_content(content: &str, repo_root: Option<&Path>) -> Result<Vec<FileCoverage>> {
+    let mut files: std::collections::HashMap<String, BTreeMap<u32, u64>> = std::collections::HashMap::new();
+    let mut current_file: Option<String> = None;
+
+    for line in content.lines() {
+        let line = line.trim();
+
+        if line.is_empty() {
+            continue;
+        }
+
+        if let Some(rest) = line.strip_prefix("SF:") {
+            let path = super::paths::normalize_path(rest, repo_root);
+            current_file = Some(path);
+            files.entry(current_file.clone().unwrap()).or_default();
+        } else if let Some(rest) = line.strip_prefix("DA:") {
+            if let Some(ref file) = current_file
+                && let Some((line_num, count)) = rest.split_once(',')
+                && let (Ok(line_num), Ok(count)) = (line_num.parse::<u32>(), count.parse::<u64>())
+            {
+                files.entry(file.clone()).or_default().insert(line_num, count);
+            }
+        } else if line == "end_of_record" {
+            current_file = None;
+        }
+    }
+
+    let mut file_coverages = Vec::new();
+    for (path, lines) in files {
+        file_coverages.push(FileCoverage::new(path, lines));
+    }
+
+    file_coverages.sort_by(|a, b| {
+        a.summary
+            .rate
+            .partial_cmp(&b.summary.rate)
+            .unwrap_or(std::cmp::Ordering::Equal)
+    });
+
+    Ok(file_coverages)
+}
+
+use super::model::FileCoverage;
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_parse_simple_lcov() {
+        let lcov = r#"SF:test.rs
+DA:1,10
+DA:2,5
+DA:3,0
+end_of_record
+"#;
+
+        let files = parse_lcov_content(lcov, None).unwrap();
+        assert_eq!(files.len(), 1);
+        assert_eq!(files[0].path, "test.rs");
+        assert_eq!(files[0].lines.len(), 3);
+        assert_eq!(files[0].lines.get(&1), Some(&10));
+        assert_eq!(files[0].lines.get(&2), Some(&5));
+        assert_eq!(files[0].lines.get(&3), Some(&0));
+    }
+
+    #[test]
+    fn test_parse_multiple_files() {
+        let lcov = r#"SF:test1.rs
+DA:1,10
+DA:2,5
+end_of_record
+SF:test2.rs
+DA:1,1
+DA:2,0
+DA:3,0
+end_of_record
+"#;
+
+        let files = parse_lcov_content(lcov, None).unwrap();
+        assert_eq!(files.len(), 2);
+        assert!(files.iter().any(|f| f.path == "test1.rs"));
+        assert!(files.iter().any(|f| f.path == "test2.rs"));
+    }
+
+    #[test]
+    fn test_parse_with_repo_root() {
+        let lcov = r#"SF:/repo/src/lib.rs
+DA:1,10
+DA:2,0
+end_of_record
+"#;
+
+        let root = Path::new("/repo");
+        let files = parse_lcov_content(lcov, Some(root)).unwrap();
+        assert_eq!(files.len(), 1);
+        assert_eq!(files[0].path, "src/lib.rs");
+    }
+
+    #[test]
+    fn test_parse_empty_lcov() {
+        let lcov = "";
+        let files = parse_lcov_content(lcov, None).unwrap();
+        assert!(files.is_empty());
+    }
+
+    #[test]
+    fn test_parse_invalid_lines() {
+        let lcov = r#"SF:test.rs
+DA:invalid,10
+DA:1,5
+end_of_record
+"#;
+
+        let files = parse_lcov_content(lcov, None).unwrap();
+        assert_eq!(files.len(), 1);
+        assert_eq!(files[0].lines.get(&1), Some(&5));
+    }
+
+    #[test]
+    fn test_parse_sorted_by_coverage_rate() {
+        let lcov = r#"SF:full.rs
+DA:1,10
+DA:2,10
+end_of_record
+SF:partial.rs
+DA:1,10
+DA:2,0
+end_of_record
+SF:none.rs
+DA:1,0
+DA:2,0
+end_of_record
+"#;
+
+        let files = parse_lcov_content(lcov, None).unwrap();
+        assert_eq!(files.len(), 3);
+        assert_eq!(files[0].path, "none.rs");
+        assert_eq!(files[1].path, "partial.rs");
+        assert_eq!(files[2].path, "full.rs");
+    }
+}

crates/core/src/coverage/misses.rs

···
+use std::collections::BTreeMap;
+
+pub fn compute_miss_ranges(lines: &BTreeMap<u32, u64>) -> Vec<(u32, u32)> {
+    let mut miss_ranges = Vec::new();
+    let mut current_range: Option<(u32, u32)> = None;
+
+    for (&line, &count) in lines {
+        if count == 0 {
+            match current_range {
+                None => current_range = Some((line, line)),
+                Some((start, end)) => {
+                    if line == end + 1 {
+                        current_range = Some((start, line));
+                    } else {
+                        miss_ranges.push(current_range.unwrap());
+                        current_range = Some((line, line));
+                    }
+                }
+            }
+        } else if let Some(range) = current_range {
+            miss_ranges.push(range);
+            current_range = None;
+        }
+    }
+
+    if let Some(range) = current_range {
+        miss_ranges.push(range);
+    }
+
+    miss_ranges
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_no_misses() {
+        let mut lines = BTreeMap::new();
+        lines.insert(1, 10);
+        lines.insert(2, 5);
+        lines.insert(3, 1);
+
+        let ranges = compute_miss_ranges(&lines);
+        assert!(ranges.is_empty());
+    }
+
+    #[test]
+    fn test_single_miss() {
+        let mut lines = BTreeMap::new();
+        lines.insert(1, 10);
+        lines.insert(2, 0);
+        lines.insert(3, 5);
+
+        let ranges = compute_miss_ranges(&lines);
+        assert_eq!(ranges, vec![(2, 2)]);
+    }
+
+    #[test]
+    fn test_consecutive_misses() {
+        let mut lines = BTreeMap::new();
+        lines.insert(1, 10);
+        lines.insert(2, 0);
+        lines.insert(3, 0);
+        lines.insert(4, 0);
+        lines.insert(5, 5);
+
+        let ranges = compute_miss_ranges(&lines);
+        assert_eq!(ranges, vec![(2, 4)]);
+    }
+
+    #[test]
+    fn test_multiple_miss_ranges() {
+        let mut lines = BTreeMap::new();
+        lines.insert(1, 10);
+        lines.insert(2, 0);
+        lines.insert(3, 0);
+        lines.insert(4, 5);
+        lines.insert(5, 0);
+        lines.insert(6, 10);
+
+        let ranges = compute_miss_ranges(&lines);
+        assert_eq!(ranges, vec![(2, 3), (5, 5)]);
+    }
+
+    #[test]
+    fn test_all_misses() {
+        let mut lines = BTreeMap::new();
+        lines.insert(1, 0);
+        lines.insert(2, 0);
+        lines.insert(3, 0);
+
+        let ranges = compute_miss_ranges(&lines);
+        assert_eq!(ranges, vec![(1, 3)]);
+    }
+
+    #[test]
+    fn test_empty_lines() {
+        let lines = BTreeMap::new();
+        let ranges = compute_miss_ranges(&lines);
+        assert!(ranges.is_empty());
+    }
+
+    #[test]
+    fn test_miss_at_start() {
+        let mut lines = BTreeMap::new();
+        lines.insert(1, 0);
+        lines.insert(2, 0);
+        lines.insert(3, 10);
+
+        let ranges = compute_miss_ranges(&lines);
+        assert_eq!(ranges, vec![(1, 2)]);
+    }
+
+    #[test]
+    fn test_miss_at_end() {
+        let mut lines = BTreeMap::new();
+        lines.insert(1, 10);
+        lines.insert(2, 5);
+        lines.insert(3, 0);
+        lines.insert(4, 0);
+
+        let ranges = compute_miss_ranges(&lines);
+        assert_eq!(ranges, vec![(3, 4)]);
+    }
+}

crates/core/src/coverage/mod.rs

···
+pub mod lcov;
+pub mod misses;
+pub mod model;
+pub mod paths;
+
+pub use lcov::parse_lcov_content;
+pub use lcov::parse_lcov_file;
+pub use model::{CoverageReport, CoverageSummary, FileCoverage};
+
+use crate::Result;
+
+pub fn parse_coverage_from_file(path: &std::path::Path, repo_root: Option<&std::path::Path>) -> Result<CoverageReport> {
+    let files = lcov::parse_lcov_file(path, repo_root)?;
+    Ok(CoverageReport::new(files))
+}
+
+pub fn parse_coverage_from_content(content: &str, repo_root: Option<&std::path::Path>) -> Result<CoverageReport> {
+    let files = lcov::parse_lcov_content(content, repo_root)?;
+    Ok(CoverageReport::new(files))
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_parse_coverage_from_content() {
+        let lcov = r#"SF:test.rs
+DA:1,10
+DA:2,0
+DA:3,5
+end_of_record
+"#;
+
+        let report = parse_coverage_from_content(lcov, None).unwrap();
+        assert_eq!(report.files.len(), 1);
+        assert_eq!(report.totals.total, 3);
+        assert_eq!(report.totals.hit, 2);
+        assert_eq!(report.totals.miss, 1);
+    }
+
+    #[test]
+    fn test_parse_coverage_multiple_files() {
+        let lcov = r#"SF:test1.rs
+DA:1,10
+DA:2,0
+end_of_record
+SF:test2.rs
+DA:1,5
+DA:2,5
+end_of_record
+"#;
+
+        let report = parse_coverage_from_content(lcov, None).unwrap();
+        assert_eq!(report.files.len(), 2);
+        assert_eq!(report.totals.total, 4);
+        assert_eq!(report.totals.hit, 3);
+        assert_eq!(report.totals.miss, 1);
+    }
+}

crates/core/src/coverage/model.rs

···
+use serde::{Deserialize, Serialize};
+
+/// Coverage report for the entire codebase
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct CoverageReport {
+    pub files: Vec<FileCoverage>,
+    pub totals: CoverageSummary,
+}
+
+impl CoverageReport {
+    pub fn new(files: Vec<FileCoverage>) -> Self {
+        let totals = CoverageSummary::from_files(&files);
+        Self { files, totals }
+    }
+}
+
+/// Coverage data for a single file
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct FileCoverage {
+    pub path: String,
+    pub lines: std::collections::BTreeMap<u32, u64>,
+    pub miss_ranges: Vec<(u32, u32)>,
+    pub summary: CoverageSummary,
+}
+
+impl FileCoverage {
+    pub fn new(path: String, lines: std::collections::BTreeMap<u32, u64>) -> Self {
+        let summary = CoverageSummary::from_lines(&lines);
+        let miss_ranges = super::misses::compute_miss_ranges(&lines);
+        Self { path, lines, miss_ranges, summary }
+    }
+}
+
+/// Coverage summary statistics
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct CoverageSummary {
+    pub total: usize,
+    pub hit: usize,
+    pub miss: usize,
+    pub rate: f64,
+}
+
+impl CoverageSummary {
+    pub fn from_lines(lines: &std::collections::BTreeMap<u32, u64>) -> Self {
+        let total = lines.len();
+        let hit = lines.values().filter(|&&c| c > 0).count();
+        let miss = lines.values().filter(|&&c| c == 0).count();
+        let rate = if total > 0 { (hit as f64 / total as f64) * 100.0 } else { 0.0 };
+
+        Self { total, hit, miss, rate }
+    }
+
+    pub fn from_files(files: &[FileCoverage]) -> Self {
+        let total: usize = files.iter().map(|f| f.summary.total).sum();
+        let hit: usize = files.iter().map(|f| f.summary.hit).sum();
+        let miss: usize = files.iter().map(|f| f.summary.miss).sum();
+        let rate = if total > 0 { (hit as f64 / total as f64) * 100.0 } else { 0.0 };
+
+        Self { total, hit, miss, rate }
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_coverage_summary_full() {
+        let mut lines = std::collections::BTreeMap::new();
+        lines.insert(1, 10);
+        lines.insert(2, 5);
+        lines.insert(3, 1);
+
+        let summary = CoverageSummary::from_lines(&lines);
+        assert_eq!(summary.total, 3);
+        assert_eq!(summary.hit, 3);
+        assert_eq!(summary.miss, 0);
+        assert_eq!(summary.rate, 100.0);
+    }
+
+    #[test]
+    fn test_coverage_summary_partial() {
+        let mut lines = std::collections::BTreeMap::new();
+        lines.insert(1, 10);
+        lines.insert(2, 0);
+        lines.insert(3, 5);
+
+        let summary = CoverageSummary::from_lines(&lines);
+        assert_eq!(summary.total, 3);
+        assert_eq!(summary.hit, 2);
+        assert_eq!(summary.miss, 1);
+        assert!((summary.rate - 66.66666666666666).abs() < 0.0001);
+    }
+
+    #[test]
+    fn test_coverage_summary_empty() {
+        let lines = std::collections::BTreeMap::new();
+        let summary = CoverageSummary::from_lines(&lines);
+        assert_eq!(summary.total, 0);
+        assert_eq!(summary.hit, 0);
+        assert_eq!(summary.miss, 0);
+        assert_eq!(summary.rate, 0.0);
+    }
+
+    #[test]
+    fn test_file_coverage() {
+        let mut lines = std::collections::BTreeMap::new();
+        lines.insert(1, 10);
+        lines.insert(2, 0);
+        lines.insert(3, 5);
+
+        let file = FileCoverage::new("test.rs".to_string(), lines.clone());
+        assert_eq!(file.path, "test.rs");
+        assert_eq!(file.summary.total, 3);
+        assert_eq!(file.summary.hit, 2);
+        assert_eq!(file.summary.miss, 1);
+        assert_eq!(file.miss_ranges, vec![(2, 2)]);
+    }
+}

crates/core/src/coverage/paths.rs

···
+use std::path::{Path, PathBuf};
+
+pub fn normalize_path(path: &str, repo_root: Option<&Path>) -> String {
+    let path = PathBuf::from(path);
+
+    let normalized = if let Some(root) = repo_root {
+        if let Ok(stripped) = path.strip_prefix(root) {
+            if stripped.as_os_str().is_empty() { PathBuf::from(".") } else { stripped.to_path_buf() }
+        } else {
+            path
+        }
+    } else {
+        path
+    };
+
+    normalized.display().to_string()
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_normalize_path_no_root() {
+        let path = "/absolute/path/to/file.rs";
+        let normalized = normalize_path(path, None);
+        assert_eq!(normalized, path);
+    }
+
+    #[test]
+    fn test_normalize_path_with_root() {
+        let path = "/repo/src/lib.rs";
+        let root = Path::new("/repo");
+        let normalized = normalize_path(path, Some(root));
+        assert_eq!(normalized, "src/lib.rs");
+    }
+
+    #[test]
+    fn test_normalize_path_no_match() {
+        let path = "/other/path/file.rs";
+        let root = Path::new("/repo");
+        let normalized = normalize_path(path, Some(root));
+        assert_eq!(normalized, path);
+    }
+
+    #[test]
+    fn test_normalize_path_relative() {
+        let path = "src/lib.rs";
+        let normalized = normalize_path(path, None);
+        assert_eq!(normalized, path);
+    }
+
+    #[test]
+    fn test_normalize_path_exact_match() {
+        let path = "/repo/src/lib.rs";
+        let root = Path::new("/repo/src/lib.rs");
+        let normalized = normalize_path(path, Some(root));
+        assert_eq!(normalized, ".");
+    }
+}

crates/core/src/lib.rs

···
 pub mod cloner;
 pub mod complexity;
 pub mod config;
+pub mod coverage;
 pub mod error;
 pub mod loader;
 pub mod reporter;

crates/core/src/reporter/coverage_jsonl.rs

···
+use crate::coverage::{CoverageReport, FileCoverage};
+use std::io::Write;
+
+pub struct JsonlReporter {
+    output: Vec<String>,
+}
+
+impl JsonlReporter {
+    pub fn new() -> Self {
+        Self { output: Vec::new() }
+    }
+
+    pub fn add_file(&mut self, file: &FileCoverage) {
+        let record = serde_json::to_string(file).expect("Failed to serialize file coverage");
+        self.output.push(record);
+    }
+
+    pub fn add_report(&mut self, report: &CoverageReport) {
+        for file in &report.files {
+            self.add_file(file);
+        }
+    }
+
+    pub fn write_to_file(&self, path: &std::path::Path) -> std::io::Result<()> {
+        let mut file = std::fs::File::create(path)?;
+        for line in &self.output {
+            writeln!(file, "{}", line)?;
+        }
+        Ok(())
+    }
+
+    pub fn as_string(&self) -> String {
+        self.output.join("\n")
+    }
+}
+
+impl Default for JsonlReporter {
+    fn default() -> Self {
+        Self::new()
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::coverage::FileCoverage;
+    use std::collections::BTreeMap;
+    use tempfile::tempdir;
+
+    #[test]
+    fn test_jsonl_reporter_empty() {
+        let reporter = JsonlReporter::new();
+        assert!(reporter.output.is_empty());
+    }
+
+    #[test]
+    fn test_jsonl_reporter_add_file() {
+        let mut lines = BTreeMap::new();
+        lines.insert(1, 10);
+        lines.insert(2, 0);
+
+        let file = FileCoverage::new("test.rs".to_string(), lines);
+        let mut reporter = JsonlReporter::new();
+        reporter.add_file(&file);
+
+        assert_eq!(reporter.output.len(), 1);
+        assert!(reporter.output[0].contains("test.rs"));
+    }
+
+    #[test]
+    fn test_jsonl_reporter_add_report() {
+        let mut lines1 = BTreeMap::new();
+        lines1.insert(1, 10);
+
+        let mut lines2 = BTreeMap::new();
+        lines2.insert(1, 5);
+        lines2.insert(2, 0);
+
+        let file1 = FileCoverage::new("test1.rs".to_string(), lines1);
+        let file2 = FileCoverage::new("test2.rs".to_string(), lines2);
+        let report = CoverageReport::new(vec![file1, file2]);
+
+        let mut reporter = JsonlReporter::new();
+        reporter.add_report(&report);
+
+        assert_eq!(reporter.output.len(), 2);
+    }
+
+    #[test]
+    fn test_jsonl_reporter_to_string() {
+        let mut lines = BTreeMap::new();
+        lines.insert(1, 10);
+        lines.insert(2, 0);
+
+        let file = FileCoverage::new("test.rs".to_string(), lines);
+        let mut reporter = JsonlReporter::new();
+        reporter.add_file(&file);
+
+        let output = reporter.as_string();
+        assert!(output.contains("test.rs"));
+        let lines: Vec<&str> = output.lines().collect();
+        assert_eq!(lines.len(), 1);
+    }
+
+    #[test]
+    fn test_jsonl_reporter_write_to_file() {
+        let mut lines = BTreeMap::new();
+        lines.insert(1, 10);
+        lines.insert(2, 0);
+
+        let file = FileCoverage::new("test.rs".to_string(), lines);
+        let mut reporter = JsonlReporter::new();
+        reporter.add_file(&file);
+
+        let temp_dir = tempdir().unwrap();
+        let file_path = temp_dir.path().join("coverage.jsonl");
+        reporter.write_to_file(&file_path).unwrap();
+
+        let content = std::fs::read_to_string(&file_path).unwrap();
+        assert!(content.contains("test.rs"));
+    }
+
+    #[test]
+    fn test_jsonl_reporter_serialization() {
+        let mut lines = BTreeMap::new();
+        lines.insert(1, 10);
+        lines.insert(2, 0);
+        lines.insert(3, 5);
+
+        let file = FileCoverage::new("test.rs".to_string(), lines);
+        let mut reporter = JsonlReporter::new();
+        reporter.add_file(&file);
+
+        let output = reporter.as_string();
+        let parsed: FileCoverage = serde_json::from_str(&output).unwrap();
+        assert_eq!(parsed.path, "test.rs");
+        assert_eq!(parsed.lines.len(), 3);
+    }
+}

crates/core/src/reporter/coverage_term.rs

···
+use crate::coverage::{CoverageReport, FileCoverage};
+use owo_colors::OwoColorize;
+
+#[cfg(test)]
+fn strip_ansi_codes(s: &str) -> String {
+    let mut result = String::new();
+    let mut chars = s.chars().peekable();
+
+    while let Some(c) = chars.next() {
+        if c == '\x1b' {
+            if chars.peek() == Some(&'[') {
+                chars.next();
+                while let Some(&c) = chars.peek() {
+                    chars.next();
+                    if c.is_ascii_alphabetic() {
+                        break;
+                    }
+                }
+            }
+        } else {
+            result.push(c);
+        }
+    }
+
+    result
+}
+
+fn wrap_line_ranges(ranges: &[(u32, u32)], max_width: usize) -> String {
+    let ranges_plain: Vec<String> = ranges
+        .iter()
+        .map(
+            |(start, end)| {
+                if start == end { start.to_string() } else { format!("{}-{}", start, end) }
+            },
+        )
+        .collect();
+
+    let full_str = ranges_plain.join(", ");
+
+    if full_str.len() <= max_width {
+        return full_str.red().to_string();
+    }
+
+    let mut result = String::new();
+    let mut current_line = String::new();
+    let mut current_width = 0;
+
+    for (i, range_str) in ranges_plain.iter().enumerate() {
+        let range_width = range_str.len();
+        let comma_sep = ", ";
+        let sep_width = if current_width > 0 { comma_sep.len() } else { 0 };
+
+        if current_width + sep_width + range_width <= max_width {
+            if current_width > 0 {
+                current_line.push_str(comma_sep);
+                current_width += comma_sep.len();
+            }
+            current_line.push_str(range_str);
+            current_width += range_width;
+        } else {
+            if !current_line.is_empty() {
+                result.push_str(&current_line.red().to_string());
+                result.push('\n');
+            }
+            current_line = range_str.to_string();
+            current_width = range_width;
+        }
+
+        if i == ranges_plain.len() - 1 && !current_line.is_empty() {
+            result.push_str(&current_line.red().to_string());
+        }
+    }
+
+    result
+}
+
+pub fn report_coverage(report: &CoverageReport) -> String {
+    let mut output = String::new();
+
+    output.push_str(&"=".repeat(80).cyan().to_string());
+    output.push('\n');
+    output.push_str(&"COVERAGE REPORT".cyan().bold().to_string());
+    output.push('\n');
+    output.push_str(&"=".repeat(80).cyan().to_string());
+    output.push_str("\n\n");
+
+    output.push_str(&"SUMMARY".green().bold().to_string());
+    output.push('\n');
+    output.push_str(&"-".repeat(80).cyan().to_string());
+    output.push('\n');
+    output.push_str(&format!("Total files:                {}\n", report.files.len().bold()));
+    output.push_str(&format!("Total lines:                {}\n", report.totals.total.bold()));
+    output.push_str(&format!(
+        "Covered lines:              {}\n",
+        report.totals.hit.green().bold()
+    ));
+    output.push_str(&format!(
+        "Uncovered lines:            {}\n",
+        report.totals.miss.red().bold()
+    ));
+
+    let rate_text = if report.totals.rate >= 80.0 {
+        format!("{:.2}%", report.totals.rate).green().bold().to_string()
+    } else if report.totals.rate >= 50.0 {
+        format!("{:.2}%", report.totals.rate).yellow().bold().to_string()
+    } else {
+        format!("{:.2}%", report.totals.rate).red().bold().to_string()
+    };
+    output.push_str(&format!("Coverage rate:              {}\n\n", rate_text));
+
+    if !report.files.is_empty() {
+        output.push_str(&"FILE COVERAGE".green().bold().to_string());
+        output.push('\n');
+        output.push_str(&"-".repeat(80).cyan().to_string());
+        output.push('\n');
+
+        for file in &report.files {
+            output.push_str(&format!("{}\n", format_file_coverage(file, 2)));
+        }
+    }
+
+    output.push_str(&"=".repeat(80).cyan().to_string());
+    output.push('\n');
+
+    output
+}
+
+pub fn format_file_coverage(file: &FileCoverage, indent: usize) -> String {
+    let spaces = " ".repeat(indent);
+    let uncovered_prefix = format!("{}    Uncovered:  ", spaces);
+    let mut output = String::new();
+
+    output.push_str(&spaces);
+    output.push_str("FILE: ");
+    let file_path = file.path.bold().to_string();
+    let current_width = spaces.len() + "FILE: ".len();
+    let remaining_width = 80 - current_width;
+
+    let path_only = file.path.to_string();
+    if path_only.len() <= remaining_width {
+        output.push_str(&file_path);
+    } else {
+        for (i, chunk) in path_only.as_bytes().chunks(remaining_width).enumerate() {
+            if i > 0 {
+                output.push_str(&format!("\n{}    ", spaces));
+            }
+            output.push_str(&String::from_utf8_lossy(chunk).bold().to_string());
+        }
+    }
+    output.push('\n');
+
+    let rate_text = if file.summary.rate >= 80.0 {
+        format!("{:.2}%", file.summary.rate).green().bold().to_string()
+    } else if file.summary.rate >= 50.0 {
+        format!("{:.2}%", file.summary.rate).yellow().bold().to_string()
+    } else {
+        format!("{:.2}%", file.summary.rate).red().bold().to_string()
+    };
+
+    output.push_str(&spaces);
+    output.push_str(&format!(
+        "    Lines:      {} / {} ({})\n",
+        file.summary.hit.green().bold(),
+        file.summary.total,
+        rate_text
+    ));
+
+    if !file.miss_ranges.is_empty() {
+        output.push_str(&uncovered_prefix);
+        let max_width = 80 - uncovered_prefix.len();
+
+        let wrapped_ranges = wrap_line_ranges(&file.miss_ranges, max_width);
+        for (i, line) in wrapped_ranges.lines().enumerate() {
+            if i > 0 {
+                output.push_str(&" ".repeat(uncovered_prefix.len()));
+            }
+            output.push_str(line);
+            output.push('\n');
+        }
+    }
+
+    output
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::coverage::FileCoverage;
+    use std::collections::BTreeMap;
+
+    #[test]
+    fn test_report_coverage_empty() {
+        let report = CoverageReport::new(vec![]);
+        let output = report_coverage(&report);
+        let output = strip_ansi_codes(&output);
+
+        assert!(output.contains("COVERAGE REPORT"));
+        assert!(output.contains("Total files:                0"));
+    }
+
+    #[test]
+    fn test_report_coverage_with_files() {
+        let mut lines = BTreeMap::new();
+        lines.insert(1, 10);
+        lines.insert(2, 0);
+        lines.insert(3, 5);
+
+        let file = FileCoverage::new("test.rs".to_string(), lines);
+        let report = CoverageReport::new(vec![file]);
+        let output = report_coverage(&report);
+        let output = strip_ansi_codes(&output);
+
+        assert!(output.contains("COVERAGE REPORT"));
+        assert!(output.contains("test.rs"));
+        assert!(output.contains("2 / 3"));
+        assert!(output.contains("Uncovered:  2"));
+    }
+
+    #[test]
+    fn test_format_file_coverage() {
+        let mut lines = BTreeMap::new();
+        lines.insert(1, 10);
+        lines.insert(2, 0);
+        lines.insert(3, 5);
+        lines.insert(4, 0);
+        lines.insert(5, 0);
+
+        let file = FileCoverage::new("test.rs".to_string(), lines);
+        let output = format_file_coverage(&file, 2);
+        let output = strip_ansi_codes(&output);
+
+        assert!(output.contains("FILE: test.rs"));
+        assert!(output.contains("2 / 5"));
+        assert!(output.contains("Uncovered:  2, 4-5"));
+    }
+
+    #[test]
+    fn test_format_file_coverage_full() {
+        let mut lines = BTreeMap::new();
+        lines.insert(1, 10);
+        lines.insert(2, 5);
+        lines.insert(3, 1);
+
+        let file = FileCoverage::new("full.rs".to_string(), lines);
+        let output = format_file_coverage(&file, 2);
+        let output = strip_ansi_codes(&output);
+
+        assert!(output.contains("FILE: full.rs"));
+        assert!(output.contains("3 / 3 (100.00%)"));
+        assert!(!output.contains("Uncovered"));
+    }
+}

crates/core/src/reporter/mod.rs

···
+pub mod coverage_jsonl;
+pub mod coverage_term;
+pub mod legacy;
+
+pub use coverage_jsonl::JsonlReporter;
+pub use coverage_term::{format_file_coverage, report_coverage};
+pub use legacy::{FileReport, Report, Summary};

todo.txt

···
+================================================================================
+todo.txt
+================================================================================
+A. Test Coverage Ingestion
+   - Ingest LCOV/JSON from `cargo llvm-cov` or `cargo test -- --coverage`.
+   - Render to terminal, HTML, Markdown, JSONL.
+   - Support path normalization (`--root`, `--strip-prefix`, `--ignore-regex`).
+   - Support Git diff coverage
+
+B. AST-Based Clone Detection
+   - Compare abstract syntax trees or subtrees.
+   - Identifies clones resilient to renamed variables or formatting changes.
+   - Requires per-language AST adapters.
+
+C. Cognitive Complexity
+   - Scores human comprehension cost.
+   - Rewards flattened control flow, penalizes deep nesting.
+   - Requires AST-level traversal.
+
+D. Maintainability Index
+   - Combines Cyclomatic, Halstead, and LOC into a single number.
+   - Good for dashboards and longitudinal tracking.
+
+E. Semantic Clone Detection
+   - Goes beyond syntax: identifies logically equivalent code.
+   - Requires control/data-flow analysis.
+
+F. Dependency Metrics
+   - Coupling, fan-in/fan-out, depth of inheritance.
+   - Requires language-specific type-resolution or symbol graph extraction.
+
+G. Hotspot Analysis
+   - Combine Git history + complexity metrics.
+   - Identify files that change often AND are complex.
+
+H. Incremental Mode
+   - Cache hashes/graphs.
+   - Analyze only changed files and touched boundaries.
+
+I. Rich Reports
+   - HTML dashboards
+   - SVG graphs (CFG visualization)
+   - JSON with stable schema for CI systems
+
+-------------------------------------------------------------------------------
+SUMMARY
+
+MVP:
+  - LOC
+  - Cyclomatic Complexity
+  - Rabin-Karp Clone Detection
+  - Halstead Complexity
+
+Beyond MVP:
+  - AST-based clones
+  - Cognitive Complexity
+  - Maintainability Index
+  - Coupling metrics
+  - Call graphs and data-flow graphs
+  - Hotspot analysis
+  - Incremental scanning