churnloom 0.1.0

Fast codebase health reports woven from churn, LOC, structure, and Cargo ownership
Documentation
use std::{
    collections::{BTreeMap, HashMap, HashSet},
    path::{Path, PathBuf},
    process::Command,
};

use anyhow::{Context, Result, bail};
use chrono::{Days, Local, NaiveDate};

use crate::model::{Churn, DailyThroughput, ThroughputSummary};

const COMMIT_MARKER: &str = "__CHURNLOOM__";

#[derive(Clone, Copy, Debug, Default)]
pub struct FileChurn {
    pub short: Churn,
    pub long: Churn,
}

#[derive(Debug, Default)]
pub struct GitHistory {
    pub files: HashMap<String, FileChurn>,
    pub short: ThroughputSummary,
    pub long: ThroughputSummary,
    pub daily_long: Vec<DailyThroughput>,
}

pub fn find_git_root(path: &Path) -> Option<PathBuf> {
    let output = Command::new("git")
        .args(["-C", path.to_str()?, "rev-parse", "--show-toplevel"])
        .output()
        .ok()?;
    if !output.status.success() {
        return None;
    }
    let root = String::from_utf8(output.stdout).ok()?;
    PathBuf::from(root.trim()).canonicalize().ok()
}

pub fn collect(
    git_root: &Path,
    eligible: &HashSet<String>,
    pathspecs: &[String],
    short_days: u32,
    long_days: u32,
) -> Result<GitHistory> {
    let today = Local::now().date_naive();
    let short_start = window_start(today, short_days);
    let long_start = window_start(today, long_days);
    let mut command = Command::new("git");
    command.current_dir(git_root).args([
        "-c",
        "core.quotepath=false",
        "log",
        &format!("--since={long_start}T00:00:00"),
        "--date=short",
        &format!("--pretty=format:{COMMIT_MARKER}%x09%ad"),
        "--numstat",
        "--find-renames",
        "--",
    ]);
    if pathspecs.is_empty() {
        command.arg(".");
    } else {
        command.args(pathspecs);
    }
    let output = command.output().context("failed to run git log")?;
    if !output.status.success() {
        bail!(
            "git log failed: {}",
            String::from_utf8_lossy(&output.stderr).trim()
        );
    }
    Ok(parse_log(
        &String::from_utf8_lossy(&output.stdout),
        eligible,
        short_start,
        long_start,
        today,
        short_days,
        long_days,
    ))
}

fn window_start(today: NaiveDate, days: u32) -> NaiveDate {
    today
        .checked_sub_days(Days::new(u64::from(days.saturating_sub(1))))
        .unwrap_or(NaiveDate::MIN)
}

fn parse_log(
    text: &str,
    eligible: &HashSet<String>,
    short_start: NaiveDate,
    long_start: NaiveDate,
    today: NaiveDate,
    short_days: u32,
    long_days: u32,
) -> GitHistory {
    let mut history = GitHistory {
        short: ThroughputSummary {
            days: short_days,
            ..ThroughputSummary::default()
        },
        long: ThroughputSummary {
            days: long_days,
            ..ThroughputSummary::default()
        },
        ..GitHistory::default()
    };
    let mut daily_long = BTreeMap::<NaiveDate, DailyThroughput>::new();
    let mut day = None;
    let mut touched_short = false;
    let mut touched_long = false;

    let finish_commit = |history: &mut GitHistory,
                         daily_long: &mut BTreeMap<NaiveDate, DailyThroughput>,
                         day: Option<NaiveDate>,
                         touched_short: &mut bool,
                         touched_long: &mut bool| {
        if *touched_short {
            history.short.commits += 1;
        }
        if *touched_long {
            history.long.commits += 1;
            if let Some(day) = day {
                daily_long.entry(day).or_default().commits += 1;
            }
        }
        *touched_short = false;
        *touched_long = false;
    };

    for line in text.lines().filter(|line| !line.is_empty()) {
        if let Some(header) = line.strip_prefix(COMMIT_MARKER) {
            finish_commit(
                &mut history,
                &mut daily_long,
                day,
                &mut touched_short,
                &mut touched_long,
            );
            day = NaiveDate::parse_from_str(header.trim_start_matches('\t'), "%Y-%m-%d").ok();
            continue;
        }
        let Some(day) = day.filter(|day| *day >= long_start && *day <= today) else {
            continue;
        };
        let mut fields = line.split('\t');
        let Some(added) = fields.next().and_then(|value| value.parse::<u64>().ok()) else {
            continue;
        };
        let Some(deleted) = fields.next().and_then(|value| value.parse::<u64>().ok()) else {
            continue;
        };
        let Some(raw_path) = fields.next() else {
            continue;
        };
        let path = normalize_rename(raw_path.trim());
        if !eligible.contains(&path) {
            continue;
        }

        let file = history.files.entry(path).or_default();
        file.long.add(added, deleted);
        add_throughput(&mut history.long, added, deleted);
        daily_long.entry(day).or_default().add(added, deleted);
        touched_long = true;

        if day >= short_start {
            file.short.add(added, deleted);
            add_throughput(&mut history.short, added, deleted);
            touched_short = true;
        }
    }
    finish_commit(
        &mut history,
        &mut daily_long,
        day,
        &mut touched_short,
        &mut touched_long,
    );
    history.short.active_days = daily_long
        .iter()
        .filter(|(day, summary)| **day >= short_start && summary.changed > 0)
        .count();
    history.long.active_days = daily_long
        .values()
        .filter(|summary| summary.changed > 0)
        .count();
    history.daily_long = complete_daily_window(daily_long, long_start, today);
    history
}

fn complete_daily_window(
    mut daily: BTreeMap<NaiveDate, DailyThroughput>,
    start: NaiveDate,
    end: NaiveDate,
) -> Vec<DailyThroughput> {
    let mut output = Vec::new();
    let mut day = start;
    while day <= end {
        let mut summary = daily.remove(&day).unwrap_or_default();
        summary.date = day.to_string();
        output.push(summary);
        let Some(next) = day.checked_add_days(Days::new(1)) else {
            break;
        };
        day = next;
    }
    output
}

fn add_throughput(summary: &mut ThroughputSummary, added: u64, deleted: u64) {
    summary.added += added;
    summary.deleted += deleted;
    summary.changed += added + deleted;
}

fn normalize_rename(path: &str) -> String {
    if !path.contains("=>") {
        return path.to_string();
    }
    if let (Some(open), Some(close)) = (path.find('{'), path.find('}'))
        && open < close
    {
        let replacement = path[open + 1..close]
            .split("=>")
            .last()
            .unwrap_or_default()
            .trim();
        return format!("{}{}{}", &path[..open], replacement, &path[close + 1..]);
    }
    path.split("=>").last().unwrap_or(path).trim().to_string()
}

#[cfg(test)]
mod tests {
    use std::collections::HashSet;

    use chrono::NaiveDate;

    use super::{normalize_rename, parse_log};

    #[test]
    fn normalizes_compact_and_full_rename_forms() {
        assert_eq!(
            normalize_rename("src/{old => new}/lib.rs"),
            "src/new/lib.rs"
        );
        assert_eq!(normalize_rename("old.rs => new.rs"), "new.rs");
    }

    #[test]
    fn derives_both_windows_from_one_log() {
        let eligible = HashSet::from(["src/lib.rs".to_string()]);
        let log = "__CHURNLOOM__\t2026-01-04\n11\t0\tsrc/lib.rs\n\
                   __CHURNLOOM__\t2026-01-02\n3\t2\tsrc/lib.rs\n\
                   __CHURNLOOM__\t2026-01-01\n7\t1\tsrc/lib.rs\n\
                   __CHURNLOOM__\t2025-12-31\n13\t0\tsrc/lib.rs\n";
        let history = parse_log(
            log,
            &eligible,
            NaiveDate::from_ymd_opt(2026, 1, 2).unwrap(),
            NaiveDate::from_ymd_opt(2026, 1, 1).unwrap(),
            NaiveDate::from_ymd_opt(2026, 1, 3).unwrap(),
            2,
            3,
        );
        assert_eq!(history.files["src/lib.rs"].short.changed(), 5);
        assert_eq!(history.files["src/lib.rs"].long.changed(), 13);
        assert_eq!(history.short.commits, 1);
        assert_eq!(history.long.commits, 2);
        assert_eq!(history.short.active_days, 1);
        assert_eq!(history.long.active_days, 2);
        assert_eq!(history.daily_long.len(), 3);
        assert_eq!(history.daily_long[0].date, "2026-01-01");
        assert_eq!(history.daily_long[1].changed, 5);
        assert_eq!(history.daily_long[2].changed, 0);
    }
}