@hasna/terminal 2.2.0 → 2.3.0

package/temp/rtk/src/gh_cmd.rs

@@ -0,0 +1,1651 @@
+//! GitHub CLI (gh) command output compression.
+//!
+//! Provides token-optimized alternatives to verbose `gh` commands.
+//! Focuses on extracting essential information from JSON outputs.
+
+use crate::git;
+use crate::tracking;
+use crate::utils::{ok_confirmation, truncate};
+use anyhow::{Context, Result};
+use lazy_static::lazy_static;
+use regex::Regex;
+use serde_json::Value;
+use std::process::Command;
+
+lazy_static! {
+    static ref HTML_COMMENT_RE: Regex = Regex::new(r"(?s)<!--.*?-->").unwrap();
+    static ref BADGE_LINE_RE: Regex =
+        Regex::new(r"(?m)^\s*\[!\[[^\]]*\]\([^)]*\)\]\([^)]*\)\s*$").unwrap();
+    static ref IMAGE_ONLY_LINE_RE: Regex = Regex::new(r"(?m)^\s*!\[[^\]]*\]\([^)]*\)\s*$").unwrap();
+    static ref HORIZONTAL_RULE_RE: Regex =
+        Regex::new(r"(?m)^\s*(?:---+|\*\*\*+|___+)\s*$").unwrap();
+    static ref MULTI_BLANK_RE: Regex = Regex::new(r"\n{3,}").unwrap();
+}
+
+/// Filter markdown body to remove noise while preserving meaningful content.
+/// Removes HTML comments, badge lines, image-only lines, horizontal rules,
+/// and collapses excessive blank lines. Preserves code blocks untouched.
+fn filter_markdown_body(body: &str) -> String {
+    if body.is_empty() {
+        return String::new();
+    }
+
+    // Split into code blocks and non-code segments
+    let mut result = String::new();
+    let mut remaining = body;
+
+    loop {
+        // Find next code block opening (``` or ~~~)
+        let fence_pos = remaining
+            .find("```")
+            .or_else(|| remaining.find("~~~"))
+            .map(|pos| {
+                let fence = if remaining[pos..].starts_with("```") {
+                    "```"
+                } else {
+                    "~~~"
+                };
+                (pos, fence)
+            });
+
+        match fence_pos {
+            Some((start, fence)) => {
+                // Filter the text before the code block
+                let before = &remaining[..start];
+                result.push_str(&filter_markdown_segment(before));
+
+                // Find the closing fence
+                let after_open = start + fence.len();
+                // Skip past the opening fence line
+                let code_start = remaining[after_open..]
+                    .find('\n')
+                    .map(|p| after_open + p + 1)
+                    .unwrap_or(remaining.len());
+
+                let close_pos = remaining[code_start..]
+                    .find(fence)
+                    .map(|p| code_start + p + fence.len());
+
+                match close_pos {
+                    Some(end) => {
+                        // Preserve the entire code block as-is
+                        result.push_str(&remaining[start..end]);
+                        // Include the rest of the closing fence line
+                        let after_close = remaining[end..]
+                            .find('\n')
+                            .map(|p| end + p + 1)
+                            .unwrap_or(remaining.len());
+                        result.push_str(&remaining[end..after_close]);
+                        remaining = &remaining[after_close..];
+                    }
+                    None => {
+                        // Unclosed code block — preserve everything
+                        result.push_str(&remaining[start..]);
+                        remaining = "";
+                    }
+                }
+            }
+            None => {
+                // No more code blocks, filter the rest
+                result.push_str(&filter_markdown_segment(remaining));
+                break;
+            }
+        }
+    }
+
+    // Final cleanup: trim trailing whitespace
+    result.trim().to_string()
+}
+
+/// Filter a markdown segment that is NOT inside a code block.
+fn filter_markdown_segment(text: &str) -> String {
+    let mut s = HTML_COMMENT_RE.replace_all(text, "").to_string();
+    s = BADGE_LINE_RE.replace_all(&s, "").to_string();
+    s = IMAGE_ONLY_LINE_RE.replace_all(&s, "").to_string();
+    s = HORIZONTAL_RULE_RE.replace_all(&s, "").to_string();
+    s = MULTI_BLANK_RE.replace_all(&s, "\n\n").to_string();
+    s
+}
+
+/// Check if args contain --json flag (user wants specific JSON fields, not RTK filtering)
+fn has_json_flag(args: &[String]) -> bool {
+    args.iter().any(|a| a == "--json")
+}
+
+/// Extract a positional identifier (PR/issue number) from args, returning it
+/// separately from the remaining extra flags (like -R, --repo, etc.).
+/// Handles both `view 123 -R owner/repo` and `view -R owner/repo 123`.
+fn extract_identifier_and_extra_args(args: &[String]) -> Option<(String, Vec<String>)> {
+    if args.is_empty() {
+        return None;
+    }
+
+    // Known gh flags that take a value — skip these and their values
+    let flags_with_value = [
+        "-R",
+        "--repo",
+        "-q",
+        "--jq",
+        "-t",
+        "--template",
+        "--job",
+        "--attempt",
+    ];
+    let mut identifier = None;
+    let mut extra = Vec::new();
+    let mut skip_next = false;
+
+    for arg in args {
+        if skip_next {
+            extra.push(arg.clone());
+            skip_next = false;
+            continue;
+        }
+        if flags_with_value.contains(&arg.as_str()) {
+            extra.push(arg.clone());
+            skip_next = true;
+            continue;
+        }
+        if arg.starts_with('-') {
+            extra.push(arg.clone());
+            continue;
+        }
+        // First non-flag arg is the identifier (number/URL)
+        if identifier.is_none() {
+            identifier = Some(arg.clone());
+        } else {
+            extra.push(arg.clone());
+        }
+    }
+
+    identifier.map(|id| (id, extra))
+}
+
+/// Run a gh command with token-optimized output
+pub fn run(subcommand: &str, args: &[String], verbose: u8, ultra_compact: bool) -> Result<()> {
+    // When user explicitly passes --json, they want raw gh JSON output, not RTK filtering
+    if has_json_flag(args) {
+        return run_passthrough("gh", subcommand, args);
+    }
+
+    match subcommand {
+        "pr" => run_pr(args, verbose, ultra_compact),
+        "issue" => run_issue(args, verbose, ultra_compact),
+        "run" => run_workflow(args, verbose, ultra_compact),
+        "repo" => run_repo(args, verbose, ultra_compact),
+        "api" => run_api(args, verbose),
+        _ => {
+            // Unknown subcommand, pass through
+            run_passthrough("gh", subcommand, args)
+        }
+    }
+}
+
+fn run_pr(args: &[String], verbose: u8, ultra_compact: bool) -> Result<()> {
+    if args.is_empty() {
+        return run_passthrough("gh", "pr", args);
+    }
+
+    match args[0].as_str() {
+        "list" => list_prs(&args[1..], verbose, ultra_compact),
+        "view" => view_pr(&args[1..], verbose, ultra_compact),
+        "checks" => pr_checks(&args[1..], verbose, ultra_compact),
+        "status" => pr_status(verbose, ultra_compact),
+        "create" => pr_create(&args[1..], verbose),
+        "merge" => pr_merge(&args[1..], verbose),
+        "diff" => pr_diff(&args[1..], verbose),
+        "comment" => pr_action("commented", &args, verbose),
+        "edit" => pr_action("edited", &args, verbose),
+        _ => run_passthrough("gh", "pr", args),
+    }
+}
+
+fn list_prs(args: &[String], _verbose: u8, ultra_compact: bool) -> Result<()> {
+    let timer = tracking::TimedExecution::start();
+
+    let mut cmd = Command::new("gh");
+    cmd.args([
+        "pr",
+        "list",
+        "--json",
+        "number,title,state,author,updatedAt",
+    ]);
+
+    // Pass through additional flags
+    for arg in args {
+        cmd.arg(arg);
+    }
+
+    let output = cmd.output().context("Failed to run gh pr list")?;
+    let raw = String::from_utf8_lossy(&output.stdout).to_string();
+
+    if !output.status.success() {
+        let stderr = String::from_utf8_lossy(&output.stderr).to_string();
+        timer.track("gh pr list", "rtk gh pr list", &stderr, &stderr);
+        eprintln!("{}", stderr.trim());
+        std::process::exit(output.status.code().unwrap_or(1));
+    }
+
+    let json: Value =
+        serde_json::from_slice(&output.stdout).context("Failed to parse gh pr list output")?;
+
+    let mut filtered = String::new();
+
+    if let Some(prs) = json.as_array() {
+        if ultra_compact {
+            filtered.push_str("PRs\n");
+            println!("PRs");
+        } else {
+            filtered.push_str("📋 Pull Requests\n");
+            println!("📋 Pull Requests");
+        }
+
+        for pr in prs.iter().take(20) {
+            let number = pr["number"].as_i64().unwrap_or(0);
+            let title = pr["title"].as_str().unwrap_or("???");
+            let state = pr["state"].as_str().unwrap_or("???");
+            let author = pr["author"]["login"].as_str().unwrap_or("???");
+
+            let state_icon = if ultra_compact {
+                match state {
+                    "OPEN" => "O",
+                    "MERGED" => "M",
+                    "CLOSED" => "C",
+                    _ => "?",
+                }
+            } else {
+                match state {
+                    "OPEN" => "🟢",
+                    "MERGED" => "🟣",
+                    "CLOSED" => "🔴",
+                    _ => "⚪",
+                }
+            };
+
+            let line = format!(
+                "  {} #{} {} ({})\n",
+                state_icon,
+                number,
+                truncate(title, 60),
+                author
+            );
+            filtered.push_str(&line);
+            print!("{}", line);
+        }
+
+        if prs.len() > 20 {
+            let more_line = format!("  ... {} more (use gh pr list for all)\n", prs.len() - 20);
+            filtered.push_str(&more_line);
+            print!("{}", more_line);
+        }
+    }
+
+    timer.track("gh pr list", "rtk gh pr list", &raw, &filtered);
+    Ok(())
+}
+
+fn should_passthrough_pr_view(extra_args: &[String]) -> bool {
+    extra_args
+        .iter()
+        .any(|a| a == "--json" || a == "--jq" || a == "--web")
+}
+
+fn view_pr(args: &[String], _verbose: u8, ultra_compact: bool) -> Result<()> {
+    let timer = tracking::TimedExecution::start();
+
+    let (pr_number, extra_args) = match extract_identifier_and_extra_args(args) {
+        Some(result) => result,
+        None => return Err(anyhow::anyhow!("PR number required")),
+    };
+
+    // If the user provides --jq or --web, pass through directly.
+    // Note: --json is already handled globally by run() via has_json_flag.
+    if should_passthrough_pr_view(&extra_args) {
+        return run_passthrough_with_extra("gh", &["pr", "view", &pr_number], &extra_args);
+    }
+
+    let mut cmd = Command::new("gh");
+    cmd.args([
+        "pr",
+        "view",
+        &pr_number,
+        "--json",
+        "number,title,state,author,body,url,mergeable,reviews,statusCheckRollup",
+    ]);
+    for arg in &extra_args {
+        cmd.arg(arg);
+    }
+
+    let output = cmd.output().context("Failed to run gh pr view")?;
+    let raw = String::from_utf8_lossy(&output.stdout).to_string();
+
+    if !output.status.success() {
+        let stderr = String::from_utf8_lossy(&output.stderr).to_string();
+        timer.track(
+            &format!("gh pr view {}", pr_number),
+            &format!("rtk gh pr view {}", pr_number),
+            &stderr,
+            &stderr,
+        );
+        eprintln!("{}", stderr.trim());
+        std::process::exit(output.status.code().unwrap_or(1));
+    }
+
+    let json: Value =
+        serde_json::from_slice(&output.stdout).context("Failed to parse gh pr view output")?;
+
+    let mut filtered = String::new();
+
+    // Extract essential info
+    let number = json["number"].as_i64().unwrap_or(0);
+    let title = json["title"].as_str().unwrap_or("???");
+    let state = json["state"].as_str().unwrap_or("???");
+    let author = json["author"]["login"].as_str().unwrap_or("???");
+    let url = json["url"].as_str().unwrap_or("");
+    let mergeable = json["mergeable"].as_str().unwrap_or("UNKNOWN");
+
+    let state_icon = if ultra_compact {
+        match state {
+            "OPEN" => "O",
+            "MERGED" => "M",
+            "CLOSED" => "C",
+            _ => "?",
+        }
+    } else {
+        match state {
+            "OPEN" => "🟢",
+            "MERGED" => "🟣",
+            "CLOSED" => "🔴",
+            _ => "⚪",
+        }
+    };
+
+    let line = format!("{} PR #{}: {}\n", state_icon, number, title);
+    filtered.push_str(&line);
+    print!("{}", line);
+
+    let line = format!("  {}\n", author);
+    filtered.push_str(&line);
+    print!("{}", line);
+
+    let mergeable_str = match mergeable {
+        "MERGEABLE" => "✓",
+        "CONFLICTING" => "✗",
+        _ => "?",
+    };
+    let line = format!("  {} | {}\n", state, mergeable_str);
+    filtered.push_str(&line);
+    print!("{}", line);
+
+    // Show reviews summary
+    if let Some(reviews) = json["reviews"]["nodes"].as_array() {
+        let approved = reviews
+            .iter()
+            .filter(|r| r["state"].as_str() == Some("APPROVED"))
+            .count();
+        let changes = reviews
+            .iter()
+            .filter(|r| r["state"].as_str() == Some("CHANGES_REQUESTED"))
+            .count();
+
+        if approved > 0 || changes > 0 {
+            let line = format!(
+                "  Reviews: {} approved, {} changes requested\n",
+                approved, changes
+            );
+            filtered.push_str(&line);
+            print!("{}", line);
+        }
+    }
+
+    // Show checks summary
+    if let Some(checks) = json["statusCheckRollup"].as_array() {
+        let total = checks.len();
+        let passed = checks
+            .iter()
+            .filter(|c| {
+                c["conclusion"].as_str() == Some("SUCCESS")
+                    || c["state"].as_str() == Some("SUCCESS")
+            })
+            .count();
+        let failed = checks
+            .iter()
+            .filter(|c| {
+                c["conclusion"].as_str() == Some("FAILURE")
+                    || c["state"].as_str() == Some("FAILURE")
+            })
+            .count();
+
+        if ultra_compact {
+            if failed > 0 {
+                let line = format!("  ✗{}/{}  {} fail\n", passed, total, failed);
+                filtered.push_str(&line);
+                print!("{}", line);
+            } else {
+                let line = format!("  ✓{}/{}\n", passed, total);
+                filtered.push_str(&line);
+                print!("{}", line);
+            }
+        } else {
+            let line = format!("  Checks: {}/{} passed\n", passed, total);
+            filtered.push_str(&line);
+            print!("{}", line);
+            if failed > 0 {
+                let line = format!("  ⚠️  {} checks failed\n", failed);
+                filtered.push_str(&line);
+                print!("{}", line);
+            }
+        }
+    }
+
+    let line = format!("  {}\n", url);
+    filtered.push_str(&line);
+    print!("{}", line);
+
+    // Show filtered body
+    if let Some(body) = json["body"].as_str() {
+        if !body.is_empty() {
+            let body_filtered = filter_markdown_body(body);
+            if !body_filtered.is_empty() {
+                filtered.push('\n');
+                println!();
+                for line in body_filtered.lines() {
+                    let formatted = format!("  {}\n", line);
+                    filtered.push_str(&formatted);
+                    print!("{}", formatted);
+                }
+            }
+        }
+    }
+
+    timer.track(
+        &format!("gh pr view {}", pr_number),
+        &format!("rtk gh pr view {}", pr_number),
+        &raw,
+        &filtered,
+    );
+    Ok(())
+}
+
+fn pr_checks(args: &[String], _verbose: u8, _ultra_compact: bool) -> Result<()> {
+    let timer = tracking::TimedExecution::start();
+
+    let (pr_number, extra_args) = match extract_identifier_and_extra_args(args) {
+        Some(result) => result,
+        None => return Err(anyhow::anyhow!("PR number required")),
+    };
+
+    let mut cmd = Command::new("gh");
+    cmd.args(["pr", "checks", &pr_number]);
+    for arg in &extra_args {
+        cmd.arg(arg);
+    }
+
+    let output = cmd.output().context("Failed to run gh pr checks")?;
+    let raw = String::from_utf8_lossy(&output.stdout).to_string();
+
+    if !output.status.success() {
+        let stderr = String::from_utf8_lossy(&output.stderr).to_string();
+        timer.track(
+            &format!("gh pr checks {}", pr_number),
+            &format!("rtk gh pr checks {}", pr_number),
+            &stderr,
+            &stderr,
+        );
+        eprintln!("{}", stderr.trim());
+        std::process::exit(output.status.code().unwrap_or(1));
+    }
+
+    let stdout = String::from_utf8_lossy(&output.stdout);
+
+    // Parse and compress checks output
+    let mut passed = 0;
+    let mut failed = 0;
+    let mut pending = 0;
+    let mut failed_checks = Vec::new();
+
+    for line in stdout.lines() {
+        if line.contains('✓') || line.contains("pass") {
+            passed += 1;
+        } else if line.contains('✗') || line.contains("fail") {
+            failed += 1;
+            failed_checks.push(line.trim().to_string());
+        } else if line.contains('*') || line.contains("pending") {
+            pending += 1;
+        }
+    }
+
+    let mut filtered = String::new();
+
+    let line = "🔍 CI Checks Summary:\n";
+    filtered.push_str(line);
+    print!("{}", line);
+
+    let line = format!("  ✅ Passed: {}\n", passed);
+    filtered.push_str(&line);
+    print!("{}", line);
+
+    let line = format!("  ❌ Failed: {}\n", failed);
+    filtered.push_str(&line);
+    print!("{}", line);
+
+    if pending > 0 {
+        let line = format!("  ⏳ Pending: {}\n", pending);
+        filtered.push_str(&line);
+        print!("{}", line);
+    }
+
+    if !failed_checks.is_empty() {
+        let line = "\n  Failed checks:\n";
+        filtered.push_str(line);
+        print!("{}", line);
+        for check in failed_checks {
+            let line = format!("    {}\n", check);
+            filtered.push_str(&line);
+            print!("{}", line);
+        }
+    }
+
+    timer.track(
+        &format!("gh pr checks {}", pr_number),
+        &format!("rtk gh pr checks {}", pr_number),
+        &raw,
+        &filtered,
+    );
+    Ok(())
+}
+
+fn pr_status(_verbose: u8, _ultra_compact: bool) -> Result<()> {
+    let timer = tracking::TimedExecution::start();
+
+    let mut cmd = Command::new("gh");
+    cmd.args([
+        "pr",
+        "status",
+        "--json",
+        "currentBranch,createdBy,reviewDecision,statusCheckRollup",
+    ]);
+
+    let output = cmd.output().context("Failed to run gh pr status")?;
+    let raw = String::from_utf8_lossy(&output.stdout).to_string();
+
+    if !output.status.success() {
+        let stderr = String::from_utf8_lossy(&output.stderr).to_string();
+        timer.track("gh pr status", "rtk gh pr status", &stderr, &stderr);
+        eprintln!("{}", stderr.trim());
+        std::process::exit(output.status.code().unwrap_or(1));
+    }
+
+    let json: Value =
+        serde_json::from_slice(&output.stdout).context("Failed to parse gh pr status output")?;
+
+    let mut filtered = String::new();
+
+    if let Some(created_by) = json["createdBy"].as_array() {
+        let line = format!("📝 Your PRs ({}):\n", created_by.len());
+        filtered.push_str(&line);
+        print!("{}", line);
+        for pr in created_by.iter().take(5) {
+            let number = pr["number"].as_i64().unwrap_or(0);
+            let title = pr["title"].as_str().unwrap_or("???");
+            let reviews = pr["reviewDecision"].as_str().unwrap_or("PENDING");
+            let line = format!("  #{} {} [{}]\n", number, truncate(title, 50), reviews);
+            filtered.push_str(&line);
+            print!("{}", line);
+        }
+    }
+
+    timer.track("gh pr status", "rtk gh pr status", &raw, &filtered);
+    Ok(())
+}
+
+fn run_issue(args: &[String], verbose: u8, ultra_compact: bool) -> Result<()> {
+    if args.is_empty() {
+        return run_passthrough("gh", "issue", args);
+    }
+
+    match args[0].as_str() {
+        "list" => list_issues(&args[1..], verbose, ultra_compact),
+        "view" => view_issue(&args[1..], verbose),
+        _ => run_passthrough("gh", "issue", args),
+    }
+}
+
+fn list_issues(args: &[String], _verbose: u8, ultra_compact: bool) -> Result<()> {
+    let timer = tracking::TimedExecution::start();
+
+    let mut cmd = Command::new("gh");
+    cmd.args(["issue", "list", "--json", "number,title,state,author"]);
+
+    for arg in args {
+        cmd.arg(arg);
+    }
+
+    let output = cmd.output().context("Failed to run gh issue list")?;
+    let raw = String::from_utf8_lossy(&output.stdout).to_string();
+
+    if !output.status.success() {
+        let stderr = String::from_utf8_lossy(&output.stderr).to_string();
+        timer.track("gh issue list", "rtk gh issue list", &stderr, &stderr);
+        eprintln!("{}", stderr.trim());
+        std::process::exit(output.status.code().unwrap_or(1));
+    }
+
+    let json: Value =
+        serde_json::from_slice(&output.stdout).context("Failed to parse gh issue list output")?;
+
+    let mut filtered = String::new();
+
+    if let Some(issues) = json.as_array() {
+        if ultra_compact {
+            filtered.push_str("Issues\n");
+            println!("Issues");
+        } else {
+            filtered.push_str("🐛 Issues\n");
+            println!("🐛 Issues");
+        }
+        for issue in issues.iter().take(20) {
+            let number = issue["number"].as_i64().unwrap_or(0);
+            let title = issue["title"].as_str().unwrap_or("???");
+            let state = issue["state"].as_str().unwrap_or("???");
+
+            let icon = if ultra_compact {
+                if state == "OPEN" {
+                    "O"
+                } else {
+                    "C"
+                }
+            } else {
+                if state == "OPEN" {
+                    "🟢"
+                } else {
+                    "🔴"
+                }
+            };
+            let line = format!("  {} #{} {}\n", icon, number, truncate(title, 60));
+            filtered.push_str(&line);
+            print!("{}", line);
+        }
+
+        if issues.len() > 20 {
+            let line = format!("  ... {} more\n", issues.len() - 20);
+            filtered.push_str(&line);
+            print!("{}", line);
+        }
+    }
+
+    timer.track("gh issue list", "rtk gh issue list", &raw, &filtered);
+    Ok(())
+}
+
+fn view_issue(args: &[String], _verbose: u8) -> Result<()> {
+    let timer = tracking::TimedExecution::start();
+
+    let (issue_number, extra_args) = match extract_identifier_and_extra_args(args) {
+        Some(result) => result,
+        None => return Err(anyhow::anyhow!("Issue number required")),
+    };
+
+    let mut cmd = Command::new("gh");
+    cmd.args([
+        "issue",
+        "view",
+        &issue_number,
+        "--json",
+        "number,title,state,author,body,url",
+    ]);
+    for arg in &extra_args {
+        cmd.arg(arg);
+    }
+
+    let output = cmd.output().context("Failed to run gh issue view")?;
+    let raw = String::from_utf8_lossy(&output.stdout).to_string();
+
+    if !output.status.success() {
+        let stderr = String::from_utf8_lossy(&output.stderr).to_string();
+        timer.track(
+            &format!("gh issue view {}", issue_number),
+            &format!("rtk gh issue view {}", issue_number),
+            &stderr,
+            &stderr,
+        );
+        eprintln!("{}", stderr.trim());
+        std::process::exit(output.status.code().unwrap_or(1));
+    }
+
+    let json: Value =
+        serde_json::from_slice(&output.stdout).context("Failed to parse gh issue view output")?;
+
+    let number = json["number"].as_i64().unwrap_or(0);
+    let title = json["title"].as_str().unwrap_or("???");
+    let state = json["state"].as_str().unwrap_or("???");
+    let author = json["author"]["login"].as_str().unwrap_or("???");
+    let url = json["url"].as_str().unwrap_or("");
+
+    let icon = if state == "OPEN" { "🟢" } else { "🔴" };
+
+    let mut filtered = String::new();
+
+    let line = format!("{} Issue #{}: {}\n", icon, number, title);
+    filtered.push_str(&line);
+    print!("{}", line);
+
+    let line = format!("  Author: @{}\n", author);
+    filtered.push_str(&line);
+    print!("{}", line);
+
+    let line = format!("  Status: {}\n", state);
+    filtered.push_str(&line);
+    print!("{}", line);
+
+    let line = format!("  URL: {}\n", url);
+    filtered.push_str(&line);
+    print!("{}", line);
+
+    if let Some(body) = json["body"].as_str() {
+        if !body.is_empty() {
+            let body_filtered = filter_markdown_body(body);
+            if !body_filtered.is_empty() {
+                let line = "\n  Description:\n";
+                filtered.push_str(line);
+                print!("{}", line);
+                for line in body_filtered.lines() {
+                    let formatted = format!("    {}\n", line);
+                    filtered.push_str(&formatted);
+                    print!("{}", formatted);
+                }
+            }
+        }
+    }
+
+    timer.track(
+        &format!("gh issue view {}", issue_number),
+        &format!("rtk gh issue view {}", issue_number),
+        &raw,
+        &filtered,
+    );
+    Ok(())
+}
+
+fn run_workflow(args: &[String], verbose: u8, ultra_compact: bool) -> Result<()> {
+    if args.is_empty() {
+        return run_passthrough("gh", "run", args);
+    }
+
+    match args[0].as_str() {
+        "list" => list_runs(&args[1..], verbose, ultra_compact),
+        "view" => view_run(&args[1..], verbose),
+        _ => run_passthrough("gh", "run", args),
+    }
+}
+
+fn list_runs(args: &[String], _verbose: u8, ultra_compact: bool) -> Result<()> {
+    let timer = tracking::TimedExecution::start();
+
+    let mut cmd = Command::new("gh");
+    cmd.args([
+        "run",
+        "list",
+        "--json",
+        "databaseId,name,status,conclusion,createdAt",
+    ]);
+    cmd.arg("--limit").arg("10");
+
+    for arg in args {
+        cmd.arg(arg);
+    }
+
+    let output = cmd.output().context("Failed to run gh run list")?;
+    let raw = String::from_utf8_lossy(&output.stdout).to_string();
+
+    if !output.status.success() {
+        let stderr = String::from_utf8_lossy(&output.stderr).to_string();
+        timer.track("gh run list", "rtk gh run list", &stderr, &stderr);
+        eprintln!("{}", stderr.trim());
+        std::process::exit(output.status.code().unwrap_or(1));
+    }
+
+    let json: Value =
+        serde_json::from_slice(&output.stdout).context("Failed to parse gh run list output")?;
+
+    let mut filtered = String::new();
+
+    if let Some(runs) = json.as_array() {
+        if ultra_compact {
+            filtered.push_str("Runs\n");
+            println!("Runs");
+        } else {
+            filtered.push_str("🏃 Workflow Runs\n");
+            println!("🏃 Workflow Runs");
+        }
+        for run in runs {
+            let id = run["databaseId"].as_i64().unwrap_or(0);
+            let name = run["name"].as_str().unwrap_or("???");
+            let status = run["status"].as_str().unwrap_or("???");
+            let conclusion = run["conclusion"].as_str().unwrap_or("");
+
+            let icon = if ultra_compact {
+                match conclusion {
+                    "success" => "✓",
+                    "failure" => "✗",
+                    "cancelled" => "X",
+                    _ => {
+                        if status == "in_progress" {
+                            "~"
+                        } else {
+                            "?"
+                        }
+                    }
+                }
+            } else {
+                match conclusion {
+                    "success" => "✅",
+                    "failure" => "❌",
+                    "cancelled" => "🚫",
+                    _ => {
+                        if status == "in_progress" {
+                            "⏳"
+                        } else {
+                            "⚪"
+                        }
+                    }
+                }
+            };
+
+            let line = format!("  {} {} [{}]\n", icon, truncate(name, 50), id);
+            filtered.push_str(&line);
+            print!("{}", line);
+        }
+    }
+
+    timer.track("gh run list", "rtk gh run list", &raw, &filtered);
+    Ok(())
+}
+
+/// Check if run view args should bypass filtering and pass through directly.
+/// Flags like --log-failed, --log, and --json produce output that the filter
+/// would incorrectly strip.
+fn should_passthrough_run_view(extra_args: &[String]) -> bool {
+    extra_args
+        .iter()
+        .any(|a| a == "--log-failed" || a == "--log" || a == "--json")
+}
+
+fn view_run(args: &[String], _verbose: u8) -> Result<()> {
+    let (run_id, extra_args) = match extract_identifier_and_extra_args(args) {
+        Some(result) => result,
+        None => return Err(anyhow::anyhow!("Run ID required")),
+    };
+
+    // Pass through when user requests logs or JSON — the filter would strip them
+    if should_passthrough_run_view(&extra_args) {
+        return run_passthrough_with_extra("gh", &["run", "view", &run_id], &extra_args);
+    }
+
+    let timer = tracking::TimedExecution::start();
+
+    let mut cmd = Command::new("gh");
+    cmd.args(["run", "view", &run_id]);
+    for arg in &extra_args {
+        cmd.arg(arg);
+    }
+
+    let output = cmd.output().context("Failed to run gh run view")?;
+    let raw = String::from_utf8_lossy(&output.stdout).to_string();
+
+    if !output.status.success() {
+        let stderr = String::from_utf8_lossy(&output.stderr).to_string();
+        timer.track(
+            &format!("gh run view {}", run_id),
+            &format!("rtk gh run view {}", run_id),
+            &stderr,
+            &stderr,
+        );
+        eprintln!("{}", stderr.trim());
+        std::process::exit(output.status.code().unwrap_or(1));
+    }
+
+    // Parse output and show only failures
+    let stdout = String::from_utf8_lossy(&output.stdout);
+    let mut in_jobs = false;
+
+    let mut filtered = String::new();
+
+    let line = format!("🏃 Workflow Run #{}\n", run_id);
+    filtered.push_str(&line);
+    print!("{}", line);
+
+    for line in stdout.lines() {
+        if line.contains("JOBS") {
+            in_jobs = true;
+        }
+
+        if in_jobs {
+            if line.contains('✓') || line.contains("success") {
+                // Skip successful jobs in compact mode
+                continue;
+            }
+            if line.contains('✗') || line.contains("fail") {
+                let formatted = format!("  ❌ {}\n", line.trim());
+                filtered.push_str(&formatted);
+                print!("{}", formatted);
+            }
+        } else if line.contains("Status:") || line.contains("Conclusion:") {
+            let formatted = format!("  {}\n", line.trim());
+            filtered.push_str(&formatted);
+            print!("{}", formatted);
+        }
+    }
+
+    timer.track(
+        &format!("gh run view {}", run_id),
+        &format!("rtk gh run view {}", run_id),
+        &raw,
+        &filtered,
+    );
+    Ok(())
+}
+
+fn run_repo(args: &[String], _verbose: u8, _ultra_compact: bool) -> Result<()> {
+    // Parse subcommand (default to "view")
+    let (subcommand, rest_args) = if args.is_empty() {
+        ("view", args)
+    } else {
+        (args[0].as_str(), &args[1..])
+    };
+
+    if subcommand != "view" {
+        return run_passthrough("gh", "repo", args);
+    }
+
+    let timer = tracking::TimedExecution::start();
+
+    let mut cmd = Command::new("gh");
+    cmd.arg("repo").arg("view");
+
+    for arg in rest_args {
+        cmd.arg(arg);
+    }
+
+    cmd.args([
+        "--json",
+        "name,owner,description,url,stargazerCount,forkCount,isPrivate",
+    ]);
+
+    let output = cmd.output().context("Failed to run gh repo view")?;
+    let raw = String::from_utf8_lossy(&output.stdout).to_string();
+
+    if !output.status.success() {
+        let stderr = String::from_utf8_lossy(&output.stderr).to_string();
+        timer.track("gh repo view", "rtk gh repo view", &stderr, &stderr);
+        eprintln!("{}", stderr.trim());
+        std::process::exit(output.status.code().unwrap_or(1));
+    }
+
+    let json: Value =
+        serde_json::from_slice(&output.stdout).context("Failed to parse gh repo view output")?;
+
+    let name = json["name"].as_str().unwrap_or("???");
+    let owner = json["owner"]["login"].as_str().unwrap_or("???");
+    let description = json["description"].as_str().unwrap_or("");
+    let url = json["url"].as_str().unwrap_or("");
+    let stars = json["stargazerCount"].as_i64().unwrap_or(0);
+    let forks = json["forkCount"].as_i64().unwrap_or(0);
+    let private = json["isPrivate"].as_bool().unwrap_or(false);
+
+    let visibility = if private {
+        "🔒 Private"
+    } else {
+        "🌐 Public"
+    };
+
+    let mut filtered = String::new();
+
+    let line = format!("📦 {}/{}\n", owner, name);
+    filtered.push_str(&line);
+    print!("{}", line);
+
+    let line = format!("  {}\n", visibility);
+    filtered.push_str(&line);
+    print!("{}", line);
+
+    if !description.is_empty() {
+        let line = format!("  {}\n", truncate(description, 80));
+        filtered.push_str(&line);
+        print!("{}", line);
+    }
+
+    let line = format!("  ⭐ {} stars | 🔱 {} forks\n", stars, forks);
+    filtered.push_str(&line);
+    print!("{}", line);
+
+    let line = format!("  {}\n", url);
+    filtered.push_str(&line);
+    print!("{}", line);
+
+    timer.track("gh repo view", "rtk gh repo view", &raw, &filtered);
+    Ok(())
+}
+
+fn pr_create(args: &[String], _verbose: u8) -> Result<()> {
+    let timer = tracking::TimedExecution::start();
+
+    let mut cmd = Command::new("gh");
+    cmd.args(["pr", "create"]);
+    for arg in args {
+        cmd.arg(arg);
+    }
+
+    let output = cmd.output().context("Failed to run gh pr create")?;
+    let stdout = String::from_utf8_lossy(&output.stdout).to_string();
+    let stderr = String::from_utf8_lossy(&output.stderr).to_string();
+
+    if !output.status.success() {
+        timer.track("gh pr create", "rtk gh pr create", &stderr, &stderr);
+        eprintln!("{}", stderr.trim());
+        std::process::exit(output.status.code().unwrap_or(1));
+    }
+
+    // gh pr create outputs the URL on success
+    let url = stdout.trim();
+
+    // Try to extract PR number from URL (e.g., https://github.com/owner/repo/pull/42)
+    let pr_num = url.rsplit('/').next().unwrap_or("");
+
+    let detail = if !pr_num.is_empty() && pr_num.chars().all(|c| c.is_ascii_digit()) {
+        format!("#{} {}", pr_num, url)
+    } else {
+        url.to_string()
+    };
+
+    let filtered = ok_confirmation("created", &detail);
+    println!("{}", filtered);
+
+    timer.track("gh pr create", "rtk gh pr create", &stdout, &filtered);
+    Ok(())
+}
+
+fn pr_merge(args: &[String], _verbose: u8) -> Result<()> {
+    let timer = tracking::TimedExecution::start();
+
+    let mut cmd = Command::new("gh");
+    cmd.args(["pr", "merge"]);
+    for arg in args {
+        cmd.arg(arg);
+    }
+
+    let output = cmd.output().context("Failed to run gh pr merge")?;
+    let stdout = String::from_utf8_lossy(&output.stdout).to_string();
+    let stderr = String::from_utf8_lossy(&output.stderr).to_string();
+
+    if !output.status.success() {
+        timer.track("gh pr merge", "rtk gh pr merge", &stderr, &stderr);
+        eprintln!("{}", stderr.trim());
+        std::process::exit(output.status.code().unwrap_or(1));
+    }
+
+    // Extract PR number from args (first non-flag arg)
+    let pr_num = args
+        .iter()
+        .find(|a| !a.starts_with('-'))
+        .map(|s| s.as_str())
+        .unwrap_or("");
+
+    let detail = if !pr_num.is_empty() {
+        format!("#{}", pr_num)
+    } else {
+        String::new()
+    };
+
+    let filtered = ok_confirmation("merged", &detail);
+    println!("{}", filtered);
+
+    // Use stdout or detail as raw input (gh pr merge doesn't output much)
+    let raw = if !stdout.trim().is_empty() {
+        stdout
+    } else {
+        detail.clone()
+    };
+
+    timer.track("gh pr merge", "rtk gh pr merge", &raw, &filtered);
+    Ok(())
+}
+
+fn pr_diff(args: &[String], _verbose: u8) -> Result<()> {
+    // --no-compact: pass full diff through (gh CLI doesn't know this flag, strip it)
+    let no_compact = args.iter().any(|a| a == "--no-compact");
+    let gh_args: Vec<String> = args
+        .iter()
+        .filter(|a| *a != "--no-compact")
+        .cloned()
+        .collect();
+
+    if no_compact {
+        return run_passthrough_with_extra("gh", &["pr", "diff"], &gh_args);
+    }
+
+    let timer = tracking::TimedExecution::start();
+
+    let mut cmd = Command::new("gh");
+    cmd.args(["pr", "diff"]);
+    for arg in gh_args.iter() {
+        cmd.arg(arg);
+    }
+
+    let output = cmd.output().context("Failed to run gh pr diff")?;
+    let raw = String::from_utf8_lossy(&output.stdout).to_string();
+
+    if !output.status.success() {
+        let stderr = String::from_utf8_lossy(&output.stderr).to_string();
+        timer.track("gh pr diff", "rtk gh pr diff", &stderr, &stderr);
+        eprintln!("{}", stderr.trim());
+        std::process::exit(output.status.code().unwrap_or(1));
+    }
+
+    let filtered = if raw.trim().is_empty() {
+        let msg = "No diff\n";
+        print!("{}", msg);
+        msg.to_string()
+    } else {
+        let compacted = git::compact_diff(&raw, 500);
+        println!("{}", compacted);
+        compacted
+    };
+
+    timer.track("gh pr diff", "rtk gh pr diff", &raw, &filtered);
+    Ok(())
+}
+
+/// Generic PR action handler for comment/edit
+fn pr_action(action: &str, args: &[String], _verbose: u8) -> Result<()> {
+    let timer = tracking::TimedExecution::start();
+    let subcmd = &args[0];
+
+    let mut cmd = Command::new("gh");
+    cmd.arg("pr");
+    for arg in args {
+        cmd.arg(arg);
+    }
+
+    let output = cmd
+        .output()
+        .context(format!("Failed to run gh pr {}", subcmd))?;
+    let stdout = String::from_utf8_lossy(&output.stdout).to_string();
+
+    if !output.status.success() {
+        let stderr = String::from_utf8_lossy(&output.stderr).to_string();
+        timer.track(
+            &format!("gh pr {}", subcmd),
+            &format!("rtk gh pr {}", subcmd),
+            &stderr,
+            &stderr,
+        );
+        eprintln!("{}", stderr.trim());
+        std::process::exit(output.status.code().unwrap_or(1));
+    }
+
+    // Extract PR number from args (skip args[0] which is the subcommand)
+    let pr_num = args[1..]
+        .iter()
+        .find(|a| !a.starts_with('-'))
+        .map(|s| format!("#{}", s))
+        .unwrap_or_default();
+
+    let filtered = ok_confirmation(action, &pr_num);
+    println!("{}", filtered);
+
+    // Use stdout or pr_num as raw input
+    let raw = if !stdout.trim().is_empty() {
+        stdout
+    } else {
+        pr_num.clone()
+    };
+
+    timer.track(
+        &format!("gh pr {}", subcmd),
+        &format!("rtk gh pr {}", subcmd),
+        &raw,
+        &filtered,
+    );
+    Ok(())
+}
+
+fn run_api(args: &[String], _verbose: u8) -> Result<()> {
+    // gh api is an explicit/advanced command — the user knows what they asked for.
+    // Converting JSON to a schema destroys all values and forces Claude to re-fetch.
+    // Passthrough preserves the full response and tracks metrics at 0% savings.
+    run_passthrough("gh", "api", args)
+}
+
+/// Pass through a command with base args + extra args, tracking as passthrough.
+fn run_passthrough_with_extra(cmd: &str, base_args: &[&str], extra_args: &[String]) -> Result<()> {
+    let timer = tracking::TimedExecution::start();
+
+    let mut command = Command::new(cmd);
+    for arg in base_args {
+        command.arg(arg);
+    }
+    for arg in extra_args {
+        command.arg(arg);
+    }
+
+    let status =
+        command
+            .status()
+            .context(format!("Failed to run {} {}", cmd, base_args.join(" ")))?;
+
+    let full_cmd = format!(
+        "{} {} {}",
+        cmd,
+        base_args.join(" "),
+        tracking::args_display(&extra_args.iter().map(|s| s.into()).collect::<Vec<_>>())
+    );
+    timer.track_passthrough(&full_cmd, &format!("rtk {} (passthrough)", full_cmd));
+
+    if !status.success() {
+        std::process::exit(status.code().unwrap_or(1));
+    }
+
+    Ok(())
+}
+
+fn run_passthrough(cmd: &str, subcommand: &str, args: &[String]) -> Result<()> {
+    let timer = tracking::TimedExecution::start();
+
+    let mut command = Command::new(cmd);
+    command.arg(subcommand);
+    for arg in args {
+        command.arg(arg);
+    }
+
+    let status = command
+        .status()
+        .context(format!("Failed to run {} {}", cmd, subcommand))?;
+
+    let args_str = tracking::args_display(&args.iter().map(|s| s.into()).collect::<Vec<_>>());
+    timer.track_passthrough(
+        &format!("{} {} {}", cmd, subcommand, args_str),
+        &format!("rtk {} {} {} (passthrough)", cmd, subcommand, args_str),
+    );
+
+    if !status.success() {
+        std::process::exit(status.code().unwrap_or(1));
+    }
+
+    Ok(())
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_truncate() {
+        assert_eq!(truncate("short", 10), "short");
+        assert_eq!(
+            truncate("this is a very long string", 15),
+            "this is a ve..."
+        );
+    }
+
+    #[test]
+    fn test_truncate_multibyte_utf8() {
+        // Emoji: 🚀 = 4 bytes, 1 char
+        assert_eq!(truncate("🚀🎉🔥abc", 6), "🚀🎉🔥abc"); // 6 chars, fits
+        assert_eq!(truncate("🚀🎉🔥abcdef", 8), "🚀🎉🔥ab..."); // 10 chars > 8
+                                                                // Edge case: all multibyte
+        assert_eq!(truncate("🚀🎉🔥🌟🎯", 5), "🚀🎉🔥🌟🎯"); // exact fit
+        assert_eq!(truncate("🚀🎉🔥🌟🎯x", 5), "🚀🎉..."); // 6 chars > 5
+    }
+
+    #[test]
+    fn test_truncate_empty_and_short() {
+        assert_eq!(truncate("", 10), "");
+        assert_eq!(truncate("ab", 10), "ab");
+        assert_eq!(truncate("abc", 3), "abc"); // exact fit
+    }
+
+    #[test]
+    fn test_ok_confirmation_pr_create() {
+        let result = ok_confirmation("created", "#42 https://github.com/foo/bar/pull/42");
+        assert!(result.contains("ok created"));
+        assert!(result.contains("#42"));
+    }
+
+    #[test]
+    fn test_ok_confirmation_pr_merge() {
+        let result = ok_confirmation("merged", "#42");
+        assert_eq!(result, "ok merged #42");
+    }
+
+    #[test]
+    fn test_ok_confirmation_pr_comment() {
+        let result = ok_confirmation("commented", "#42");
+        assert_eq!(result, "ok commented #42");
+    }
+
+    #[test]
+    fn test_ok_confirmation_pr_edit() {
+        let result = ok_confirmation("edited", "#42");
+        assert_eq!(result, "ok edited #42");
+    }
+
+    #[test]
+    fn test_has_json_flag_present() {
+        assert!(has_json_flag(&[
+            "view".into(),
+            "--json".into(),
+            "number,url".into()
+        ]));
+    }
+
+    #[test]
+    fn test_has_json_flag_absent() {
+        assert!(!has_json_flag(&["view".into(), "42".into()]));
+    }
+
+    #[test]
+    fn test_extract_identifier_simple() {
+        let args: Vec<String> = vec!["123".into()];
+        let (id, extra) = extract_identifier_and_extra_args(&args).unwrap();
+        assert_eq!(id, "123");
+        assert!(extra.is_empty());
+    }
+
+    #[test]
+    fn test_extract_identifier_with_repo_flag_after() {
+        // gh issue view 185 -R rtk-ai/rtk
+        let args: Vec<String> = vec!["185".into(), "-R".into(), "rtk-ai/rtk".into()];
+        let (id, extra) = extract_identifier_and_extra_args(&args).unwrap();
+        assert_eq!(id, "185");
+        assert_eq!(extra, vec!["-R", "rtk-ai/rtk"]);
+    }
+
+    #[test]
+    fn test_extract_identifier_with_repo_flag_before() {
+        // gh issue view -R rtk-ai/rtk 185
+        let args: Vec<String> = vec!["-R".into(), "rtk-ai/rtk".into(), "185".into()];
+        let (id, extra) = extract_identifier_and_extra_args(&args).unwrap();
+        assert_eq!(id, "185");
+        assert_eq!(extra, vec!["-R", "rtk-ai/rtk"]);
+    }
+
+    #[test]
+    fn test_extract_identifier_with_long_repo_flag() {
+        let args: Vec<String> = vec!["42".into(), "--repo".into(), "owner/repo".into()];
+        let (id, extra) = extract_identifier_and_extra_args(&args).unwrap();
+        assert_eq!(id, "42");
+        assert_eq!(extra, vec!["--repo", "owner/repo"]);
+    }
+
+    #[test]
+    fn test_extract_identifier_empty() {
+        let args: Vec<String> = vec![];
+        assert!(extract_identifier_and_extra_args(&args).is_none());
+    }
+
+    #[test]
+    fn test_extract_identifier_only_flags() {
+        // No positional identifier, only flags
+        let args: Vec<String> = vec!["-R".into(), "rtk-ai/rtk".into()];
+        assert!(extract_identifier_and_extra_args(&args).is_none());
+    }
+
+    #[test]
+    fn test_extract_identifier_with_web_flag() {
+        let args: Vec<String> = vec!["123".into(), "--web".into()];
+        let (id, extra) = extract_identifier_and_extra_args(&args).unwrap();
+        assert_eq!(id, "123");
+        assert_eq!(extra, vec!["--web"]);
+    }
+
+    #[test]
+    fn test_run_view_passthrough_log_failed() {
+        assert!(should_passthrough_run_view(&["--log-failed".into()]));
+    }
+
+    #[test]
+    fn test_run_view_passthrough_log() {
+        assert!(should_passthrough_run_view(&["--log".into()]));
+    }
+
+    #[test]
+    fn test_run_view_passthrough_json() {
+        assert!(should_passthrough_run_view(&[
+            "--json".into(),
+            "jobs".into()
+        ]));
+    }
+
+    #[test]
+    fn test_run_view_no_passthrough_empty() {
+        assert!(!should_passthrough_run_view(&[]));
+    }
+
+    #[test]
+    fn test_run_view_no_passthrough_other_flags() {
+        assert!(!should_passthrough_run_view(&["--web".into()]));
+    }
+
+    #[test]
+    fn test_extract_identifier_with_job_flag_after() {
+        // gh run view 12345 --job 67890
+        let args: Vec<String> = vec!["12345".into(), "--job".into(), "67890".into()];
+        let (id, extra) = extract_identifier_and_extra_args(&args).unwrap();
+        assert_eq!(id, "12345");
+        assert_eq!(extra, vec!["--job", "67890"]);
+    }
+
+    #[test]
+    fn test_extract_identifier_with_job_flag_before() {
+        // gh run view --job 67890 12345
+        let args: Vec<String> = vec!["--job".into(), "67890".into(), "12345".into()];
+        let (id, extra) = extract_identifier_and_extra_args(&args).unwrap();
+        assert_eq!(id, "12345");
+        assert_eq!(extra, vec!["--job", "67890"]);
+    }
+
+    #[test]
+    fn test_extract_identifier_with_job_and_log_failed() {
+        // gh run view --log-failed --job 67890 12345
+        let args: Vec<String> = vec![
+            "--log-failed".into(),
+            "--job".into(),
+            "67890".into(),
+            "12345".into(),
+        ];
+        let (id, extra) = extract_identifier_and_extra_args(&args).unwrap();
+        assert_eq!(id, "12345");
+        assert_eq!(extra, vec!["--log-failed", "--job", "67890"]);
+    }
+
+    #[test]
+    fn test_extract_identifier_with_attempt_flag() {
+        // gh run view 12345 --attempt 3
+        let args: Vec<String> = vec!["12345".into(), "--attempt".into(), "3".into()];
+        let (id, extra) = extract_identifier_and_extra_args(&args).unwrap();
+        assert_eq!(id, "12345");
+        assert_eq!(extra, vec!["--attempt", "3"]);
+    }
+
+    // --- should_passthrough_pr_view tests ---
+
+    #[test]
+    fn test_should_passthrough_pr_view_json() {
+        assert!(should_passthrough_pr_view(&[
+            "--json".into(),
+            "body,comments".into()
+        ]));
+    }
+
+    #[test]
+    fn test_should_passthrough_pr_view_jq() {
+        assert!(should_passthrough_pr_view(&["--jq".into(), ".body".into()]));
+    }
+
+    #[test]
+    fn test_should_passthrough_pr_view_web() {
+        assert!(should_passthrough_pr_view(&["--web".into()]));
+    }
+
+    #[test]
+    fn test_should_passthrough_pr_view_default() {
+        assert!(!should_passthrough_pr_view(&[]));
+    }
+
+    #[test]
+    fn test_should_passthrough_pr_view_other_flags() {
+        assert!(!should_passthrough_pr_view(&["--comments".into()]));
+    }
+
+    // --- filter_markdown_body tests ---
+
+    #[test]
+    fn test_filter_markdown_body_html_comment_single_line() {
+        let input = "Hello\n<!-- this is a comment -->\nWorld";
+        let result = filter_markdown_body(input);
+        assert!(!result.contains("<!--"));
+        assert!(result.contains("Hello"));
+        assert!(result.contains("World"));
+    }
+
+    #[test]
+    fn test_filter_markdown_body_html_comment_multiline() {
+        let input = "Before\n<!--\nmultiline\ncomment\n-->\nAfter";
+        let result = filter_markdown_body(input);
+        assert!(!result.contains("<!--"));
+        assert!(!result.contains("multiline"));
+        assert!(result.contains("Before"));
+        assert!(result.contains("After"));
+    }
+
+    #[test]
+    fn test_filter_markdown_body_badge_lines() {
+        let input = "# Title\n[![CI](https://img.shields.io/badge.svg)](https://github.com/actions)\nSome text";
+        let result = filter_markdown_body(input);
+        assert!(!result.contains("shields.io"));
+        assert!(result.contains("# Title"));
+        assert!(result.contains("Some text"));
+    }
+
+    #[test]
+    fn test_filter_markdown_body_image_only_lines() {
+        let input = "# Title\n![screenshot](https://example.com/img.png)\nSome text";
+        let result = filter_markdown_body(input);
+        assert!(!result.contains("![screenshot]"));
+        assert!(result.contains("# Title"));
+        assert!(result.contains("Some text"));
+    }
+
+    #[test]
+    fn test_filter_markdown_body_horizontal_rules() {
+        let input = "Section 1\n---\nSection 2\n***\nSection 3\n___\nEnd";
+        let result = filter_markdown_body(input);
+        assert!(!result.contains("---"));
+        assert!(!result.contains("***"));
+        assert!(!result.contains("___"));
+        assert!(result.contains("Section 1"));
+        assert!(result.contains("Section 2"));
+        assert!(result.contains("Section 3"));
+    }
+
+    #[test]
+    fn test_filter_markdown_body_blank_lines_collapse() {
+        let input = "Line 1\n\n\n\n\nLine 2";
+        let result = filter_markdown_body(input);
+        // Should collapse to at most one blank line (2 newlines)
+        assert!(!result.contains("\n\n\n"));
+        assert!(result.contains("Line 1"));
+        assert!(result.contains("Line 2"));
+    }
+
+    #[test]
+    fn test_filter_markdown_body_code_block_preserved() {
+        let input = "Text before\n```python\n<!-- not a comment -->\n![not an image](url)\n---\n```\nText after";
+        let result = filter_markdown_body(input);
+        // Content inside code block should be preserved
+        assert!(result.contains("<!-- not a comment -->"));
+        assert!(result.contains("![not an image](url)"));
+        assert!(result.contains("---"));
+        assert!(result.contains("Text before"));
+        assert!(result.contains("Text after"));
+    }
+
+    #[test]
+    fn test_filter_markdown_body_empty() {
+        assert_eq!(filter_markdown_body(""), "");
+    }
+
+    #[test]
+    fn test_filter_markdown_body_meaningful_content_preserved() {
+        let input = "## Summary\n- Item 1\n- Item 2\n\n[Link](https://example.com)\n\n| Col1 | Col2 |\n| --- | --- |\n| a | b |";
+        let result = filter_markdown_body(input);
+        assert!(result.contains("## Summary"));
+        assert!(result.contains("- Item 1"));
+        assert!(result.contains("- Item 2"));
+        assert!(result.contains("[Link](https://example.com)"));
+        assert!(result.contains("| Col1 | Col2 |"));
+    }
+
+    #[test]
+    fn test_filter_markdown_body_token_savings() {
+        // Realistic PR body with noise
+        let input = r#"<!-- This PR template is auto-generated -->
+<!-- Please fill in the following sections -->
+
+## Summary
+
+Added smart markdown filtering for gh issue/pr view commands.
+
+[![CI](https://img.shields.io/github/actions/workflow/status/rtk-ai/rtk/ci.yml)](https://github.com/rtk-ai/rtk/actions)
+[![Coverage](https://img.shields.io/codecov/c/github/rtk-ai/rtk)](https://codecov.io/gh/rtk-ai/rtk)
+
+![screenshot](https://user-images.githubusercontent.com/123/screenshot.png)
+
+---
+
+## Changes
+
+- Filter HTML comments
+- Filter badge lines
+- Filter image-only lines
+- Collapse blank lines
+
+***
+
+## Test Plan
+
+- [x] Unit tests added
+- [x] Snapshot tests pass
+- [ ] Manual testing
+
+___
+
+<!-- Do not edit below this line -->
+<!-- Auto-generated footer -->"#;
+
+        let result = filter_markdown_body(input);
+
+        fn count_tokens(text: &str) -> usize {
+            text.split_whitespace().count()
+        }
+
+        let input_tokens = count_tokens(input);
+        let output_tokens = count_tokens(&result);
+        let savings = 100.0 - (output_tokens as f64 / input_tokens as f64 * 100.0);
+
+        assert!(
+            savings >= 30.0,
+            "Expected ≥30% savings, got {:.1}% (input: {} tokens, output: {} tokens)",
+            savings,
+            input_tokens,
+            output_tokens
+        );
+
+        // Verify meaningful content preserved
+        assert!(result.contains("## Summary"));
+        assert!(result.contains("## Changes"));
+        assert!(result.contains("## Test Plan"));
+        assert!(result.contains("Filter HTML comments"));
+    }
+}