@hasna/terminal 2.0.5 → 2.3.0

package/temp/rtk/src/wc_cmd.rs

@@ -0,0 +1,401 @@
+/// 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

@@ -0,0 +1,260 @@
+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

@@ -0,0 +1,11 @@
+  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

@@ -0,0 +1,31 @@
+[
+  {
+    "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

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