@hasna/terminal 2.3.0 → 2.3.2

package/temp/rtk/src/git.rs

@@ -1,2012 +0,0 @@
-use crate::tracking;
-use anyhow::{Context, Result};
-use std::ffi::OsString;
-use std::process::Command;
-
-#[derive(Debug, Clone)]
-pub enum GitCommand {
-    Diff,
-    Log,
-    Status,
-    Show,
-    Add,
-    Commit,
-    Push,
-    Pull,
-    Branch,
-    Fetch,
-    Stash { subcommand: Option<String> },
-    Worktree,
-}
-
-/// Create a git Command with global options (e.g. -C, -c, --git-dir, --work-tree)
-/// prepended before any subcommand arguments.
-fn git_cmd(global_args: &[String]) -> Command {
-    let mut cmd = Command::new("git");
-    for arg in global_args {
-        cmd.arg(arg);
-    }
-    cmd
-}
-
-pub fn run(
-    cmd: GitCommand,
-    args: &[String],
-    max_lines: Option<usize>,
-    verbose: u8,
-    global_args: &[String],
-) -> Result<()> {
-    match cmd {
-        GitCommand::Diff => run_diff(args, max_lines, verbose, global_args),
-        GitCommand::Log => run_log(args, max_lines, verbose, global_args),
-        GitCommand::Status => run_status(args, verbose, global_args),
-        GitCommand::Show => run_show(args, max_lines, verbose, global_args),
-        GitCommand::Add => run_add(args, verbose, global_args),
-        GitCommand::Commit => run_commit(args, verbose, global_args),
-        GitCommand::Push => run_push(args, verbose, global_args),
-        GitCommand::Pull => run_pull(args, verbose, global_args),
-        GitCommand::Branch => run_branch(args, verbose, global_args),
-        GitCommand::Fetch => run_fetch(args, verbose, global_args),
-        GitCommand::Stash { subcommand } => {
-            run_stash(subcommand.as_deref(), args, verbose, global_args)
-        }
-        GitCommand::Worktree => run_worktree(args, verbose, global_args),
-    }
-}
-
-fn run_diff(
-    args: &[String],
-    max_lines: Option<usize>,
-    verbose: u8,
-    global_args: &[String],
-) -> Result<()> {
-    let timer = tracking::TimedExecution::start();
-
-    // Check if user wants stat output
-    let wants_stat = args
-        .iter()
-        .any(|arg| arg == "--stat" || arg == "--numstat" || arg == "--shortstat");
-
-    // Check if user wants compact diff (default RTK behavior)
-    let wants_compact = !args.iter().any(|arg| arg == "--no-compact");
-
-    if wants_stat || !wants_compact {
-        // User wants stat or explicitly no compacting - pass through directly
-        let mut cmd = git_cmd(global_args);
-        cmd.arg("diff");
-        for arg in args {
-            cmd.arg(arg);
-        }
-
-        let output = cmd.output().context("Failed to run git diff")?;
-
-        if !output.status.success() {
-            let stderr = String::from_utf8_lossy(&output.stderr);
-            eprintln!("{}", stderr);
-            std::process::exit(output.status.code().unwrap_or(1));
-        }
-
-        let stdout = String::from_utf8_lossy(&output.stdout);
-        println!("{}", stdout.trim());
-
-        timer.track(
-            &format!("git diff {}", args.join(" ")),
-            &format!("rtk git diff {} (passthrough)", args.join(" ")),
-            &stdout,
-            &stdout,
-        );
-
-        return Ok(());
-    }
-
-    // Default RTK behavior: stat first, then compacted diff
-    let mut cmd = git_cmd(global_args);
-    cmd.arg("diff").arg("--stat");
-
-    for arg in args {
-        cmd.arg(arg);
-    }
-
-    let output = cmd.output().context("Failed to run git diff")?;
-    let stat_stdout = String::from_utf8_lossy(&output.stdout);
-
-    if verbose > 0 {
-        eprintln!("Git diff summary:");
-    }
-
-    // Print stat summary first
-    println!("{}", stat_stdout.trim());
-
-    // Now get actual diff but compact it
-    let mut diff_cmd = git_cmd(global_args);
-    diff_cmd.arg("diff");
-    for arg in args {
-        diff_cmd.arg(arg);
-    }
-
-    let diff_output = diff_cmd.output().context("Failed to run git diff")?;
-    let diff_stdout = String::from_utf8_lossy(&diff_output.stdout);
-
-    let mut final_output = stat_stdout.to_string();
-    if !diff_stdout.is_empty() {
-        println!("\n--- Changes ---");
-        let compacted = compact_diff(&diff_stdout, max_lines.unwrap_or(500));
-        println!("{}", compacted);
-        final_output.push_str("\n--- Changes ---\n");
-        final_output.push_str(&compacted);
-    }
-
-    timer.track(
-        &format!("git diff {}", args.join(" ")),
-        &format!("rtk git diff {}", args.join(" ")),
-        &format!("{}\n{}", stat_stdout, diff_stdout),
-        &final_output,
-    );
-
-    Ok(())
-}
-
-fn run_show(
-    args: &[String],
-    max_lines: Option<usize>,
-    verbose: u8,
-    global_args: &[String],
-) -> Result<()> {
-    let timer = tracking::TimedExecution::start();
-
-    // If user wants --stat or --format only, pass through
-    let wants_stat_only = args
-        .iter()
-        .any(|arg| arg == "--stat" || arg == "--numstat" || arg == "--shortstat");
-
-    let wants_format = args
-        .iter()
-        .any(|arg| arg.starts_with("--pretty") || arg.starts_with("--format"));
-
-    // `git show rev:path` prints a blob, not a commit diff. In this mode we should
-    // pass through directly to avoid duplicated output from compact-show steps.
-    let wants_blob_show = args.iter().any(|arg| is_blob_show_arg(arg));
-
-    if wants_stat_only || wants_format || wants_blob_show {
-        let mut cmd = git_cmd(global_args);
-        cmd.arg("show");
-        for arg in args {
-            cmd.arg(arg);
-        }
-        let output = cmd.output().context("Failed to run git show")?;
-        if !output.status.success() {
-            let stderr = String::from_utf8_lossy(&output.stderr);
-            eprintln!("{}", stderr);
-            std::process::exit(output.status.code().unwrap_or(1));
-        }
-        let stdout = String::from_utf8_lossy(&output.stdout);
-        if wants_blob_show {
-            print!("{}", stdout);
-        } else {
-            println!("{}", stdout.trim());
-        }
-
-        timer.track(
-            &format!("git show {}", args.join(" ")),
-            &format!("rtk git show {} (passthrough)", args.join(" ")),
-            &stdout,
-            &stdout,
-        );
-
-        return Ok(());
-    }
-
-    // Get raw output for tracking
-    let mut raw_cmd = git_cmd(global_args);
-    raw_cmd.arg("show");
-    for arg in args {
-        raw_cmd.arg(arg);
-    }
-    let raw_output = raw_cmd
-        .output()
-        .map(|o| String::from_utf8_lossy(&o.stdout).to_string())
-        .unwrap_or_default();
-
-    // Step 1: one-line commit summary
-    let mut summary_cmd = git_cmd(global_args);
-    summary_cmd.args(["show", "--no-patch", "--pretty=format:%h %s (%ar) <%an>"]);
-    for arg in args {
-        summary_cmd.arg(arg);
-    }
-    let summary_output = summary_cmd.output().context("Failed to run git show")?;
-    if !summary_output.status.success() {
-        let stderr = String::from_utf8_lossy(&summary_output.stderr);
-        eprintln!("{}", stderr);
-        std::process::exit(summary_output.status.code().unwrap_or(1));
-    }
-    let summary = String::from_utf8_lossy(&summary_output.stdout);
-    println!("{}", summary.trim());
-
-    // Step 2: --stat summary
-    let mut stat_cmd = git_cmd(global_args);
-    stat_cmd.args(["show", "--stat", "--pretty=format:"]);
-    for arg in args {
-        stat_cmd.arg(arg);
-    }
-    let stat_output = stat_cmd.output().context("Failed to run git show --stat")?;
-    let stat_stdout = String::from_utf8_lossy(&stat_output.stdout);
-    let stat_text = stat_stdout.trim();
-    if !stat_text.is_empty() {
-        println!("{}", stat_text);
-    }
-
-    // Step 3: compacted diff
-    let mut diff_cmd = git_cmd(global_args);
-    diff_cmd.args(["show", "--pretty=format:"]);
-    for arg in args {
-        diff_cmd.arg(arg);
-    }
-    let diff_output = diff_cmd.output().context("Failed to run git show (diff)")?;
-    let diff_stdout = String::from_utf8_lossy(&diff_output.stdout);
-    let diff_text = diff_stdout.trim();
-
-    let mut final_output = summary.to_string();
-    if !diff_text.is_empty() {
-        if verbose > 0 {
-            println!("\n--- Changes ---");
-        }
-        let compacted = compact_diff(diff_text, max_lines.unwrap_or(500));
-        println!("{}", compacted);
-        final_output.push_str(&format!("\n{}", compacted));
-    }
-
-    timer.track(
-        &format!("git show {}", args.join(" ")),
-        &format!("rtk git show {}", args.join(" ")),
-        &raw_output,
-        &final_output,
-    );
-
-    Ok(())
-}
-
-fn is_blob_show_arg(arg: &str) -> bool {
-    // Detect `rev:path` style arguments while ignoring flags like `--pretty=format:...`.
-    !arg.starts_with('-') && arg.contains(':')
-}
-
-pub(crate) fn compact_diff(diff: &str, max_lines: usize) -> String {
-    let mut result = Vec::new();
-    let mut current_file = String::new();
-    let mut added = 0;
-    let mut removed = 0;
-    let mut in_hunk = false;
-    let mut hunk_lines = 0;
-    let max_hunk_lines = 30;
-
-    for line in diff.lines() {
-        if line.starts_with("diff --git") {
-            // New file
-            if !current_file.is_empty() && (added > 0 || removed > 0) {
-                result.push(format!("  +{} -{}", added, removed));
-            }
-            current_file = line.split(" b/").nth(1).unwrap_or("unknown").to_string();
-            result.push(format!("\n📄 {}", current_file));
-            added = 0;
-            removed = 0;
-            in_hunk = false;
-        } else if line.starts_with("@@") {
-            // New hunk
-            in_hunk = true;
-            hunk_lines = 0;
-            let hunk_info = line.split("@@").nth(1).unwrap_or("").trim();
-            result.push(format!("  @@ {} @@", hunk_info));
-        } else if in_hunk {
-            if line.starts_with('+') && !line.starts_with("+++") {
-                added += 1;
-                if hunk_lines < max_hunk_lines {
-                    result.push(format!("  {}", line));
-                    hunk_lines += 1;
-                }
-            } else if line.starts_with('-') && !line.starts_with("---") {
-                removed += 1;
-                if hunk_lines < max_hunk_lines {
-                    result.push(format!("  {}", line));
-                    hunk_lines += 1;
-                }
-            } else if hunk_lines < max_hunk_lines && !line.starts_with("\\") {
-                // Context line
-                if hunk_lines > 0 {
-                    result.push(format!("  {}", line));
-                    hunk_lines += 1;
-                }
-            }
-
-            if hunk_lines == max_hunk_lines {
-                result.push("  ... (truncated)".to_string());
-                hunk_lines += 1;
-            }
-        }
-
-        if result.len() >= max_lines {
-            result.push("\n... (more changes truncated)".to_string());
-            break;
-        }
-    }
-
-    if !current_file.is_empty() && (added > 0 || removed > 0) {
-        result.push(format!("  +{} -{}", added, removed));
-    }
-
-    result.join("\n")
-}
-
-fn run_log(
-    args: &[String],
-    _max_lines: Option<usize>,
-    verbose: u8,
-    global_args: &[String],
-) -> Result<()> {
-    let timer = tracking::TimedExecution::start();
-
-    let mut cmd = git_cmd(global_args);
-    cmd.arg("log");
-
-    // Check if user provided format flags
-    let has_format_flag = args.iter().any(|arg| {
-        arg.starts_with("--oneline") || arg.starts_with("--pretty") || arg.starts_with("--format")
-    });
-
-    // Check if user provided limit flag (-N, -n N, --max-count=N, --max-count N)
-    let has_limit_flag = args.iter().any(|arg| {
-        (arg.starts_with('-') && arg.chars().nth(1).map_or(false, |c| c.is_ascii_digit()))
-            || arg == "-n"
-            || arg.starts_with("--max-count")
-    });
-
-    // Apply RTK defaults only if user didn't specify them
-    if !has_format_flag {
-        cmd.args(["--pretty=format:%h %s (%ar) <%an>"]);
-    }
-
-    // Determine limit: respect user's explicit -N flag, use sensible defaults otherwise
-    let (limit, user_set_limit) = if has_limit_flag {
-        // User explicitly passed -N / -n N / --max-count=N → respect their choice
-        let n = parse_user_limit(args).unwrap_or(10);
-        (n, true)
-    } else if has_format_flag {
-        // --oneline / --pretty without -N: user wants compact output, allow more
-        cmd.arg("-50");
-        (50, false)
-    } else {
-        // No flags at all: default to 10
-        cmd.arg("-10");
-        (10, false)
-    };
-
-    // Only add --no-merges if user didn't explicitly request merge commits
-    let wants_merges = args
-        .iter()
-        .any(|arg| arg == "--merges" || arg == "--min-parents=2");
-    if !wants_merges {
-        cmd.arg("--no-merges");
-    }
-
-    // Pass all user arguments
-    for arg in args {
-        cmd.arg(arg);
-    }
-
-    let output = cmd.output().context("Failed to run git log")?;
-
-    if !output.status.success() {
-        let stderr = String::from_utf8_lossy(&output.stderr);
-        eprintln!("{}", stderr);
-        // Propagate git's exit code
-        std::process::exit(output.status.code().unwrap_or(1));
-    }
-
-    let stdout = String::from_utf8_lossy(&output.stdout);
-
-    if verbose > 0 {
-        eprintln!("Git log output:");
-    }
-
-    // Post-process: truncate long messages, cap lines only if RTK set the default
-    let filtered = filter_log_output(&stdout, limit, user_set_limit);
-    println!("{}", filtered);
-
-    timer.track(
-        &format!("git log {}", args.join(" ")),
-        &format!("rtk git log {}", args.join(" ")),
-        &stdout,
-        &filtered,
-    );
-
-    Ok(())
-}
-
-/// Filter git log output: truncate long messages, cap lines
-/// Parse the user-specified limit from git log args.
-/// Handles: -20, -n 20, --max-count=20, --max-count 20
-fn parse_user_limit(args: &[String]) -> Option<usize> {
-    let mut iter = args.iter();
-    while let Some(arg) = iter.next() {
-        // -20 (combined digit form)
-        if arg.starts_with('-')
-            && arg.len() > 1
-            && arg.chars().nth(1).map_or(false, |c| c.is_ascii_digit())
-        {
-            if let Ok(n) = arg[1..].parse::<usize>() {
-                return Some(n);
-            }
-        }
-        // -n 20 (two-token form)
-        if arg == "-n" {
-            if let Some(next) = iter.next() {
-                if let Ok(n) = next.parse::<usize>() {
-                    return Some(n);
-                }
-            }
-        }
-        // --max-count=20
-        if let Some(rest) = arg.strip_prefix("--max-count=") {
-            if let Ok(n) = rest.parse::<usize>() {
-                return Some(n);
-            }
-        }
-        // --max-count 20 (two-token form)
-        if arg == "--max-count" {
-            if let Some(next) = iter.next() {
-                if let Ok(n) = next.parse::<usize>() {
-                    return Some(n);
-                }
-            }
-        }
-    }
-    None
-}
-
-/// When `user_set_limit` is true, the user explicitly passed `-N` to git log,
-/// so we skip line capping (git already returns exactly N commits) and use a
-/// wider truncation threshold (120 chars) to preserve commit context that LLMs
-/// need for rebase/squash operations.
-fn filter_log_output(output: &str, limit: usize, user_set_limit: bool) -> String {
-    let lines: Vec<&str> = output.lines().collect();
-
-    let truncate_width = if user_set_limit { 120 } else { 80 };
-
-    let iter = lines.iter();
-    let capped: Vec<String> = if user_set_limit {
-        // User chose the limit → git already returned the right number of commits
-        iter.map(|line| truncate_line(line, truncate_width))
-            .collect()
-    } else {
-        // RTK default → cap output lines
-        iter.take(limit)
-            .map(|line| truncate_line(line, truncate_width))
-            .collect()
-    };
-
-    capped.join("\n").trim().to_string()
-}
-
-/// Truncate a single line to `width` characters, appending "..." if needed
-fn truncate_line(line: &str, width: usize) -> String {
-    if line.chars().count() > width {
-        let truncated: String = line.chars().take(width - 3).collect();
-        format!("{}...", truncated)
-    } else {
-        line.to_string()
-    }
-}
-
-/// Format porcelain output into compact RTK status display
-fn format_status_output(porcelain: &str) -> String {
-    let lines: Vec<&str> = porcelain.lines().collect();
-
-    if lines.is_empty() {
-        return "Clean working tree".to_string();
-    }
-
-    let mut output = String::new();
-
-    // Parse branch info
-    if let Some(branch_line) = lines.first() {
-        if branch_line.starts_with("##") {
-            let branch = branch_line.trim_start_matches("## ");
-            output.push_str(&format!("📌 {}\n", branch));
-        }
-    }
-
-    // Count changes by type
-    let mut staged = 0;
-    let mut modified = 0;
-    let mut untracked = 0;
-    let mut conflicts = 0;
-
-    let mut staged_files = Vec::new();
-    let mut modified_files = Vec::new();
-    let mut untracked_files = Vec::new();
-
-    for line in lines.iter().skip(1) {
-        if line.len() < 3 {
-            continue;
-        }
-        let status = line.get(0..2).unwrap_or("  ");
-        let file = line.get(3..).unwrap_or("");
-
-        match status.chars().next().unwrap_or(' ') {
-            'M' | 'A' | 'D' | 'R' | 'C' => {
-                staged += 1;
-                staged_files.push(file);
-            }
-            'U' => conflicts += 1,
-            _ => {}
-        }
-
-        match status.chars().nth(1).unwrap_or(' ') {
-            'M' | 'D' => {
-                modified += 1;
-                modified_files.push(file);
-            }
-            _ => {}
-        }
-
-        if status == "??" {
-            untracked += 1;
-            untracked_files.push(file);
-        }
-    }
-
-    // Build summary
-    if staged > 0 {
-        output.push_str(&format!("✅ Staged: {} files\n", staged));
-        for f in staged_files.iter().take(5) {
-            output.push_str(&format!("   {}\n", f));
-        }
-        if staged_files.len() > 5 {
-            output.push_str(&format!("   ... +{} more\n", staged_files.len() - 5));
-        }
-    }
-
-    if modified > 0 {
-        output.push_str(&format!("📝 Modified: {} files\n", modified));
-        for f in modified_files.iter().take(5) {
-            output.push_str(&format!("   {}\n", f));
-        }
-        if modified_files.len() > 5 {
-            output.push_str(&format!("   ... +{} more\n", modified_files.len() - 5));
-        }
-    }
-
-    if untracked > 0 {
-        output.push_str(&format!("❓ Untracked: {} files\n", untracked));
-        for f in untracked_files.iter().take(3) {
-            output.push_str(&format!("   {}\n", f));
-        }
-        if untracked_files.len() > 3 {
-            output.push_str(&format!("   ... +{} more\n", untracked_files.len() - 3));
-        }
-    }
-
-    if conflicts > 0 {
-        output.push_str(&format!("⚠️  Conflicts: {} files\n", conflicts));
-    }
-
-    output.trim_end().to_string()
-}
-
-/// Minimal filtering for git status with user-provided args
-fn filter_status_with_args(output: &str) -> String {
-    let mut result = Vec::new();
-
-    for line in output.lines() {
-        let trimmed = line.trim();
-
-        // Skip empty lines
-        if trimmed.is_empty() {
-            continue;
-        }
-
-        // Skip git hints - can appear at start or within line
-        if trimmed.starts_with("(use \"git")
-            || trimmed.starts_with("(create/copy files")
-            || trimmed.contains("(use \"git add")
-            || trimmed.contains("(use \"git restore")
-        {
-            continue;
-        }
-
-        // Special case: clean working tree
-        if trimmed.contains("nothing to commit") && trimmed.contains("working tree clean") {
-            result.push(trimmed.to_string());
-            break;
-        }
-
-        result.push(line.to_string());
-    }
-
-    if result.is_empty() {
-        "ok ✓".to_string()
-    } else {
-        result.join("\n")
-    }
-}
-
-fn run_status(args: &[String], verbose: u8, global_args: &[String]) -> Result<()> {
-    let timer = tracking::TimedExecution::start();
-
-    // If user provided flags, apply minimal filtering
-    if !args.is_empty() {
-        let output = git_cmd(global_args)
-            .arg("status")
-            .args(args)
-            .output()
-            .context("Failed to run git status")?;
-
-        let stdout = String::from_utf8_lossy(&output.stdout);
-        let stderr = String::from_utf8_lossy(&output.stderr);
-
-        if verbose > 0 || !stderr.is_empty() {
-            eprint!("{}", stderr);
-        }
-
-        // Apply minimal filtering: strip ANSI, remove hints, empty lines
-        let filtered = filter_status_with_args(&stdout);
-        print!("{}", filtered);
-
-        timer.track(
-            &format!("git status {}", args.join(" ")),
-            &format!("rtk git status {}", args.join(" ")),
-            &stdout,
-            &filtered,
-        );
-
-        return Ok(());
-    }
-
-    // Default RTK compact mode (no args provided)
-    // Get raw git status for tracking
-    let raw_output = git_cmd(global_args)
-        .args(["status"])
-        .output()
-        .map(|o| String::from_utf8_lossy(&o.stdout).to_string())
-        .unwrap_or_default();
-
-    let output = git_cmd(global_args)
-        .args(["status", "--porcelain", "-b"])
-        .output()
-        .context("Failed to run git status")?;
-
-    let stdout = String::from_utf8_lossy(&output.stdout);
-    let stderr = String::from_utf8_lossy(&output.stderr);
-
-    if !stderr.is_empty() && stderr.contains("not a git repository") {
-        let message = "Not a git repository".to_string();
-        eprintln!("{}", message);
-        timer.track("git status", "rtk git status", &raw_output, &message);
-        std::process::exit(output.status.code().unwrap_or(128));
-    }
-
-    let formatted = format_status_output(&stdout);
-
-    println!("{}", formatted);
-
-    // Track for statistics
-    timer.track("git status", "rtk git status", &raw_output, &formatted);
-
-    Ok(())
-}
-
-fn run_add(args: &[String], verbose: u8, global_args: &[String]) -> Result<()> {
-    let timer = tracking::TimedExecution::start();
-
-    let mut cmd = git_cmd(global_args);
-    cmd.arg("add");
-
-    // Pass all arguments directly to git (flags like -A, -p, --all, etc.)
-    if args.is_empty() {
-        cmd.arg(".");
-    } else {
-        for arg in args {
-            cmd.arg(arg);
-        }
-    }
-
-    let output = cmd.output().context("Failed to run git add")?;
-
-    if verbose > 0 {
-        eprintln!("git add executed");
-    }
-
-    let raw_output = format!(
-        "{}\n{}",
-        String::from_utf8_lossy(&output.stdout),
-        String::from_utf8_lossy(&output.stderr)
-    );
-
-    if output.status.success() {
-        // Count what was added
-        let status_output = git_cmd(global_args)
-            .args(["diff", "--cached", "--stat", "--shortstat"])
-            .output()
-            .context("Failed to check staged files")?;
-
-        let stat = String::from_utf8_lossy(&status_output.stdout);
-        let compact = if stat.trim().is_empty() {
-            "ok (nothing to add)".to_string()
-        } else {
-            // Parse "1 file changed, 5 insertions(+)" format
-            let short = stat.lines().last().unwrap_or("").trim();
-            if short.is_empty() {
-                "ok ✓".to_string()
-            } else {
-                format!("ok ✓ {}", short)
-            }
-        };
-
-        println!("{}", compact);
-
-        timer.track(
-            &format!("git add {}", args.join(" ")),
-            &format!("rtk git add {}", args.join(" ")),
-            &raw_output,
-            &compact,
-        );
-    } else {
-        let stderr = String::from_utf8_lossy(&output.stderr);
-        let stdout = String::from_utf8_lossy(&output.stdout);
-        eprintln!("FAILED: git add");
-        if !stderr.trim().is_empty() {
-            eprintln!("{}", stderr);
-        }
-        if !stdout.trim().is_empty() {
-            eprintln!("{}", stdout);
-        }
-        // Propagate git's exit code
-        std::process::exit(output.status.code().unwrap_or(1));
-    }
-
-    Ok(())
-}
-
-fn build_commit_command(args: &[String], global_args: &[String]) -> Command {
-    let mut cmd = git_cmd(global_args);
-    cmd.arg("commit");
-    for arg in args {
-        cmd.arg(arg);
-    }
-    cmd
-}
-
-fn run_commit(args: &[String], verbose: u8, global_args: &[String]) -> Result<()> {
-    let timer = tracking::TimedExecution::start();
-
-    let original_cmd = format!("git commit {}", args.join(" "));
-
-    if verbose > 0 {
-        eprintln!("{}", original_cmd);
-    }
-
-    let output = build_commit_command(args, global_args)
-        .output()
-        .context("Failed to run git commit")?;
-
-    let stdout = String::from_utf8_lossy(&output.stdout);
-    let stderr = String::from_utf8_lossy(&output.stderr);
-    let raw_output = format!("{}\n{}", stdout, stderr);
-
-    if output.status.success() {
-        // Extract commit hash from output like "[main abc1234] message"
-        let compact = if let Some(line) = stdout.lines().next() {
-            if let Some(hash_start) = line.find(' ') {
-                let hash = line[1..hash_start].split(' ').last().unwrap_or("");
-                if !hash.is_empty() && hash.len() >= 7 {
-                    format!("ok ✓ {}", &hash[..7.min(hash.len())])
-                } else {
-                    "ok ✓".to_string()
-                }
-            } else {
-                "ok ✓".to_string()
-            }
-        } else {
-            "ok ✓".to_string()
-        };
-
-        println!("{}", compact);
-
-        timer.track(&original_cmd, "rtk git commit", &raw_output, &compact);
-    } else {
-        if stderr.contains("nothing to commit") || stdout.contains("nothing to commit") {
-            println!("ok (nothing to commit)");
-            timer.track(
-                &original_cmd,
-                "rtk git commit",
-                &raw_output,
-                "ok (nothing to commit)",
-            );
-        } else {
-            eprintln!("FAILED: git commit");
-            if !stderr.trim().is_empty() {
-                eprintln!("{}", stderr);
-            }
-            if !stdout.trim().is_empty() {
-                eprintln!("{}", stdout);
-            }
-        }
-    }
-
-    Ok(())
-}
-
-fn run_push(args: &[String], verbose: u8, global_args: &[String]) -> Result<()> {
-    let timer = tracking::TimedExecution::start();
-
-    if verbose > 0 {
-        eprintln!("git push");
-    }
-
-    let mut cmd = git_cmd(global_args);
-    cmd.arg("push");
-    for arg in args {
-        cmd.arg(arg);
-    }
-
-    let output = cmd.output().context("Failed to run git push")?;
-
-    let stderr = String::from_utf8_lossy(&output.stderr);
-    let stdout = String::from_utf8_lossy(&output.stdout);
-    let raw = format!("{}{}", stdout, stderr);
-
-    if output.status.success() {
-        let compact = if stderr.contains("Everything up-to-date") {
-            "ok (up-to-date)".to_string()
-        } else {
-            let mut result = String::new();
-            for line in stderr.lines() {
-                if line.contains("->") {
-                    let parts: Vec<&str> = line.split_whitespace().collect();
-                    if parts.len() >= 3 {
-                        result = format!("ok ✓ {}", parts[parts.len() - 1]);
-                        break;
-                    }
-                }
-            }
-            if !result.is_empty() {
-                result
-            } else {
-                "ok ✓".to_string()
-            }
-        };
-
-        println!("{}", compact);
-
-        timer.track(
-            &format!("git push {}", args.join(" ")),
-            &format!("rtk git push {}", args.join(" ")),
-            &raw,
-            &compact,
-        );
-    } else {
-        eprintln!("FAILED: git push");
-        if !stderr.trim().is_empty() {
-            eprintln!("{}", stderr);
-        }
-        if !stdout.trim().is_empty() {
-            eprintln!("{}", stdout);
-        }
-        std::process::exit(output.status.code().unwrap_or(1));
-    }
-
-    Ok(())
-}
-
-fn run_pull(args: &[String], verbose: u8, global_args: &[String]) -> Result<()> {
-    let timer = tracking::TimedExecution::start();
-
-    if verbose > 0 {
-        eprintln!("git pull");
-    }
-
-    let mut cmd = git_cmd(global_args);
-    cmd.arg("pull");
-    for arg in args {
-        cmd.arg(arg);
-    }
-
-    let output = cmd.output().context("Failed to run git pull")?;
-
-    let stdout = String::from_utf8_lossy(&output.stdout);
-    let stderr = String::from_utf8_lossy(&output.stderr);
-    let raw_output = format!("{}\n{}", stdout, stderr);
-
-    if output.status.success() {
-        let compact =
-            if stdout.contains("Already up to date") || stdout.contains("Already up-to-date") {
-                "ok (up-to-date)".to_string()
-            } else {
-                // Count files changed
-                let mut files = 0;
-                let mut insertions = 0;
-                let mut deletions = 0;
-
-                for line in stdout.lines() {
-                    if line.contains("file") && line.contains("changed") {
-                        // Parse "3 files changed, 10 insertions(+), 2 deletions(-)"
-                        for part in line.split(',') {
-                            let part = part.trim();
-                            if part.contains("file") {
-                                files = part
-                                    .split_whitespace()
-                                    .next()
-                                    .and_then(|n| n.parse().ok())
-                                    .unwrap_or(0);
-                            } else if part.contains("insertion") {
-                                insertions = part
-                                    .split_whitespace()
-                                    .next()
-                                    .and_then(|n| n.parse().ok())
-                                    .unwrap_or(0);
-                            } else if part.contains("deletion") {
-                                deletions = part
-                                    .split_whitespace()
-                                    .next()
-                                    .and_then(|n| n.parse().ok())
-                                    .unwrap_or(0);
-                            }
-                        }
-                    }
-                }
-
-                if files > 0 {
-                    format!("ok ✓ {} files +{} -{}", files, insertions, deletions)
-                } else {
-                    "ok ✓".to_string()
-                }
-            };
-
-        println!("{}", compact);
-
-        timer.track(
-            &format!("git pull {}", args.join(" ")),
-            &format!("rtk git pull {}", args.join(" ")),
-            &raw_output,
-            &compact,
-        );
-    } else {
-        eprintln!("FAILED: git pull");
-        if !stderr.trim().is_empty() {
-            eprintln!("{}", stderr);
-        }
-        if !stdout.trim().is_empty() {
-            eprintln!("{}", stdout);
-        }
-        std::process::exit(output.status.code().unwrap_or(1));
-    }
-
-    Ok(())
-}
-
-fn run_branch(args: &[String], verbose: u8, global_args: &[String]) -> Result<()> {
-    let timer = tracking::TimedExecution::start();
-
-    if verbose > 0 {
-        eprintln!("git branch");
-    }
-
-    // Detect write operations: delete, rename, copy
-    let has_action_flag = args
-        .iter()
-        .any(|a| a == "-d" || a == "-D" || a == "-m" || a == "-M" || a == "-c" || a == "-C");
-
-    // Detect list-mode flags
-    let has_list_flag = args.iter().any(|a| {
-        a == "-a"
-            || a == "--all"
-            || a == "-r"
-            || a == "--remotes"
-            || a == "--list"
-            || a == "--merged"
-            || a == "--no-merged"
-            || a == "--contains"
-            || a == "--no-contains"
-    });
-
-    // Detect positional arguments (not flags) — indicates branch creation
-    let has_positional_arg = args.iter().any(|a| !a.starts_with('-'));
-
-    // Write operation: action flags, or positional args without list flags (= branch creation)
-    if has_action_flag || (has_positional_arg && !has_list_flag) {
-        let mut cmd = git_cmd(global_args);
-        cmd.arg("branch");
-        for arg in args {
-            cmd.arg(arg);
-        }
-        let output = cmd.output().context("Failed to run git branch")?;
-        let stdout = String::from_utf8_lossy(&output.stdout);
-        let stderr = String::from_utf8_lossy(&output.stderr);
-        let combined = format!("{}{}", stdout, stderr);
-
-        let msg = if output.status.success() {
-            "ok ✓"
-        } else {
-            &combined
-        };
-
-        timer.track(
-            &format!("git branch {}", args.join(" ")),
-            &format!("rtk git branch {}", args.join(" ")),
-            &combined,
-            msg,
-        );
-
-        if output.status.success() {
-            println!("ok ✓");
-        } else {
-            eprintln!("FAILED: git branch {}", args.join(" "));
-            if !stderr.trim().is_empty() {
-                eprintln!("{}", stderr);
-            }
-            if !stdout.trim().is_empty() {
-                eprintln!("{}", stdout);
-            }
-            std::process::exit(output.status.code().unwrap_or(1));
-        }
-        return Ok(());
-    }
-
-    // List mode: show compact branch list
-    let mut cmd = git_cmd(global_args);
-    cmd.arg("branch");
-    if !has_list_flag {
-        cmd.arg("-a");
-    }
-    cmd.arg("--no-color");
-    for arg in args {
-        cmd.arg(arg);
-    }
-
-    let output = cmd.output().context("Failed to run git branch")?;
-    let stdout = String::from_utf8_lossy(&output.stdout);
-    let raw = stdout.to_string();
-
-    let filtered = filter_branch_output(&stdout);
-    println!("{}", filtered);
-
-    timer.track(
-        &format!("git branch {}", args.join(" ")),
-        &format!("rtk git branch {}", args.join(" ")),
-        &raw,
-        &filtered,
-    );
-
-    Ok(())
-}
-
-fn filter_branch_output(output: &str) -> String {
-    let mut current = String::new();
-    let mut local: Vec<String> = Vec::new();
-    let mut remote: Vec<String> = Vec::new();
-
-    for line in output.lines() {
-        let line = line.trim();
-        if line.is_empty() {
-            continue;
-        }
-
-        if let Some(branch) = line.strip_prefix("* ") {
-            current = branch.to_string();
-        } else if line.starts_with("remotes/origin/") {
-            let branch = line.strip_prefix("remotes/origin/").unwrap_or(line);
-            // Skip HEAD pointer
-            if branch.starts_with("HEAD ") {
-                continue;
-            }
-            remote.push(branch.to_string());
-        } else {
-            local.push(line.to_string());
-        }
-    }
-
-    let mut result = Vec::new();
-    result.push(format!("* {}", current));
-
-    if !local.is_empty() {
-        for b in &local {
-            result.push(format!("  {}", b));
-        }
-    }
-
-    if !remote.is_empty() {
-        // Filter out remotes that already exist locally
-        let remote_only: Vec<&String> = remote
-            .iter()
-            .filter(|r| *r != &current && !local.contains(r))
-            .collect();
-        if !remote_only.is_empty() {
-            result.push(format!("  remote-only ({}):", remote_only.len()));
-            for b in remote_only.iter().take(10) {
-                result.push(format!("    {}", b));
-            }
-            if remote_only.len() > 10 {
-                result.push(format!("    ... +{} more", remote_only.len() - 10));
-            }
-        }
-    }
-
-    result.join("\n")
-}
-
-fn run_fetch(args: &[String], verbose: u8, global_args: &[String]) -> Result<()> {
-    let timer = tracking::TimedExecution::start();
-
-    if verbose > 0 {
-        eprintln!("git fetch");
-    }
-
-    let mut cmd = git_cmd(global_args);
-    cmd.arg("fetch");
-    for arg in args {
-        cmd.arg(arg);
-    }
-
-    let output = cmd.output().context("Failed to run git fetch")?;
-    let stdout = String::from_utf8_lossy(&output.stdout);
-    let stderr = String::from_utf8_lossy(&output.stderr);
-    let raw = format!("{}{}", stdout, stderr);
-
-    if !output.status.success() {
-        eprintln!("FAILED: git fetch");
-        if !stderr.trim().is_empty() {
-            eprintln!("{}", stderr);
-        }
-        std::process::exit(output.status.code().unwrap_or(1));
-    }
-
-    // Count new refs from stderr (git fetch outputs to stderr)
-    let new_refs: usize = stderr
-        .lines()
-        .filter(|l| l.contains("->") || l.contains("[new"))
-        .count();
-
-    let msg = if new_refs > 0 {
-        format!("ok fetched ({} new refs)", new_refs)
-    } else {
-        "ok fetched".to_string()
-    };
-
-    println!("{}", msg);
-    timer.track("git fetch", "rtk git fetch", &raw, &msg);
-
-    Ok(())
-}
-
-fn run_stash(
-    subcommand: Option<&str>,
-    args: &[String],
-    verbose: u8,
-    global_args: &[String],
-) -> Result<()> {
-    let timer = tracking::TimedExecution::start();
-
-    if verbose > 0 {
-        eprintln!("git stash {:?}", subcommand);
-    }
-
-    match subcommand {
-        Some("list") => {
-            let output = git_cmd(global_args)
-                .args(["stash", "list"])
-                .output()
-                .context("Failed to run git stash list")?;
-            let stdout = String::from_utf8_lossy(&output.stdout);
-            let raw = stdout.to_string();
-
-            if stdout.trim().is_empty() {
-                let msg = "No stashes";
-                println!("{}", msg);
-                timer.track("git stash list", "rtk git stash list", &raw, msg);
-                return Ok(());
-            }
-
-            let filtered = filter_stash_list(&stdout);
-            println!("{}", filtered);
-            timer.track("git stash list", "rtk git stash list", &raw, &filtered);
-        }
-        Some("show") => {
-            let mut cmd = git_cmd(global_args);
-            cmd.args(["stash", "show", "-p"]);
-            for arg in args {
-                cmd.arg(arg);
-            }
-            let output = cmd.output().context("Failed to run git stash show")?;
-            let stdout = String::from_utf8_lossy(&output.stdout);
-            let raw = stdout.to_string();
-
-            let filtered = if stdout.trim().is_empty() {
-                let msg = "Empty stash";
-                println!("{}", msg);
-                msg.to_string()
-            } else {
-                let compacted = compact_diff(&stdout, 100);
-                println!("{}", compacted);
-                compacted
-            };
-
-            timer.track("git stash show", "rtk git stash show", &raw, &filtered);
-        }
-        Some("pop") | Some("apply") | Some("drop") | Some("push") => {
-            let sub = subcommand.unwrap();
-            let mut cmd = git_cmd(global_args);
-            cmd.args(["stash", sub]);
-            for arg in args {
-                cmd.arg(arg);
-            }
-            let output = cmd.output().context("Failed to run git stash")?;
-            let stdout = String::from_utf8_lossy(&output.stdout);
-            let stderr = String::from_utf8_lossy(&output.stderr);
-            let combined = format!("{}{}", stdout, stderr);
-
-            let msg = if output.status.success() {
-                let msg = format!("ok stash {}", sub);
-                println!("{}", msg);
-                msg
-            } else {
-                eprintln!("FAILED: git stash {}", sub);
-                if !stderr.trim().is_empty() {
-                    eprintln!("{}", stderr);
-                }
-                combined.clone()
-            };
-
-            timer.track(
-                &format!("git stash {}", sub),
-                &format!("rtk git stash {}", sub),
-                &combined,
-                &msg,
-            );
-
-            if !output.status.success() {
-                std::process::exit(output.status.code().unwrap_or(1));
-            }
-        }
-        _ => {
-            // Default: git stash (push)
-            let mut cmd = git_cmd(global_args);
-            cmd.arg("stash");
-            for arg in args {
-                cmd.arg(arg);
-            }
-            let output = cmd.output().context("Failed to run git stash")?;
-            let stdout = String::from_utf8_lossy(&output.stdout);
-            let stderr = String::from_utf8_lossy(&output.stderr);
-            let combined = format!("{}{}", stdout, stderr);
-
-            let msg = if output.status.success() {
-                if stdout.contains("No local changes") {
-                    let msg = "ok (nothing to stash)";
-                    println!("{}", msg);
-                    msg.to_string()
-                } else {
-                    let msg = "ok stashed";
-                    println!("{}", msg);
-                    msg.to_string()
-                }
-            } else {
-                eprintln!("FAILED: git stash");
-                if !stderr.trim().is_empty() {
-                    eprintln!("{}", stderr);
-                }
-                combined.clone()
-            };
-
-            timer.track("git stash", "rtk git stash", &combined, &msg);
-
-            if !output.status.success() {
-                std::process::exit(output.status.code().unwrap_or(1));
-            }
-        }
-    }
-
-    Ok(())
-}
-
-fn filter_stash_list(output: &str) -> String {
-    // Format: "stash@{0}: WIP on main: abc1234 commit message"
-    let mut result = Vec::new();
-    for line in output.lines() {
-        if let Some(colon_pos) = line.find(": ") {
-            let index = &line[..colon_pos];
-            let rest = &line[colon_pos + 2..];
-            // Compact: strip "WIP on branch:" prefix if present
-            let message = if let Some(second_colon) = rest.find(": ") {
-                rest[second_colon + 2..].trim()
-            } else {
-                rest.trim()
-            };
-            result.push(format!("{}: {}", index, message));
-        } else {
-            result.push(line.to_string());
-        }
-    }
-    result.join("\n")
-}
-
-fn run_worktree(args: &[String], verbose: u8, global_args: &[String]) -> Result<()> {
-    let timer = tracking::TimedExecution::start();
-
-    if verbose > 0 {
-        eprintln!("git worktree list");
-    }
-
-    // If args contain "add", "remove", "prune" etc., pass through
-    let has_action = args.iter().any(|a| {
-        a == "add" || a == "remove" || a == "prune" || a == "lock" || a == "unlock" || a == "move"
-    });
-
-    if has_action {
-        let mut cmd = git_cmd(global_args);
-        cmd.arg("worktree");
-        for arg in args {
-            cmd.arg(arg);
-        }
-        let output = cmd.output().context("Failed to run git worktree")?;
-        let stdout = String::from_utf8_lossy(&output.stdout);
-        let stderr = String::from_utf8_lossy(&output.stderr);
-        let combined = format!("{}{}", stdout, stderr);
-
-        let msg = if output.status.success() {
-            "ok ✓"
-        } else {
-            &combined
-        };
-
-        timer.track(
-            &format!("git worktree {}", args.join(" ")),
-            &format!("rtk git worktree {}", args.join(" ")),
-            &combined,
-            msg,
-        );
-
-        if output.status.success() {
-            println!("ok ✓");
-        } else {
-            eprintln!("FAILED: git worktree {}", args.join(" "));
-            if !stderr.trim().is_empty() {
-                eprintln!("{}", stderr);
-            }
-            std::process::exit(output.status.code().unwrap_or(1));
-        }
-        return Ok(());
-    }
-
-    // Default: list mode
-    let output = git_cmd(global_args)
-        .args(["worktree", "list"])
-        .output()
-        .context("Failed to run git worktree list")?;
-
-    let stdout = String::from_utf8_lossy(&output.stdout);
-    let raw = stdout.to_string();
-
-    let filtered = filter_worktree_list(&stdout);
-    println!("{}", filtered);
-    timer.track("git worktree list", "rtk git worktree", &raw, &filtered);
-
-    Ok(())
-}
-
-fn filter_worktree_list(output: &str) -> String {
-    let home = dirs::home_dir()
-        .map(|h| h.to_string_lossy().to_string())
-        .unwrap_or_default();
-
-    let mut result = Vec::new();
-    for line in output.lines() {
-        if line.trim().is_empty() {
-            continue;
-        }
-        // Format: "/path/to/worktree  abc1234 [branch]"
-        let parts: Vec<&str> = line.split_whitespace().collect();
-        if parts.len() >= 3 {
-            let mut path = parts[0].to_string();
-            if !home.is_empty() && path.starts_with(&home) {
-                path = format!("~{}", &path[home.len()..]);
-            }
-            let hash = parts[1];
-            let branch = parts[2..].join(" ");
-            result.push(format!("{} {} {}", path, hash, branch));
-        } else {
-            result.push(line.to_string());
-        }
-    }
-    result.join("\n")
-}
-
-/// Runs an unsupported git subcommand by passing it through directly
-pub fn run_passthrough(args: &[OsString], global_args: &[String], verbose: u8) -> Result<()> {
-    let timer = tracking::TimedExecution::start();
-
-    if verbose > 0 {
-        eprintln!("git passthrough: {:?}", args);
-    }
-    let status = git_cmd(global_args)
-        .args(args)
-        .status()
-        .context("Failed to run git")?;
-
-    let args_str = tracking::args_display(args);
-    timer.track_passthrough(
-        &format!("git {}", args_str),
-        &format!("rtk git {} (passthrough)", args_str),
-    );
-
-    if !status.success() {
-        std::process::exit(status.code().unwrap_or(1));
-    }
-    Ok(())
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-
-    #[test]
-    fn test_git_cmd_no_global_args() {
-        let cmd = git_cmd(&[]);
-        let program = cmd.get_program();
-        assert_eq!(program, "git");
-        let args: Vec<_> = cmd.get_args().collect();
-        assert!(args.is_empty());
-    }
-
-    #[test]
-    fn test_git_cmd_with_directory() {
-        let global_args = vec!["-C".to_string(), "/tmp".to_string()];
-        let cmd = git_cmd(&global_args);
-        let args: Vec<_> = cmd.get_args().collect();
-        assert_eq!(args, vec!["-C", "/tmp"]);
-    }
-
-    #[test]
-    fn test_git_cmd_with_multiple_global_args() {
-        let global_args = vec![
-            "-C".to_string(),
-            "/tmp".to_string(),
-            "-c".to_string(),
-            "user.name=test".to_string(),
-            "--git-dir".to_string(),
-            "/foo/.git".to_string(),
-        ];
-        let cmd = git_cmd(&global_args);
-        let args: Vec<_> = cmd.get_args().collect();
-        assert_eq!(
-            args,
-            vec![
-                "-C",
-                "/tmp",
-                "-c",
-                "user.name=test",
-                "--git-dir",
-                "/foo/.git"
-            ]
-        );
-    }
-
-    #[test]
-    fn test_git_cmd_with_boolean_flags() {
-        let global_args = vec!["--no-pager".to_string(), "--bare".to_string()];
-        let cmd = git_cmd(&global_args);
-        let args: Vec<_> = cmd.get_args().collect();
-        assert_eq!(args, vec!["--no-pager", "--bare"]);
-    }
-
-    #[test]
-    fn test_compact_diff() {
-        let diff = r#"diff --git a/foo.rs b/foo.rs
---- a/foo.rs
-+++ b/foo.rs
-@@ -1,3 +1,4 @@
- fn main() {
-+    println!("hello");
- }
-"#;
-        let result = compact_diff(diff, 100);
-        assert!(result.contains("foo.rs"));
-        assert!(result.contains("+"));
-    }
-
-    #[test]
-    fn test_compact_diff_increased_hunk_limit() {
-        // Build a hunk with 25 changed lines — should NOT be truncated with limit 30
-        let mut diff =
-            "diff --git a/big.rs b/big.rs\n--- a/big.rs\n+++ b/big.rs\n@@ -1,25 +1,25 @@\n"
-                .to_string();
-        for i in 1..=25 {
-            diff.push_str(&format!("+line{}\n", i));
-        }
-        let result = compact_diff(&diff, 500);
-        assert!(
-            !result.contains("... (truncated)"),
-            "25 lines should not be truncated with max_hunk_lines=30"
-        );
-        assert!(result.contains("+line25"));
-    }
-
-    #[test]
-    fn test_compact_diff_increased_total_limit() {
-        // Build a diff with 150 output result lines across multiple files — should NOT be cut at 100
-        let mut diff = String::new();
-        for f in 1..=5 {
-            diff.push_str(&format!("diff --git a/file{f}.rs b/file{f}.rs\n--- a/file{f}.rs\n+++ b/file{f}.rs\n@@ -1,20 +1,20 @@\n"));
-            for i in 1..=20 {
-                diff.push_str(&format!("+line{f}_{i}\n"));
-            }
-        }
-        let result = compact_diff(&diff, 500);
-        assert!(
-            !result.contains("more changes truncated"),
-            "5 files × 20 lines should not exceed max_lines=500"
-        );
-    }
-
-    #[test]
-    fn test_is_blob_show_arg() {
-        assert!(is_blob_show_arg("develop:modules/pairs_backtest.py"));
-        assert!(is_blob_show_arg("HEAD:src/main.rs"));
-        assert!(!is_blob_show_arg("--pretty=format:%h"));
-        assert!(!is_blob_show_arg("--format=short"));
-        assert!(!is_blob_show_arg("HEAD"));
-    }
-
-    #[test]
-    fn test_filter_branch_output() {
-        let output = "* main\n  feature/auth\n  fix/bug-123\n  remotes/origin/HEAD -> origin/main\n  remotes/origin/main\n  remotes/origin/feature/auth\n  remotes/origin/release/v2\n";
-        let result = filter_branch_output(output);
-        assert!(result.contains("* main"));
-        assert!(result.contains("feature/auth"));
-        assert!(result.contains("fix/bug-123"));
-        // remote-only should show release/v2 but not main or feature/auth (already local)
-        assert!(result.contains("remote-only"));
-        assert!(result.contains("release/v2"));
-    }
-
-    #[test]
-    fn test_filter_branch_no_remotes() {
-        let output = "* main\n  develop\n";
-        let result = filter_branch_output(output);
-        assert!(result.contains("* main"));
-        assert!(result.contains("develop"));
-        assert!(!result.contains("remote-only"));
-    }
-
-    #[test]
-    fn test_filter_stash_list() {
-        let output =
-            "stash@{0}: WIP on main: abc1234 fix login\nstash@{1}: On feature: def5678 wip\n";
-        let result = filter_stash_list(output);
-        assert!(result.contains("stash@{0}: abc1234 fix login"));
-        assert!(result.contains("stash@{1}: def5678 wip"));
-    }
-
-    #[test]
-    fn test_filter_worktree_list() {
-        let output =
-            "/home/user/project  abc1234 [main]\n/home/user/worktrees/feat  def5678 [feature]\n";
-        let result = filter_worktree_list(output);
-        assert!(result.contains("abc1234"));
-        assert!(result.contains("[main]"));
-        assert!(result.contains("[feature]"));
-    }
-
-    #[test]
-    fn test_format_status_output_clean() {
-        let porcelain = "";
-        let result = format_status_output(porcelain);
-        assert_eq!(result, "Clean working tree");
-    }
-
-    #[test]
-    fn test_format_status_output_modified_files() {
-        let porcelain = "## main...origin/main\n M src/main.rs\n M src/lib.rs\n";
-        let result = format_status_output(porcelain);
-        assert!(result.contains("📌 main...origin/main"));
-        assert!(result.contains("📝 Modified: 2 files"));
-        assert!(result.contains("src/main.rs"));
-        assert!(result.contains("src/lib.rs"));
-        assert!(!result.contains("Staged"));
-        assert!(!result.contains("Untracked"));
-    }
-
-    #[test]
-    fn test_format_status_output_untracked_files() {
-        let porcelain = "## feature/new\n?? temp.txt\n?? debug.log\n?? test.sh\n";
-        let result = format_status_output(porcelain);
-        assert!(result.contains("📌 feature/new"));
-        assert!(result.contains("❓ Untracked: 3 files"));
-        assert!(result.contains("temp.txt"));
-        assert!(result.contains("debug.log"));
-        assert!(result.contains("test.sh"));
-        assert!(!result.contains("Modified"));
-    }
-
-    #[test]
-    fn test_format_status_output_mixed_changes() {
-        let porcelain = r#"## main
-M  staged.rs
- M modified.rs
-A  added.rs
-?? untracked.txt
-"#;
-        let result = format_status_output(porcelain);
-        assert!(result.contains("📌 main"));
-        assert!(result.contains("✅ Staged: 2 files"));
-        assert!(result.contains("staged.rs"));
-        assert!(result.contains("added.rs"));
-        assert!(result.contains("📝 Modified: 1 files"));
-        assert!(result.contains("modified.rs"));
-        assert!(result.contains("❓ Untracked: 1 files"));
-        assert!(result.contains("untracked.txt"));
-    }
-
-    #[test]
-    fn test_format_status_output_truncation() {
-        // Test that >5 staged files show "... +N more"
-        let porcelain = r#"## main
-M  file1.rs
-M  file2.rs
-M  file3.rs
-M  file4.rs
-M  file5.rs
-M  file6.rs
-M  file7.rs
-"#;
-        let result = format_status_output(porcelain);
-        assert!(result.contains("✅ Staged: 7 files"));
-        assert!(result.contains("file1.rs"));
-        assert!(result.contains("file5.rs"));
-        assert!(result.contains("... +2 more"));
-        assert!(!result.contains("file6.rs"));
-        assert!(!result.contains("file7.rs"));
-    }
-
-    #[test]
-    fn test_run_passthrough_accepts_args() {
-        // Test that run_passthrough compiles and has correct signature
-        let _args: Vec<OsString> = vec![OsString::from("tag"), OsString::from("--list")];
-        // Compile-time verification that the function exists with correct signature
-    }
-
-    #[test]
-    fn test_filter_log_output() {
-        let output = "abc1234 This is a commit message (2 days ago) <author>\ndef5678 Another commit (1 week ago) <other>\n";
-        let result = filter_log_output(output, 10, false);
-        assert!(result.contains("abc1234"));
-        assert!(result.contains("def5678"));
-        assert_eq!(result.lines().count(), 2);
-    }
-
-    #[test]
-    fn test_filter_log_output_truncate_long() {
-        let long_line = "abc1234 ".to_string() + &"x".repeat(100) + " (2 days ago) <author>";
-        let result = filter_log_output(&long_line, 10, false);
-        assert!(result.chars().count() < long_line.chars().count());
-        assert!(result.contains("..."));
-        assert!(result.chars().count() <= 80);
-    }
-
-    #[test]
-    fn test_filter_log_output_cap_lines() {
-        let output = (0..20)
-            .map(|i| format!("hash{} message {} (1 day ago) <author>", i, i))
-            .collect::<Vec<_>>()
-            .join("\n");
-        let result = filter_log_output(&output, 5, false);
-        assert_eq!(result.lines().count(), 5);
-    }
-
-    #[test]
-    fn test_filter_log_output_user_limit_no_cap() {
-        // When user explicitly passes -N, all N lines should be returned (no re-truncation)
-        let output = (0..20)
-            .map(|i| format!("hash{} message {} (1 day ago) <author>", i, i))
-            .collect::<Vec<_>>()
-            .join("\n");
-        let result = filter_log_output(&output, 20, true);
-        assert_eq!(
-            result.lines().count(),
-            20,
-            "User's -20 should return all 20 lines"
-        );
-    }
-
-    #[test]
-    fn test_filter_log_output_user_limit_wider_truncation() {
-        // When user explicitly passes -N, lines up to 120 chars should NOT be truncated
-        let line_90_chars = format!("abc1234 {} (2 days ago) <author>", "x".repeat(60));
-        assert!(line_90_chars.chars().count() > 80);
-        assert!(line_90_chars.chars().count() < 120);
-
-        let result_default = filter_log_output(&line_90_chars, 10, false);
-        let result_user = filter_log_output(&line_90_chars, 10, true);
-
-        // Default truncates at 80 chars
-        assert!(
-            result_default.contains("..."),
-            "Default should truncate at 80 chars"
-        );
-        // User-set limit uses wider threshold (120 chars)
-        assert!(
-            !result_user.contains("..."),
-            "User limit should not truncate 90-char line"
-        );
-    }
-
-    #[test]
-    fn test_parse_user_limit_combined() {
-        let args: Vec<String> = vec!["-20".into()];
-        assert_eq!(parse_user_limit(&args), Some(20));
-    }
-
-    #[test]
-    fn test_parse_user_limit_n_space() {
-        let args: Vec<String> = vec!["-n".into(), "15".into()];
-        assert_eq!(parse_user_limit(&args), Some(15));
-    }
-
-    #[test]
-    fn test_parse_user_limit_max_count_eq() {
-        let args: Vec<String> = vec!["--max-count=30".into()];
-        assert_eq!(parse_user_limit(&args), Some(30));
-    }
-
-    #[test]
-    fn test_parse_user_limit_max_count_space() {
-        let args: Vec<String> = vec!["--max-count".into(), "25".into()];
-        assert_eq!(parse_user_limit(&args), Some(25));
-    }
-
-    #[test]
-    fn test_parse_user_limit_none() {
-        let args: Vec<String> = vec!["--oneline".into()];
-        assert_eq!(parse_user_limit(&args), None);
-    }
-
-    #[test]
-    fn test_filter_log_output_token_savings() {
-        fn count_tokens(text: &str) -> usize {
-            text.split_whitespace().count()
-        }
-        // Simulate verbose git log output (default format with full metadata)
-        let input = (0..20)
-            .map(|i| {
-                format!(
-                    "commit abc123{:02x}\nAuthor: User Name <user@example.com>\nDate:   Mon Mar 10 10:00:00 2026 +0000\n\n    fix: commit message number {}\n\n    Extended body with details about the change.\n",
-                    i, i
-                )
-            })
-            .collect::<Vec<_>>()
-            .join("\n");
-        let output = filter_log_output(&input, 10, false);
-        let savings = 100.0 - (count_tokens(&output) as f64 / count_tokens(&input) as f64 * 100.0);
-        assert!(
-            savings >= 60.0,
-            "Expected ≥60% token savings, got {:.1}%",
-            savings
-        );
-    }
-
-    #[test]
-    fn test_filter_status_with_args() {
-        let output = r#"On branch main
-Your branch is up to date with 'origin/main'.
-
-Changes not staged for commit:
-  (use "git add <file>..." to update what will be committed)
-  (use "git restore <file>..." to discard changes in working directory)
-	modified:   src/main.rs
-
-no changes added to commit (use "git add" and/or "git commit -a")
-"#;
-        let result = filter_status_with_args(output);
-        eprintln!("Result:\n{}", result);
-        assert!(result.contains("On branch main"));
-        assert!(result.contains("modified:   src/main.rs"));
-        assert!(
-            !result.contains("(use \"git"),
-            "Result should not contain git hints"
-        );
-    }
-
-    #[test]
-    fn test_filter_status_with_args_clean() {
-        let output = "nothing to commit, working tree clean\n";
-        let result = filter_status_with_args(output);
-        assert!(result.contains("nothing to commit"));
-    }
-
-    #[test]
-    fn test_filter_log_output_multibyte() {
-        // Thai characters: each is 3 bytes. A line with >80 bytes but few chars
-        let thai_msg = format!("abc1234 {} (2 days ago) <author>", "ก".repeat(30));
-        let result = filter_log_output(&thai_msg, 10, false);
-        // Should not panic
-        assert!(result.contains("abc1234"));
-        // The line has 30 Thai chars + other text, so > 80 chars total
-        // truncate_line now counts chars, not bytes
-        // 30 Thai + ~33 other = 63 chars < 80 threshold, so no truncation
-        assert!(result.contains("abc1234"));
-    }
-
-    #[test]
-    fn test_filter_log_output_emoji() {
-        let emoji_msg = "abc1234 🎉🎊🎈🎁🎂🎄🎃🎆🎇✨🎉🎊🎈🎁🎂🎄🎃🎆🎇✨ (1 day ago) <user>";
-        let result = filter_log_output(emoji_msg, 10, false);
-        // Should not panic
-        // 20 emoji + ~30 other chars = ~50 chars < 80, no truncation needed
-        assert!(result.contains("abc1234"));
-    }
-
-    #[test]
-    fn test_format_status_output_thai_filename() {
-        let porcelain = "## main\n M สวัสดี.txt\n?? ทดสอบ.rs\n";
-        let result = format_status_output(porcelain);
-        // Should not panic
-        assert!(result.contains("📌 main"));
-        assert!(result.contains("สวัสดี.txt"));
-        assert!(result.contains("ทดสอบ.rs"));
-    }
-
-    #[test]
-    fn test_format_status_output_emoji_filename() {
-        let porcelain = "## main\nA  🎉-party.txt\n M 日本語ファイル.rs\n";
-        let result = format_status_output(porcelain);
-        assert!(result.contains("📌 main"));
-    }
-
-    /// Regression test: `git branch <name>` must create, not list.
-    /// Before fix, positional args fell into list mode which added `-a`,
-    /// turning creation into a pattern-filtered listing (silent no-op).
-    #[test]
-    #[ignore] // Integration test: requires git repo
-    fn test_branch_creation_not_swallowed() {
-        let branch = "test-rtk-create-branch-regression";
-        // Create branch via run_branch
-        run_branch(&[branch.to_string()], 0, &[]).expect("run_branch should succeed");
-        // Verify it exists
-        let output = Command::new("git")
-            .args(["branch", "--list", branch])
-            .output()
-            .expect("git branch --list should work");
-        let stdout = String::from_utf8_lossy(&output.stdout);
-        assert!(
-            stdout.contains(branch),
-            "Branch '{}' was not created. run_branch silently swallowed the creation.",
-            branch
-        );
-        // Cleanup
-        let _ = Command::new("git").args(["branch", "-d", branch]).output();
-    }
-
-    /// Regression test: `git branch <name> <commit>` must create from commit.
-    #[test]
-    #[ignore] // Integration test: requires git repo
-    fn test_branch_creation_from_commit() {
-        let branch = "test-rtk-create-from-commit";
-        run_branch(&[branch.to_string(), "HEAD".to_string()], 0, &[])
-            .expect("run_branch with start-point should succeed");
-        let output = Command::new("git")
-            .args(["branch", "--list", branch])
-            .output()
-            .expect("git branch --list should work");
-        let stdout = String::from_utf8_lossy(&output.stdout);
-        assert!(
-            stdout.contains(branch),
-            "Branch '{}' was not created from commit.",
-            branch
-        );
-        let _ = Command::new("git").args(["branch", "-d", branch]).output();
-    }
-
-    #[test]
-    fn test_commit_single_message() {
-        let args = vec!["-m".to_string(), "fix: typo".to_string()];
-        let cmd = build_commit_command(&args, &[]);
-        let cmd_args: Vec<_> = cmd
-            .get_args()
-            .map(|a| a.to_string_lossy().to_string())
-            .collect();
-        assert_eq!(cmd_args, vec!["commit", "-m", "fix: typo"]);
-    }
-
-    #[test]
-    fn test_commit_multiple_messages() {
-        let args = vec![
-            "-m".to_string(),
-            "feat: add multi-paragraph support".to_string(),
-            "-m".to_string(),
-            "This allows git commit -m \"title\" -m \"body\".".to_string(),
-        ];
-        let cmd = build_commit_command(&args, &[]);
-        let cmd_args: Vec<_> = cmd
-            .get_args()
-            .map(|a| a.to_string_lossy().to_string())
-            .collect();
-        assert_eq!(
-            cmd_args,
-            vec![
-                "commit",
-                "-m",
-                "feat: add multi-paragraph support",
-                "-m",
-                "This allows git commit -m \"title\" -m \"body\"."
-            ]
-        );
-    }
-
-    // #327: git commit -am "msg" must pass -am through to git
-    #[test]
-    fn test_commit_am_flag() {
-        let args = vec!["-am".to_string(), "quick fix".to_string()];
-        let cmd = build_commit_command(&args, &[]);
-        let cmd_args: Vec<_> = cmd
-            .get_args()
-            .map(|a| a.to_string_lossy().to_string())
-            .collect();
-        assert_eq!(cmd_args, vec!["commit", "-am", "quick fix"]);
-    }
-
-    #[test]
-    fn test_commit_amend() {
-        let args = vec![
-            "--amend".to_string(),
-            "-m".to_string(),
-            "new msg".to_string(),
-        ];
-        let cmd = build_commit_command(&args, &[]);
-        let cmd_args: Vec<_> = cmd
-            .get_args()
-            .map(|a| a.to_string_lossy().to_string())
-            .collect();
-        assert_eq!(cmd_args, vec!["commit", "--amend", "-m", "new msg"]);
-    }
-
-    #[test]
-    #[ignore] // Requires `cargo build` first — run with `cargo test --ignored`
-    fn test_git_status_not_a_repo_exits_nonzero() {
-        // Run rtk git status in a directory that is not a git repo
-        let tmp = std::env::temp_dir().join("rtk_test_not_a_repo");
-        let _ = std::fs::create_dir_all(&tmp);
-
-        // Build the path to the test binary
-        let bin_path = std::path::PathBuf::from(env!("CARGO_MANIFEST_DIR"))
-            .join("target")
-            .join("debug")
-            .join("rtk");
-        assert!(
-            bin_path.exists(),
-            "Debug binary not found at {:?} — run `cargo build` first",
-            bin_path
-        );
-        let output = std::process::Command::new(&bin_path)
-            .args(["git", "status"])
-            .current_dir(&tmp)
-            .output()
-            .expect("Failed to run rtk");
-
-        // Should exit with non-zero (128 from git)
-        assert!(
-            !output.status.success(),
-            "Expected non-zero exit code for git status outside a repo, got {:?}",
-            output.status.code()
-        );
-
-        // Message should be on stderr, not stdout
-        let stderr = String::from_utf8_lossy(&output.stderr);
-        let stdout = String::from_utf8_lossy(&output.stdout);
-        assert!(
-            stderr.to_lowercase().contains("not a git repository"),
-            "Expected 'not a git repository' on stderr, got stderr={:?}, stdout={:?}",
-            stderr,
-            stdout
-        );
-
-        let _ = std::fs::remove_dir_all(&tmp);
-    }
-}