@hasna/terminal 2.3.0 → 2.3.2

package/temp/rtk/src/wc_cmd.rs

@@ -1,401 +0,0 @@
-/// Compact filter for `wc` — strips redundant paths and alignment padding.
-///
-/// Compression examples:
-/// - `wc file.py`     → `30L 96W 978B`
-/// - `wc -l file.py`  → `30`
-/// - `wc -w file.py`  → `96`
-/// - `wc -c file.py`  → `978`
-/// - `wc -l *.py`     → table with common path prefix stripped
-use crate::tracking;
-use anyhow::{Context, Result};
-use std::process::Command;
-
-pub fn run(args: &[String], verbose: u8) -> Result<()> {
-    let timer = tracking::TimedExecution::start();
-
-    let mut cmd = Command::new("wc");
-    for arg in args {
-        cmd.arg(arg);
-    }
-
-    if verbose > 0 {
-        eprintln!("Running: wc {}", args.join(" "));
-    }
-
-    let output = cmd.output().context("Failed to run wc")?;
-    let stdout = String::from_utf8_lossy(&output.stdout);
-    let stderr = String::from_utf8_lossy(&output.stderr);
-
-    if !output.status.success() {
-        let msg = if stderr.trim().is_empty() {
-            stdout.trim().to_string()
-        } else {
-            stderr.trim().to_string()
-        };
-        eprintln!("FAILED: wc {}", msg);
-        std::process::exit(output.status.code().unwrap_or(1));
-    }
-
-    let raw = stdout.to_string();
-
-    // Detect which columns the user requested
-    let mode = detect_mode(args);
-    let filtered = filter_wc_output(&raw, &mode);
-    println!("{}", filtered);
-
-    timer.track(
-        &format!("wc {}", args.join(" ")),
-        &format!("rtk wc {}", args.join(" ")),
-        &raw,
-        &filtered,
-    );
-
-    Ok(())
-}
-
-/// Which columns the user requested
-#[derive(Debug, PartialEq)]
-enum WcMode {
-    /// Default: lines, words, bytes (3 columns)
-    Full,
-    /// Lines only (-l)
-    Lines,
-    /// Words only (-w)
-    Words,
-    /// Bytes only (-c)
-    Bytes,
-    /// Chars only (-m)
-    Chars,
-    /// Multiple flags combined — keep compact format
-    Mixed,
-}
-
-fn detect_mode(args: &[String]) -> WcMode {
-    let flags: Vec<&str> = args
-        .iter()
-        .filter(|a| a.starts_with('-'))
-        .map(|s| s.as_str())
-        .collect();
-
-    if flags.is_empty() {
-        return WcMode::Full;
-    }
-
-    // Collect all single-char flags (handles combined flags like -lw)
-    let mut has_l = false;
-    let mut has_w = false;
-    let mut has_c = false;
-    let mut has_m = false;
-    let mut flag_count = 0;
-
-    for flag in &flags {
-        for ch in flag.chars().skip(1) {
-            match ch {
-                'l' => {
-                    has_l = true;
-                    flag_count += 1;
-                }
-                'w' => {
-                    has_w = true;
-                    flag_count += 1;
-                }
-                'c' => {
-                    has_c = true;
-                    flag_count += 1;
-                }
-                'm' => {
-                    has_m = true;
-                    flag_count += 1;
-                }
-                _ => {}
-            }
-        }
-    }
-
-    if flag_count == 0 {
-        return WcMode::Full;
-    }
-    if flag_count > 1 {
-        return WcMode::Mixed;
-    }
-
-    if has_l {
-        WcMode::Lines
-    } else if has_w {
-        WcMode::Words
-    } else if has_c {
-        WcMode::Bytes
-    } else if has_m {
-        WcMode::Chars
-    } else {
-        WcMode::Full
-    }
-}
-
-fn filter_wc_output(raw: &str, mode: &WcMode) -> String {
-    let lines: Vec<&str> = raw.trim().lines().collect();
-
-    if lines.is_empty() {
-        return String::new();
-    }
-
-    // Single file (one output line, no "total")
-    if lines.len() == 1 {
-        return format_single_line(lines[0], mode);
-    }
-
-    // Multiple files — compact table
-    format_multi_line(&lines, mode)
-}
-
-/// Format a single wc output line (one file or stdin)
-fn format_single_line(line: &str, mode: &WcMode) -> String {
-    let parts: Vec<&str> = line.split_whitespace().collect();
-
-    match mode {
-        WcMode::Lines | WcMode::Words | WcMode::Bytes | WcMode::Chars => {
-            // First number is the only requested column
-            parts.first().map(|s| s.to_string()).unwrap_or_default()
-        }
-        WcMode::Full => {
-            if parts.len() >= 3 {
-                format!("{}L {}W {}B", parts[0], parts[1], parts[2])
-            } else {
-                line.trim().to_string()
-            }
-        }
-        WcMode::Mixed => {
-            // Strip file path, keep numbers only
-            if parts.len() >= 2 {
-                let last_is_path = parts.last().map_or(false, |p| p.parse::<u64>().is_err());
-                if last_is_path {
-                    parts[..parts.len() - 1].join(" ")
-                } else {
-                    parts.join(" ")
-                }
-            } else {
-                line.trim().to_string()
-            }
-        }
-    }
-}
-
-/// Format multiple files as a compact table
-fn format_multi_line(lines: &[&str], mode: &WcMode) -> String {
-    let mut result = Vec::new();
-
-    // Find common directory prefix to shorten paths
-    let paths: Vec<&str> = lines
-        .iter()
-        .filter_map(|line| {
-            let parts: Vec<&str> = line.split_whitespace().collect();
-            parts.last().copied()
-        })
-        .filter(|p| *p != "total")
-        .collect();
-
-    let common_prefix = find_common_prefix(&paths);
-
-    for line in lines {
-        let parts: Vec<&str> = line.split_whitespace().collect();
-        if parts.is_empty() {
-            continue;
-        }
-
-        let is_total = parts.last().map_or(false, |p| *p == "total");
-
-        match mode {
-            WcMode::Lines | WcMode::Words | WcMode::Bytes | WcMode::Chars => {
-                if is_total {
-                    result.push(format!("Σ {}", parts.first().unwrap_or(&"0")));
-                } else {
-                    let name = strip_prefix(parts.last().unwrap_or(&""), &common_prefix);
-                    result.push(format!("{} {}", parts.first().unwrap_or(&"0"), name));
-                }
-            }
-            WcMode::Full => {
-                if is_total {
-                    result.push(format!(
-                        "Σ {}L {}W {}B",
-                        parts.first().unwrap_or(&"0"),
-                        parts.get(1).unwrap_or(&"0"),
-                        parts.get(2).unwrap_or(&"0"),
-                    ));
-                } else if parts.len() >= 4 {
-                    let name = strip_prefix(parts[3], &common_prefix);
-                    result.push(format!(
-                        "{}L {}W {}B {}",
-                        parts[0], parts[1], parts[2], name
-                    ));
-                } else {
-                    result.push(line.trim().to_string());
-                }
-            }
-            WcMode::Mixed => {
-                if is_total {
-                    let nums: Vec<&str> = parts[..parts.len() - 1].to_vec();
-                    result.push(format!("Σ {}", nums.join(" ")));
-                } else if parts.len() >= 2 {
-                    let last_is_path = parts.last().map_or(false, |p| p.parse::<u64>().is_err());
-                    if last_is_path {
-                        let name = strip_prefix(parts.last().unwrap_or(&""), &common_prefix);
-                        let nums: Vec<&str> = parts[..parts.len() - 1].to_vec();
-                        result.push(format!("{} {}", nums.join(" "), name));
-                    } else {
-                        result.push(parts.join(" "));
-                    }
-                } else {
-                    result.push(line.trim().to_string());
-                }
-            }
-        }
-    }
-
-    result.join("\n")
-}
-
-/// Find common directory prefix among paths
-fn find_common_prefix(paths: &[&str]) -> String {
-    if paths.len() <= 1 {
-        return String::new();
-    }
-
-    let first = paths[0];
-    let prefix = if let Some(pos) = first.rfind('/') {
-        &first[..=pos]
-    } else {
-        return String::new();
-    };
-
-    if paths.iter().all(|p| p.starts_with(prefix)) {
-        return prefix.to_string();
-    }
-
-    // Try shorter prefixes by removing right-most segments
-    let mut candidate = prefix.to_string();
-    while !candidate.is_empty() {
-        if paths.iter().all(|p| p.starts_with(&candidate)) {
-            return candidate;
-        }
-        if let Some(pos) = candidate[..candidate.len() - 1].rfind('/') {
-            candidate.truncate(pos + 1);
-        } else {
-            return String::new();
-        }
-    }
-    String::new()
-}
-
-/// Strip common prefix from a path
-fn strip_prefix<'a>(path: &'a str, prefix: &str) -> &'a str {
-    if prefix.is_empty() {
-        return path;
-    }
-    path.strip_prefix(prefix).unwrap_or(path)
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-
-    #[test]
-    fn test_single_file_full() {
-        let raw = "      30      96     978 scripts/find_duplicate_attrs.py\n";
-        let result = filter_wc_output(raw, &WcMode::Full);
-        assert_eq!(result, "30L 96W 978B");
-    }
-
-    #[test]
-    fn test_single_file_lines_only() {
-        let raw = "      30 scripts/find_duplicate_attrs.py\n";
-        let result = filter_wc_output(raw, &WcMode::Lines);
-        assert_eq!(result, "30");
-    }
-
-    #[test]
-    fn test_single_file_words_only() {
-        let raw = "      96 scripts/find_duplicate_attrs.py\n";
-        let result = filter_wc_output(raw, &WcMode::Words);
-        assert_eq!(result, "96");
-    }
-
-    #[test]
-    fn test_stdin_full() {
-        let raw = "      30      96     978\n";
-        let result = filter_wc_output(raw, &WcMode::Full);
-        assert_eq!(result, "30L 96W 978B");
-    }
-
-    #[test]
-    fn test_stdin_lines() {
-        let raw = "      30\n";
-        let result = filter_wc_output(raw, &WcMode::Lines);
-        assert_eq!(result, "30");
-    }
-
-    #[test]
-    fn test_multi_file_lines() {
-        let raw = "      30 src/main.rs\n      50 src/lib.rs\n      80 total\n";
-        let result = filter_wc_output(raw, &WcMode::Lines);
-        assert_eq!(result, "30 main.rs\n50 lib.rs\nΣ 80");
-    }
-
-    #[test]
-    fn test_multi_file_full() {
-        let raw = "      30      96     978 src/main.rs\n      50     120    1500 src/lib.rs\n      80     216    2478 total\n";
-        let result = filter_wc_output(raw, &WcMode::Full);
-        assert_eq!(
-            result,
-            "30L 96W 978B main.rs\n50L 120W 1500B lib.rs\nΣ 80L 216W 2478B"
-        );
-    }
-
-    #[test]
-    fn test_detect_mode_full() {
-        let args: Vec<String> = vec!["file.py".into()];
-        assert_eq!(detect_mode(&args), WcMode::Full);
-    }
-
-    #[test]
-    fn test_detect_mode_lines() {
-        let args: Vec<String> = vec!["-l".into(), "file.py".into()];
-        assert_eq!(detect_mode(&args), WcMode::Lines);
-    }
-
-    #[test]
-    fn test_detect_mode_mixed() {
-        let args: Vec<String> = vec!["-lw".into(), "file.py".into()];
-        assert_eq!(detect_mode(&args), WcMode::Mixed);
-    }
-
-    #[test]
-    fn test_detect_mode_separate_flags() {
-        let args: Vec<String> = vec!["-l".into(), "-w".into(), "file.py".into()];
-        assert_eq!(detect_mode(&args), WcMode::Mixed);
-    }
-
-    #[test]
-    fn test_common_prefix() {
-        let paths = vec!["src/main.rs", "src/lib.rs", "src/utils.rs"];
-        assert_eq!(find_common_prefix(&paths), "src/");
-    }
-
-    #[test]
-    fn test_no_common_prefix() {
-        let paths = vec!["main.rs", "lib.rs"];
-        assert_eq!(find_common_prefix(&paths), "");
-    }
-
-    #[test]
-    fn test_deep_common_prefix() {
-        let paths = vec!["src/cmd/wc.rs", "src/cmd/ls.rs"];
-        assert_eq!(find_common_prefix(&paths), "src/cmd/");
-    }
-
-    #[test]
-    fn test_empty() {
-        let raw = "";
-        let result = filter_wc_output(raw, &WcMode::Full);
-        assert_eq!(result, "");
-    }
-}

package/temp/rtk/src/wget_cmd.rs

@@ -1,260 +0,0 @@
-use crate::tracking;
-use anyhow::{Context, Result};
-use std::process::Command;
-
-/// Compact wget - strips progress bars, shows only result
-pub fn run(url: &str, args: &[String], verbose: u8) -> Result<()> {
-    let timer = tracking::TimedExecution::start();
-
-    if verbose > 0 {
-        eprintln!("wget: {}", url);
-    }
-
-    // Run wget normally but capture output to parse it
-    let mut cmd_args: Vec<&str> = vec![];
-
-    // Add user args
-    for arg in args {
-        cmd_args.push(arg);
-    }
-    cmd_args.push(url);
-
-    let output = Command::new("wget")
-        .args(&cmd_args)
-        .output()
-        .context("Failed to run wget")?;
-
-    let stderr = String::from_utf8_lossy(&output.stderr);
-    let stdout = String::from_utf8_lossy(&output.stdout);
-
-    let raw_output = format!("{}\n{}", stderr, stdout);
-
-    if output.status.success() {
-        let filename = extract_filename_from_output(&stderr, url, args);
-        let size = get_file_size(&filename);
-        let msg = format!(
-            "⬇️ {} ok | {} | {}",
-            compact_url(url),
-            filename,
-            format_size(size)
-        );
-        println!("{}", msg);
-        timer.track(&format!("wget {}", url), "rtk wget", &raw_output, &msg);
-    } else {
-        let error = parse_error(&stderr, &stdout);
-        let msg = format!("⬇️ {} FAILED: {}", compact_url(url), error);
-        println!("{}", msg);
-        timer.track(&format!("wget {}", url), "rtk wget", &raw_output, &msg);
-    }
-
-    Ok(())
-}
-
-/// Run wget and output to stdout (for piping)
-pub fn run_stdout(url: &str, args: &[String], verbose: u8) -> Result<()> {
-    let timer = tracking::TimedExecution::start();
-
-    if verbose > 0 {
-        eprintln!("wget: {} -> stdout", url);
-    }
-
-    let mut cmd_args = vec!["-q", "-O", "-"];
-    for arg in args {
-        cmd_args.push(arg);
-    }
-    cmd_args.push(url);
-
-    let output = Command::new("wget")
-        .args(&cmd_args)
-        .output()
-        .context("Failed to run wget")?;
-
-    if output.status.success() {
-        let content = String::from_utf8_lossy(&output.stdout);
-        let lines: Vec<&str> = content.lines().collect();
-        let total = lines.len();
-        let raw_output = content.to_string();
-
-        let mut rtk_output = String::new();
-        if total > 20 {
-            rtk_output.push_str(&format!(
-                "⬇️ {} ok | {} lines | {}\n",
-                compact_url(url),
-                total,
-                format_size(output.stdout.len() as u64)
-            ));
-            rtk_output.push_str("--- first 10 lines ---\n");
-            for line in lines.iter().take(10) {
-                rtk_output.push_str(&format!("{}\n", truncate_line(line, 100)));
-            }
-            rtk_output.push_str(&format!("... +{} more lines", total - 10));
-        } else {
-            rtk_output.push_str(&format!("⬇️ {} ok | {} lines\n", compact_url(url), total));
-            for line in &lines {
-                rtk_output.push_str(&format!("{}\n", line));
-            }
-        }
-        print!("{}", rtk_output);
-        timer.track(
-            &format!("wget -O - {}", url),
-            "rtk wget -o",
-            &raw_output,
-            &rtk_output,
-        );
-    } else {
-        let stderr = String::from_utf8_lossy(&output.stderr);
-        let error = parse_error(&stderr, "");
-        let msg = format!("⬇️ {} FAILED: {}", compact_url(url), error);
-        println!("{}", msg);
-        timer.track(&format!("wget -O - {}", url), "rtk wget -o", &stderr, &msg);
-    }
-
-    Ok(())
-}
-
-fn extract_filename_from_output(stderr: &str, url: &str, args: &[String]) -> String {
-    // Check for -O argument first
-    for (i, arg) in args.iter().enumerate() {
-        if arg == "-O" || arg == "--output-document" {
-            if let Some(name) = args.get(i + 1) {
-                return name.clone();
-            }
-        }
-        if let Some(name) = arg.strip_prefix("-O") {
-            return name.to_string();
-        }
-    }
-
-    // Parse wget output for "Sauvegarde en" or "Saving to"
-    for line in stderr.lines() {
-        // French: Sauvegarde en : « filename »
-        if line.contains("Sauvegarde en") || line.contains("Saving to") {
-            // Use char-based parsing to handle Unicode properly
-            let chars: Vec<char> = line.chars().collect();
-            let mut start_idx = None;
-            let mut end_idx = None;
-
-            for (i, c) in chars.iter().enumerate() {
-                if *c == '«' || (*c == '\'' && start_idx.is_none()) {
-                    start_idx = Some(i);
-                }
-                if *c == '»' || (*c == '\'' && start_idx.is_some()) {
-                    end_idx = Some(i);
-                }
-            }
-
-            if let (Some(s), Some(e)) = (start_idx, end_idx) {
-                if e > s + 1 {
-                    let filename: String = chars[s + 1..e].iter().collect();
-                    return filename.trim().to_string();
-                }
-            }
-        }
-    }
-
-    // Fallback: extract from URL
-    let path = url.rsplit("://").next().unwrap_or(url);
-    let filename = path
-        .rsplit('/')
-        .next()
-        .unwrap_or("index.html")
-        .split('?')
-        .next()
-        .unwrap_or("index.html");
-
-    if filename.is_empty() || !filename.contains('.') {
-        "index.html".to_string()
-    } else {
-        filename.to_string()
-    }
-}
-
-fn get_file_size(filename: &str) -> u64 {
-    std::fs::metadata(filename).map(|m| m.len()).unwrap_or(0)
-}
-
-fn format_size(bytes: u64) -> String {
-    if bytes == 0 {
-        return "?".to_string();
-    }
-    if bytes < 1024 {
-        format!("{}B", bytes)
-    } else if bytes < 1024 * 1024 {
-        format!("{:.1}KB", bytes as f64 / 1024.0)
-    } else if bytes < 1024 * 1024 * 1024 {
-        format!("{:.1}MB", bytes as f64 / (1024.0 * 1024.0))
-    } else {
-        format!("{:.1}GB", bytes as f64 / (1024.0 * 1024.0 * 1024.0))
-    }
-}
-
-fn compact_url(url: &str) -> String {
-    // Remove protocol
-    let without_proto = url
-        .strip_prefix("https://")
-        .or_else(|| url.strip_prefix("http://"))
-        .unwrap_or(url);
-
-    // Truncate if too long
-    let chars: Vec<char> = without_proto.chars().collect();
-    if chars.len() <= 50 {
-        without_proto.to_string()
-    } else {
-        let prefix: String = chars[..25].iter().collect();
-        let suffix: String = chars[chars.len() - 20..].iter().collect();
-        format!("{}...{}", prefix, suffix)
-    }
-}
-
-fn parse_error(stderr: &str, stdout: &str) -> String {
-    // Common wget error patterns
-    let combined = format!("{}\n{}", stderr, stdout);
-
-    if combined.contains("404") {
-        return "404 Not Found".to_string();
-    }
-    if combined.contains("403") {
-        return "403 Forbidden".to_string();
-    }
-    if combined.contains("401") {
-        return "401 Unauthorized".to_string();
-    }
-    if combined.contains("500") {
-        return "500 Server Error".to_string();
-    }
-    if combined.contains("Connection refused") {
-        return "Connection refused".to_string();
-    }
-    if combined.contains("unable to resolve") || combined.contains("Name or service not known") {
-        return "DNS lookup failed".to_string();
-    }
-    if combined.contains("timed out") {
-        return "Connection timed out".to_string();
-    }
-    if combined.contains("SSL") || combined.contains("certificate") {
-        return "SSL/TLS error".to_string();
-    }
-
-    // Return first meaningful line
-    for line in stderr.lines() {
-        let trimmed = line.trim();
-        if !trimmed.is_empty() && !trimmed.starts_with("--") {
-            if trimmed.len() > 60 {
-                let t: String = trimmed.chars().take(60).collect();
-                return format!("{}...", t);
-            }
-            return trimmed.to_string();
-        }
-    }
-
-    "Unknown error".to_string()
-}
-
-fn truncate_line(line: &str, max: usize) -> String {
-    if line.len() <= max {
-        line.to_string()
-    } else {
-        let t: String = line.chars().take(max.saturating_sub(3)).collect();
-        format!("{}...", t)
-    }
-}

package/temp/rtk/tests/fixtures/dotnet/build_failed.txt

@@ -1,11 +0,0 @@
-  Determining projects to restore...
-  All projects are up-to-date for restore.
-/private/tmp/RtkDotnetSmoke/Broken.cs(7,17): error CS1525: Invalid expression term ';' [/private/tmp/RtkDotnetSmoke/RtkDotnetSmoke.csproj]
-
-Build FAILED.
-
-/private/tmp/RtkDotnetSmoke/Broken.cs(7,17): error CS1525: Invalid expression term ';' [/private/tmp/RtkDotnetSmoke/RtkDotnetSmoke.csproj]
-    0 Warning(s)
-    1 Error(s)
-
-Time Elapsed 00:00:00.76

package/temp/rtk/tests/fixtures/dotnet/format_changes.json

@@ -1,31 +0,0 @@
-[
-  {
-    "FileName": "Program.cs",
-    "FilePath": "src/Program.cs",
-    "FileChanges": [
-      {
-        "LineNumber": 42,
-        "CharNumber": 17,
-        "DiagnosticId": "WHITESPACE",
-        "FormatDescription": "Fix whitespace"
-      }
-    ]
-  },
-  {
-    "FileName": "Utils.cs",
-    "FilePath": "src/Utils.cs",
-    "FileChanges": [
-      {
-        "LineNumber": 15,
-        "CharNumber": 8,
-        "DiagnosticId": "IDE0055",
-        "FormatDescription": "Fix formatting"
-      }
-    ]
-  },
-  {
-    "FileName": "Tests.cs",
-    "FilePath": "tests/Tests.cs",
-    "FileChanges": []
-  }
-]

package/temp/rtk/tests/fixtures/dotnet/format_empty.json

@@ -1 +0,0 @@
-[]