RTK

// src/main.rs

fn main() {
    let code = match run_cli() {
        Ok(code) => code,
        Err(e) => {
            eprintln!("rtk: {:#}", e);
            1
        }
    };
    std::process::exit(code);
}

fn run_cli() -> Result<i32> {
    let cli = Cli::try_parse()?;

    // 命令路由：match 穷举所有子命令
    let code = match cli.command {
        Commands::Ls { args } => ls::run(&args, cli.verbose)?,
        Commands::Git { command, .. } => {
            git::run(command, &args, cli.verbose)?
        }
        // ... 40+ 命令
    };
    Ok(code)
}

// src/cmds/git/git.rs

fn run_log(args: &[String], verbose: u8, global_args: &[String]) -> Result<i32> {
    let timer = tracking::TimedExecution::start();

    let mut cmd = git_cmd(global_args);
    cmd.arg("log");

    // 智能默认值：仅在用户未指定时注入
    if !has_format_flag {
        cmd.args(["--pretty=format:%h %s (%ar) <%an>%n%b%n---END---"]);
    }
    if !has_limit_flag {
        cmd.arg("-10");
    }
    cmd.arg("--no-merges");

    // 执行真实 git 命令
    let output = cmd.output().context("Failed to run git log")?;
    let stdout = String::from_utf8_lossy(&output.stdout);

    // 过滤输出 + 记录 token 节省量
    let filtered = filter_log_output(&stdout, limit, user_set_limit, has_format_flag);
    println!("{}", filtered);

    timer.track("git log", "rtk git log", &stdout, &filtered);
    Ok(0)
}

// src/cmds/git/git.rs

fn filter_log_output(output: &str, limit: usize, user_set_limit: bool, user_format: bool) -> String {
    // 按 commit 块分割
    let commits: Vec<&str> = output.split("---END---").collect();
    let max_commits = if user_set_limit { commits.len() } else { limit };

    let mut result = Vec::new();
    for block in commits.iter().take(max_commits) {
        let block = block.trim();
        if block.is_empty() { continue; }

        let mut lines = block.lines();
        let header = truncate_line(lines.next().unwrap_or("").trim(), 80);

        // 过滤 body：去 trailer，限 3 行
        let body_lines: Vec<&str> = lines
            .map(|l| l.trim())
            .filter(|l| {
                !l.is_empty()
                    && !l.starts_with("Signed-off-by:")
                    && !l.starts_with("Co-authored-by:")
            })
            .take(3)
            .collect();

        result.push(format_entry(&header, &body_lines));
    }
    result.join("\n")
}

// src/core/tracking.rs

pub fn estimate_tokens(text: &str) -> usize {
    // ~4 chars per token（近似值，零开销）
    (text.len() as f64 / 4.0).ceil() as usize
}

impl TimedExecution {
    pub fn track(&self, original_cmd: &str, rtk_cmd: &str, input: &str, output: &str) {
        let elapsed_ms = self.start.elapsed().as_millis() as u64;
        let input_tokens = estimate_tokens(input);
        let output_tokens = estimate_tokens(output);

        if let Ok(tracker) = Tracker::new() {
            // 写入 SQLite，失败不阻断命令执行
            let _ = tracker.record(
                original_cmd, rtk_cmd,
                input_tokens, output_tokens, elapsed_ms,
            );
        }
    }
}