gitstack/

cli.rs

//! CLIモード（非対話モード）モジュール
//!
//! Claude CodeなどのAI開発環境から直接統計情報を取得するための
//! 非対話モードを提供する
//!
//! ## セキュリティ考慮事項
//!
//! - 入力バリデーション: コマンドライン引数の値を検証
//! - リソース制限: 読み込み件数に上限を設定（DoS防止）
//! - エラーメッセージ: 内部情報を露出しない汎用メッセージを使用

use std::env;

use anyhow::Result;
use git2::Repository;

use crate::event::GitEvent;
use crate::export::{
    bus_factor_to_json, coupling_to_json, heatmap_to_json, impact_to_json, log_to_json,
    ownership_to_json, quality_to_json, stats_to_json, tech_debt_to_json, timeline_to_json,
};
use crate::git::{get_commit_files, load_events};
use crate::stats::{
    calculate_activity_timeline, calculate_bus_factor, calculate_change_coupling,
    calculate_file_heatmap, calculate_impact_scores, calculate_ownership, calculate_quality_scores,
    calculate_stats, calculate_tech_debt,
};

/// ログ出力の最大件数（セキュリティ: リソース枯渇防止）
const MAX_LOG_LIMIT: usize = 10000;

/// ログ出力のデフォルト件数
const DEFAULT_LOG_LIMIT: usize = 10;

/// 統計計算用の最大イベント読み込み件数
const MAX_EVENTS_FOR_STATS: usize = 2000;

// コンパイル時セキュリティチェック
const _: () = {
    assert!(MAX_LOG_LIMIT <= 10000, "MAX_LOG_LIMIT must be reasonable");
    assert!(MAX_LOG_LIMIT > 0, "MAX_LOG_LIMIT must be positive");
    assert!(
        DEFAULT_LOG_LIMIT <= MAX_LOG_LIMIT,
        "DEFAULT must not exceed MAX"
    );
    assert!(
        MAX_EVENTS_FOR_STATS <= 10000,
        "MAX_EVENTS_FOR_STATS must be reasonable"
    );
    assert!(
        MAX_EVENTS_FOR_STATS > 0,
        "MAX_EVENTS_FOR_STATS must be positive"
    );
};

/// 出力フォーマット
#[derive(Debug, Clone, Copy, PartialEq, Eq, Default)]
pub enum OutputFormat {
    #[default]
    Json,
    Markdown,
}

impl OutputFormat {
    fn from_str(s: &str) -> Option<Self> {
        match s.to_lowercase().as_str() {
            "json" => Some(OutputFormat::Json),
            "md" | "markdown" => Some(OutputFormat::Markdown),
            _ => None,
        }
    }
}

/// CLIコマンド
#[derive(Debug, Clone, PartialEq)]
pub enum CliCommand {
    /// ベンチマークモード
    Benchmark,
    /// 著者統計を出力
    Stats { format: OutputFormat },
    /// ファイルヒートマップを出力
    Heatmap { format: OutputFormat },
    /// Impact Scoreを出力
    Impact { format: OutputFormat },
    /// Change Couplingを出力
    Coupling { format: OutputFormat },
    /// コードオーナーシップを出力
    Ownership { format: OutputFormat },
    /// コミット品質スコアを出力
    Quality { format: OutputFormat },
    /// 活動タイムラインを出力
    Timeline { format: OutputFormat },
    /// バスファクター分析を出力
    BusFactor { format: OutputFormat },
    /// 技術的負債スコアを出力
    TechDebt { format: OutputFormat },
    /// 最新N件のログを出力
    Log { limit: usize, format: OutputFormat },
    /// ヘルプ表示
    Help,
    /// バージョン表示
    Version,
}

/// コマンドライン引数をパースしてCliCommandを返す
///
/// CLIコマンドが指定されていない場合はNoneを返す（TUIモード起動）
///
/// ## セキュリティ
///
/// - `--log -n N` の N は `MAX_LOG_LIMIT` を超えないよう制限
/// - 不正な入力値はデフォルト値にフォールバック
pub fn parse_cli_args() -> Option<CliCommand> {
    let args: Vec<String> = env::args().collect();

    // 引数が1つ以下（プログラム名のみ）の場合はTUIモード
    if args.len() <= 1 {
        return None;
    }

    // --format オプションを探す
    let format = find_format_option(&args);

    // 各引数をチェック
    let mut i = 1;
    while i < args.len() {
        match args[i].as_str() {
            "--benchmark" => return Some(CliCommand::Benchmark),
            "--stats" => return Some(CliCommand::Stats { format }),
            "--heatmap" => return Some(CliCommand::Heatmap { format }),
            "--impact" => return Some(CliCommand::Impact { format }),
            "--coupling" => return Some(CliCommand::Coupling { format }),
            "--ownership" => return Some(CliCommand::Ownership { format }),
            "--quality" => return Some(CliCommand::Quality { format }),
            "--timeline" => return Some(CliCommand::Timeline { format }),
            "--bus-factor" => return Some(CliCommand::BusFactor { format }),
            "--tech-debt" => return Some(CliCommand::TechDebt { format }),
            "--log" => {
                // -n オプションを探す
                let limit = if i + 2 < args.len() && args[i + 1] == "-n" {
                    // セキュリティ: 入力値のバリデーション
                    match args[i + 2].parse::<usize>() {
                        Ok(n) if n > 0 && n <= MAX_LOG_LIMIT => n,
                        Ok(n) if n > MAX_LOG_LIMIT => {
                            eprintln!(
                                "Warning: limit {} exceeds maximum ({}), using maximum",
                                n, MAX_LOG_LIMIT
                            );
                            MAX_LOG_LIMIT
                        }
                        _ => {
                            eprintln!(
                                "Warning: invalid limit value, using default ({})",
                                DEFAULT_LOG_LIMIT
                            );
                            DEFAULT_LOG_LIMIT
                        }
                    }
                } else {
                    DEFAULT_LOG_LIMIT
                };
                return Some(CliCommand::Log { limit, format });
            }
            "--help" | "-h" => return Some(CliCommand::Help),
            "--version" | "-V" => return Some(CliCommand::Version),
            _ => {}
        }
        i += 1;
    }

    None
}

/// --format オプションを探す
fn find_format_option(args: &[String]) -> OutputFormat {
    for i in 0..args.len() {
        if args[i] == "--format" && i + 1 < args.len() {
            if let Some(fmt) = OutputFormat::from_str(&args[i + 1]) {
                return fmt;
            }
        }
    }
    OutputFormat::default()
}

/// CLIモードを実行
pub fn run_cli_mode(command: CliCommand) -> Result<()> {
    match command {
        CliCommand::Benchmark => {
            // ベンチマークモードは main.rs で処理済み
            // ここに来ることはないが、念のため
            Ok(())
        }
        CliCommand::Stats { format } => run_stats(format),
        CliCommand::Heatmap { format } => run_heatmap(format),
        CliCommand::Impact { format } => run_impact(format),
        CliCommand::Coupling { format } => run_coupling(format),
        CliCommand::Ownership { format } => run_ownership(format),
        CliCommand::Quality { format } => run_quality(format),
        CliCommand::Timeline { format } => run_timeline(format),
        CliCommand::BusFactor { format } => run_bus_factor(format),
        CliCommand::TechDebt { format } => run_tech_debt(format),
        CliCommand::Log { limit, format } => run_log(limit, format),
        CliCommand::Help => run_help(),
        CliCommand::Version => run_version(),
    }
}

/// 著者統計を出力
fn run_stats(format: OutputFormat) -> Result<()> {
    let events = load_events_or_error()?;
    let event_refs: Vec<&GitEvent> = events.iter().collect();
    let stats = calculate_stats(&event_refs);

    let output = match format {
        OutputFormat::Json => stats_to_json(&stats)?,
        OutputFormat::Markdown => stats_to_markdown(&stats),
    };
    println!("{}", output);
    Ok(())
}

/// ファイルヒートマップを出力
fn run_heatmap(format: OutputFormat) -> Result<()> {
    let events = load_events_or_error()?;
    let event_refs: Vec<&GitEvent> = events.iter().collect();
    let heatmap = calculate_file_heatmap(&event_refs, |hash| get_commit_files(hash).ok());

    let output = match format {
        OutputFormat::Json => heatmap_to_json(&heatmap)?,
        OutputFormat::Markdown => heatmap_to_markdown(&heatmap),
    };
    println!("{}", output);
    Ok(())
}

/// Impact Scoreを出力
fn run_impact(format: OutputFormat) -> Result<()> {
    let events = load_events_or_error()?;
    let event_refs: Vec<&GitEvent> = events.iter().collect();
    let heatmap = calculate_file_heatmap(&event_refs, |hash| get_commit_files(hash).ok());
    let analysis =
        calculate_impact_scores(&event_refs, |hash| get_commit_files(hash).ok(), &heatmap);

    let output = match format {
        OutputFormat::Json => impact_to_json(&analysis)?,
        OutputFormat::Markdown => impact_to_markdown(&analysis),
    };
    println!("{}", output);
    Ok(())
}

/// Change Couplingを出力
fn run_coupling(format: OutputFormat) -> Result<()> {
    let events = load_events_or_error()?;
    let event_refs: Vec<&GitEvent> = events.iter().collect();
    let analysis = calculate_change_coupling(
        &event_refs,
        |hash| get_commit_files(hash).ok(),
        5,   // min_commits
        0.3, // min_coupling
    );

    let output = match format {
        OutputFormat::Json => coupling_to_json(&analysis)?,
        OutputFormat::Markdown => coupling_to_markdown(&analysis),
    };
    println!("{}", output);
    Ok(())
}

/// コードオーナーシップを出力
fn run_ownership(format: OutputFormat) -> Result<()> {
    let events = load_events_or_error()?;
    let event_refs: Vec<&GitEvent> = events.iter().collect();
    let ownership = calculate_ownership(&event_refs, |hash| get_commit_files(hash).ok());

    let output = match format {
        OutputFormat::Json => ownership_to_json(&ownership)?,
        OutputFormat::Markdown => ownership_to_markdown(&ownership),
    };
    println!("{}", output);
    Ok(())
}

/// コミット品質スコアを出力
fn run_quality(format: OutputFormat) -> Result<()> {
    let events = load_events_or_error()?;
    let event_refs: Vec<&GitEvent> = events.iter().collect();
    let coupling = calculate_change_coupling(
        &event_refs,
        |hash| get_commit_files(hash).ok(),
        5,
        0.3,
    );
    let analysis =
        calculate_quality_scores(&event_refs, |hash| get_commit_files(hash).ok(), &coupling);

    let output = match format {
        OutputFormat::Json => quality_to_json(&analysis)?,
        OutputFormat::Markdown => quality_to_markdown(&analysis),
    };
    println!("{}", output);
    Ok(())
}

/// 活動タイムラインを出力
fn run_timeline(format: OutputFormat) -> Result<()> {
    let events = load_events_or_error()?;
    let event_refs: Vec<&GitEvent> = events.iter().collect();
    let timeline = calculate_activity_timeline(&event_refs);

    let output = match format {
        OutputFormat::Json => timeline_to_json(&timeline)?,
        OutputFormat::Markdown => timeline_to_markdown(&timeline),
    };
    println!("{}", output);
    Ok(())
}

/// バスファクター分析を出力
fn run_bus_factor(format: OutputFormat) -> Result<()> {
    let events = load_events_or_error()?;
    let event_refs: Vec<&GitEvent> = events.iter().collect();
    let analysis = calculate_bus_factor(&event_refs, |hash| get_commit_files(hash).ok(), 5);

    let output = match format {
        OutputFormat::Json => bus_factor_to_json(&analysis)?,
        OutputFormat::Markdown => bus_factor_to_markdown(&analysis),
    };
    println!("{}", output);
    Ok(())
}

/// 技術的負債スコアを出力
fn run_tech_debt(format: OutputFormat) -> Result<()> {
    let events = load_events_or_error()?;
    let event_refs: Vec<&GitEvent> = events.iter().collect();
    let analysis = calculate_tech_debt(&event_refs, |hash| get_commit_files(hash).ok(), 3);

    let output = match format {
        OutputFormat::Json => tech_debt_to_json(&analysis)?,
        OutputFormat::Markdown => tech_debt_to_markdown(&analysis),
    };
    println!("{}", output);
    Ok(())
}

/// 最新N件のログを出力
fn run_log(limit: usize, format: OutputFormat) -> Result<()> {
    let events = load_events_limited(limit)?;

    let output = match format {
        OutputFormat::Json => log_to_json(&events)?,
        OutputFormat::Markdown => log_to_markdown(&events),
    };
    println!("{}", output);
    Ok(())
}

/// ヘルプを表示
fn run_help() -> Result<()> {
    let help = format!(
        r#"gitstack - Git history viewer with insights

USAGE:
    gitstack [OPTIONS]

ANALYSIS OPTIONS:
    --stats       Output author statistics
    --heatmap     Output file change heatmap
    --impact      Output Impact Score (commit influence)
    --coupling    Output Change Coupling (file co-change)
    --ownership   Output Code Ownership
    --quality     Output Commit Quality Score
    --timeline    Output Activity Timeline
    --bus-factor  Output Bus Factor analysis (knowledge risk)
    --tech-debt   Output Technical Debt Score
    --log -n N    Output latest N commits (default: {}, max: {})

FORMAT OPTIONS:
    --format json     Output as JSON (default)
    --format md       Output as Markdown

GENERAL OPTIONS:
    --help, -h        Show this help message
    --version, -V     Show version information

Without options, gitstack starts in interactive TUI mode.

EXAMPLES:
    gitstack --stats                      # JSON output
    gitstack --stats --format md          # Markdown output
    gitstack --bus-factor --format json   # Bus factor analysis
    gitstack --tech-debt --format md      # Tech debt as Markdown
    gitstack --log -n 5 | jq .            # Latest 5 commits

For more information, visit: https://github.com/Hiro-Chiba/gitstack"#,
        DEFAULT_LOG_LIMIT, MAX_LOG_LIMIT
    );

    println!("{}", help);
    Ok(())
}

/// バージョン情報を表示
fn run_version() -> Result<()> {
    println!("gitstack {}", env!("CARGO_PKG_VERSION"));
    Ok(())
}

/// イベントを読み込む（エラー時はstderrに出力してエラー返却）
fn load_events_or_error() -> Result<Vec<GitEvent>> {
    Repository::discover(".").map_err(|_| {
        anyhow::anyhow!("Error: Not a git repository (or any of the parent directories)")
    })?;

    load_events(MAX_EVENTS_FOR_STATS).map_err(|_| {
        anyhow::anyhow!("Error: Failed to load git history")
    })
}

/// 指定件数のイベントを読み込む
fn load_events_limited(limit: usize) -> Result<Vec<GitEvent>> {
    Repository::discover(".").map_err(|_| {
        anyhow::anyhow!("Error: Not a git repository (or any of the parent directories)")
    })?;

    let safe_limit = limit.min(MAX_LOG_LIMIT);

    load_events(safe_limit).map_err(|_| {
        anyhow::anyhow!("Error: Failed to load git history")
    })
}

// ============================================================
// Markdown出力関数
// ============================================================

use crate::stats::{
    ActivityTimeline, BusFactorAnalysis, ChangeCouplingAnalysis, CodeOwnership,
    CommitImpactAnalysis, CommitQualityAnalysis, FileHeatmap, RepoStats, TechDebtAnalysis,
};

fn stats_to_markdown(stats: &RepoStats) -> String {
    let mut md = String::new();
    md.push_str("# Author Statistics\n\n");
    md.push_str(&format!(
        "- **Total Commits**: {}\n",
        stats.total_commits
    ));
    md.push_str(&format!(
        "- **Total Insertions**: {}\n",
        stats.total_insertions
    ));
    md.push_str(&format!(
        "- **Total Deletions**: {}\n",
        stats.total_deletions
    ));
    md.push_str(&format!("- **Authors**: {}\n\n", stats.author_count()));

    md.push_str("## Top Contributors\n\n");
    md.push_str("| Author | Commits | Lines (+/-) | % |\n");
    md.push_str("|--------|--------:|------------:|--:|\n");
    for author in stats.authors.iter().take(20) {
        md.push_str(&format!(
            "| {} | {} | +{} / -{} | {:.1}% |\n",
            author.name,
            author.commit_count,
            author.insertions,
            author.deletions,
            author.commit_percentage(stats.total_commits)
        ));
    }
    md
}

fn heatmap_to_markdown(heatmap: &FileHeatmap) -> String {
    let mut md = String::new();
    md.push_str("# File Heatmap\n\n");
    md.push_str(&format!("**Total Files**: {}\n\n", heatmap.total_files));

    md.push_str("## Hot Files (Most Changed)\n\n");
    md.push_str("| File | Changes | Heat |\n");
    md.push_str("|------|--------:|:----:|\n");
    for file in heatmap.files.iter().take(30) {
        let heat_bar = file.heat_bar();
        md.push_str(&format!(
            "| `{}` | {} | {} |\n",
            file.path, file.change_count, heat_bar
        ));
    }
    md
}

fn impact_to_markdown(analysis: &CommitImpactAnalysis) -> String {
    let mut md = String::new();
    md.push_str("# Impact Score Analysis\n\n");
    md.push_str(&format!(
        "- **Total Commits**: {}\n",
        analysis.total_commits
    ));
    md.push_str(&format!("- **Average Score**: {:.2}\n", analysis.avg_score));
    md.push_str(&format!(
        "- **High Impact Commits**: {}\n\n",
        analysis.high_impact_count
    ));

    md.push_str("## High Impact Commits\n\n");
    md.push_str("| Hash | Author | Score | Files | Message |\n");
    md.push_str("|------|--------|------:|------:|--------|\n");
    for commit in analysis.commits.iter().take(20) {
        let msg = if commit.commit_message.len() > 40 {
            format!("{}...", &commit.commit_message[..37])
        } else {
            commit.commit_message.clone()
        };
        md.push_str(&format!(
            "| `{}` | {} | {:.2} | {} | {} |\n",
            commit.commit_hash, commit.author, commit.score, commit.files_changed, msg
        ));
    }
    md
}

fn coupling_to_markdown(analysis: &ChangeCouplingAnalysis) -> String {
    let mut md = String::new();
    md.push_str("# Change Coupling Analysis\n\n");
    md.push_str(&format!(
        "- **Total Couplings**: {}\n",
        analysis.couplings.len()
    ));
    md.push_str(&format!(
        "- **High Coupling (>70%)**: {}\n\n",
        analysis.high_coupling_count
    ));

    md.push_str("## File Couplings\n\n");
    md.push_str("| File | Coupled With | Coupling | Co-Changes |\n");
    md.push_str("|------|--------------|----------|------------|\n");
    for coupling in analysis.couplings.iter().take(30) {
        md.push_str(&format!(
            "| `{}` | `{}` | {:.1}% | {} |\n",
            coupling.file,
            coupling.coupled_file,
            coupling.coupling_percent * 100.0,
            coupling.co_change_count
        ));
    }
    md
}

fn ownership_to_markdown(ownership: &CodeOwnership) -> String {
    let mut md = String::new();
    md.push_str("# Code Ownership\n\n");
    md.push_str(&format!("**Total Files**: {}\n\n", ownership.total_files));

    md.push_str("## Directory Ownership\n\n");
    md.push_str("| Path | Primary Owner | Ownership | Commits |\n");
    md.push_str("|------|---------------|-----------|--------:|\n");
    for entry in ownership.entries.iter().filter(|e| e.is_directory).take(30) {
        md.push_str(&format!(
            "| `{}/` | {} | {:.1}% | {} |\n",
            entry.path,
            entry.primary_author,
            entry.ownership_percentage(),
            entry.total_commits
        ));
    }
    md
}

fn quality_to_markdown(analysis: &CommitQualityAnalysis) -> String {
    let mut md = String::new();
    md.push_str("# Commit Quality Analysis\n\n");
    md.push_str(&format!(
        "- **Total Commits**: {}\n",
        analysis.total_commits
    ));
    md.push_str(&format!("- **Average Score**: {:.2}\n", analysis.avg_score));
    md.push_str(&format!(
        "- **High Quality (>0.6)**: {}\n",
        analysis.high_quality_count
    ));
    md.push_str(&format!(
        "- **Low Quality (<0.4)**: {}\n\n",
        analysis.low_quality_count
    ));

    md.push_str("## Quality Breakdown\n\n");
    md.push_str("| Hash | Author | Score | Level | Message |\n");
    md.push_str("|------|--------|------:|-------|--------|\n");
    for commit in analysis.commits.iter().take(20) {
        let msg = if commit.commit_message.len() > 40 {
            format!("{}...", &commit.commit_message[..37])
        } else {
            commit.commit_message.clone()
        };
        md.push_str(&format!(
            "| `{}` | {} | {:.2} | {} | {} |\n",
            commit.commit_hash,
            commit.author,
            commit.score,
            commit.quality_level(),
            msg
        ));
    }
    md
}

fn timeline_to_markdown(timeline: &ActivityTimeline) -> String {
    let mut md = String::new();
    md.push_str("# Activity Timeline\n\n");
    md.push_str(&format!(
        "- **Total Commits**: {}\n",
        timeline.total_commits
    ));
    md.push_str(&format!("- **Peak Time**: {}\n\n", timeline.peak_summary()));

    md.push_str("## Weekly Activity Heatmap\n\n");
    md.push_str("```\n");
    md.push_str("Hour:  00 03 06 09 12 15 18 21\n");
    md.push_str("       ┌──────────────────────────\n");
    for day in 0..7 {
        md.push_str(&format!(" {}  │ ", ActivityTimeline::day_name(day)));
        for hour in (0..24).step_by(3) {
            let level = timeline.heat_level(day, hour);
            md.push_str(ActivityTimeline::heat_char(level));
            md.push(' ');
        }
        md.push('\n');
    }
    md.push_str("```\n");
    md
}

fn bus_factor_to_markdown(analysis: &BusFactorAnalysis) -> String {
    let mut md = String::new();
    md.push_str("# Bus Factor Analysis\n\n");
    md.push_str(&format!(
        "- **Paths Analyzed**: {}\n",
        analysis.total_paths_analyzed
    ));
    md.push_str(&format!(
        "- **High Risk (Bus Factor = 1)**: {}\n",
        analysis.high_risk_count
    ));
    md.push_str(&format!(
        "- **Medium Risk (Bus Factor = 2)**: {}\n\n",
        analysis.medium_risk_count
    ));

    if analysis.high_risk_count > 0 {
        md.push_str("## ⚠️ High Risk Areas\n\n");
        md.push_str("These areas have only **1 person** with significant knowledge:\n\n");
        md.push_str("| Path | Bus Factor | Primary Contributor | Ownership |\n");
        md.push_str("|------|:----------:|---------------------|----------:|\n");
        for entry in analysis.entries.iter().filter(|e| e.bus_factor == 1).take(20) {
            if let Some(c) = entry.contributors.first() {
                md.push_str(&format!(
                    "| `{}/` | {} | {} | {:.1}% |\n",
                    entry.path, entry.bus_factor, c.name, c.contribution_percent
                ));
            }
        }
        md.push('\n');
    }

    md.push_str("## All Areas by Risk\n\n");
    md.push_str("| Path | Bus Factor | Risk | Top Contributors |\n");
    md.push_str("|------|:----------:|------|------------------|\n");
    for entry in analysis.entries.iter().take(30) {
        let contributors: Vec<String> = entry
            .contributors
            .iter()
            .take(3)
            .map(|c| format!("{} ({:.0}%)", c.name, c.contribution_percent))
            .collect();
        md.push_str(&format!(
            "| `{}/` | {} | {} | {} |\n",
            entry.path,
            entry.bus_factor,
            entry.risk_level.display_name(),
            contributors.join(", ")
        ));
    }
    md
}

fn tech_debt_to_markdown(analysis: &TechDebtAnalysis) -> String {
    let mut md = String::new();
    md.push_str("# Technical Debt Analysis\n\n");
    md.push_str(&format!(
        "- **Files Analyzed**: {}\n",
        analysis.total_files_analyzed
    ));
    md.push_str(&format!("- **Average Score**: {:.2}\n", analysis.avg_score));
    md.push_str(&format!(
        "- **High Debt Files**: {}\n\n",
        analysis.high_debt_count
    ));

    if analysis.high_debt_count > 0 {
        md.push_str("## ⚠️ High Debt Files\n\n");
        md.push_str("These files have high churn and complexity:\n\n");
        md.push_str("| File | Score | Churn | Complexity | Changes |\n");
        md.push_str("|------|------:|------:|-----------:|--------:|\n");
        for entry in analysis
            .entries
            .iter()
            .filter(|e| e.debt_level == crate::stats::TechDebtLevel::High)
            .take(20)
        {
            md.push_str(&format!(
                "| `{}` | {:.2} | {:.2} | {:.2} | {} |\n",
                entry.path,
                entry.score,
                entry.churn_score,
                entry.complexity_score,
                entry.change_count
            ));
        }
        md.push('\n');
    }

    md.push_str("## All Files by Debt Score\n\n");
    md.push_str("| File | Score | Level | Changes | Total Lines |\n");
    md.push_str("|------|------:|-------|--------:|------------:|\n");
    for entry in analysis.entries.iter().take(30) {
        md.push_str(&format!(
            "| `{}` | {:.2} | {} | {} | {} |\n",
            entry.path,
            entry.score,
            entry.debt_level.display_name(),
            entry.change_count,
            entry.total_changes
        ));
    }
    md
}

fn log_to_markdown(events: &[GitEvent]) -> String {
    let mut md = String::new();
    md.push_str("# Recent Commits\n\n");
    md.push_str(&format!("**Showing**: {} commits\n\n", events.len()));

    md.push_str("| Hash | Author | Date | Message |\n");
    md.push_str("|------|--------|------|--------|\n");
    for event in events {
        let date = event.timestamp.format("%Y-%m-%d");
        let msg = if event.message.len() > 50 {
            format!("{}...", &event.message[..47])
        } else {
            event.message.clone()
        };
        md.push_str(&format!(
            "| `{}` | {} | {} | {} |\n",
            event.short_hash, event.author, date, msg
        ));
    }
    md
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn test_parse_cli_args_stats() {
        assert_eq!(
            CliCommand::Stats {
                format: OutputFormat::Json
            },
            CliCommand::Stats {
                format: OutputFormat::Json
            }
        );
    }

    #[test]
    fn test_parse_cli_args_help() {
        assert_eq!(CliCommand::Help, CliCommand::Help);
    }

    #[test]
    fn test_parse_cli_args_version() {
        assert_eq!(CliCommand::Version, CliCommand::Version);
    }

    #[test]
    fn test_parse_cli_args_log_default() {
        let log = CliCommand::Log {
            limit: 10,
            format: OutputFormat::Json,
        };
        if let CliCommand::Log { limit, .. } = log {
            assert_eq!(limit, 10);
        }
    }

    #[test]
    fn test_output_format_from_str() {
        assert_eq!(OutputFormat::from_str("json"), Some(OutputFormat::Json));
        assert_eq!(OutputFormat::from_str("JSON"), Some(OutputFormat::Json));
        assert_eq!(OutputFormat::from_str("md"), Some(OutputFormat::Markdown));
        assert_eq!(
            OutputFormat::from_str("markdown"),
            Some(OutputFormat::Markdown)
        );
        assert_eq!(OutputFormat::from_str("invalid"), None);
    }
}