@hasna/terminal 2.3.0 → 2.3.2

package/temp/rtk/src/tree.rs

@@ -1,209 +0,0 @@
-//! tree command - proxy to native tree with token-optimized output
-//!
-//! This module proxies to the native `tree` command and filters the output
-//! to reduce token usage while preserving structure visibility.
-//!
-//! Token optimization: automatically excludes noise directories via -I pattern
-//! unless -a flag is present (respecting user intent).
-
-use crate::tracking;
-use anyhow::{Context, Result};
-use std::process::Command;
-
-/// Noise directories commonly excluded from LLM context
-const NOISE_DIRS: &[&str] = &[
-    "node_modules",
-    ".git",
-    "target",
-    "__pycache__",
-    ".next",
-    "dist",
-    "build",
-    ".cache",
-    ".turbo",
-    ".vercel",
-    ".pytest_cache",
-    ".mypy_cache",
-    ".tox",
-    ".venv",
-    "venv",
-    "env",
-    ".env",
-    "coverage",
-    ".nyc_output",
-    ".DS_Store",
-    "Thumbs.db",
-    ".idea",
-    ".vscode",
-    ".vs",
-    "*.egg-info",
-    ".eggs",
-];
-
-pub fn run(args: &[String], verbose: u8) -> Result<()> {
-    let timer = tracking::TimedExecution::start();
-
-    // Check if tree is installed
-    let tree_check = Command::new("which").arg("tree").output();
-    if tree_check.is_err() || !tree_check.unwrap().status.success() {
-        anyhow::bail!(
-            "tree command not found. Install it first:\n\
-             - macOS: brew install tree\n\
-             - Ubuntu/Debian: sudo apt install tree\n\
-             - Fedora/RHEL: sudo dnf install tree\n\
-             - Arch: sudo pacman -S tree"
-        );
-    }
-
-    let mut cmd = Command::new("tree");
-
-    // Determine if user wants all files or default behavior
-    let show_all = args.iter().any(|a| a == "-a" || a == "--all");
-    let has_ignore = args.iter().any(|a| a == "-I" || a.starts_with("--ignore="));
-
-    // Auto-inject -I pattern unless user wants all or already specified -I
-    if !show_all && !has_ignore {
-        let ignore_pattern = NOISE_DIRS.join("|");
-        cmd.arg("-I").arg(&ignore_pattern);
-    }
-
-    // Pass all user args
-    for arg in args {
-        cmd.arg(arg);
-    }
-
-    let output = cmd.output().context("Failed to run tree")?;
-
-    if !output.status.success() {
-        let stderr = String::from_utf8_lossy(&output.stderr);
-        eprint!("{}", stderr);
-        std::process::exit(output.status.code().unwrap_or(1));
-    }
-
-    let raw = String::from_utf8_lossy(&output.stdout).to_string();
-    let filtered = filter_tree_output(&raw);
-
-    if verbose > 0 {
-        eprintln!(
-            "Lines: {} → {} ({}% reduction)",
-            raw.lines().count(),
-            filtered.lines().count(),
-            if raw.lines().count() > 0 {
-                100 - (filtered.lines().count() * 100 / raw.lines().count())
-            } else {
-                0
-            }
-        );
-    }
-
-    print!("{}", filtered);
-    timer.track("tree", "rtk tree", &raw, &filtered);
-
-    Ok(())
-}
-
-fn filter_tree_output(raw: &str) -> String {
-    let lines: Vec<&str> = raw.lines().collect();
-
-    if lines.is_empty() {
-        return "\n".to_string();
-    }
-
-    let mut filtered_lines = Vec::new();
-
-    for line in lines {
-        // Skip the final summary line (e.g., "5 directories, 23 files")
-        if line.contains("director") && line.contains("file") {
-            continue;
-        }
-
-        // Skip empty lines at the end
-        if line.trim().is_empty() && filtered_lines.is_empty() {
-            continue;
-        }
-
-        filtered_lines.push(line);
-    }
-
-    // Remove trailing empty lines
-    while filtered_lines.last().map_or(false, |l| l.trim().is_empty()) {
-        filtered_lines.pop();
-    }
-
-    filtered_lines.join("\n") + "\n"
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-
-    #[test]
-    fn test_filter_removes_summary() {
-        let input = ".\n├── src\n│   └── main.rs\n└── Cargo.toml\n\n2 directories, 3 files\n";
-        let output = filter_tree_output(input);
-        assert!(!output.contains("directories"));
-        assert!(!output.contains("files"));
-        assert!(output.contains("main.rs"));
-        assert!(output.contains("Cargo.toml"));
-    }
-
-    #[test]
-    fn test_filter_preserves_structure() {
-        let input = ".\n├── src\n│   ├── main.rs\n│   └── lib.rs\n└── tests\n    └── test.rs\n";
-        let output = filter_tree_output(input);
-        assert!(output.contains("├──"));
-        assert!(output.contains("│"));
-        assert!(output.contains("└──"));
-        assert!(output.contains("main.rs"));
-        assert!(output.contains("test.rs"));
-    }
-
-    #[test]
-    fn test_filter_handles_empty() {
-        let input = "";
-        let output = filter_tree_output(input);
-        assert_eq!(output, "\n");
-    }
-
-    #[test]
-    fn test_filter_removes_trailing_empty_lines() {
-        let input = ".\n├── file.txt\n\n\n";
-        let output = filter_tree_output(input);
-        assert_eq!(output.matches('\n').count(), 2); // Root + file.txt + final newline
-    }
-
-    #[test]
-    fn test_filter_summary_variations() {
-        // Test different summary formats
-        let inputs = vec![
-            (".\n└── file.txt\n\n0 directories, 1 file\n", "1 file"),
-            (".\n└── file.txt\n\n1 directory, 0 files\n", "1 directory"),
-            (".\n└── file.txt\n\n10 directories, 25 files\n", "25 files"),
-        ];
-
-        for (input, summary_fragment) in inputs {
-            let output = filter_tree_output(input);
-            assert!(
-                !output.contains(summary_fragment),
-                "Should remove summary '{}' from output",
-                summary_fragment
-            );
-            assert!(
-                output.contains("file.txt"),
-                "Should preserve file.txt in output"
-            );
-        }
-    }
-
-    #[test]
-    fn test_noise_dirs_constant() {
-        // Verify NOISE_DIRS contains expected patterns
-        assert!(NOISE_DIRS.contains(&"node_modules"));
-        assert!(NOISE_DIRS.contains(&".git"));
-        assert!(NOISE_DIRS.contains(&"target"));
-        assert!(NOISE_DIRS.contains(&"__pycache__"));
-        assert!(NOISE_DIRS.contains(&".next"));
-        assert!(NOISE_DIRS.contains(&"dist"));
-        assert!(NOISE_DIRS.contains(&"build"));
-    }
-}

package/temp/rtk/src/tsc_cmd.rs

@@ -1,259 +0,0 @@
-use crate::tracking;
-use crate::utils::truncate;
-use anyhow::{Context, Result};
-use regex::Regex;
-use std::collections::HashMap;
-use std::process::Command;
-
-pub fn run(args: &[String], verbose: u8) -> Result<()> {
-    let timer = tracking::TimedExecution::start();
-
-    // Try tsc directly first, fallback to npx if not found
-    let tsc_exists = Command::new("which")
-        .arg("tsc")
-        .output()
-        .map(|o| o.status.success())
-        .unwrap_or(false);
-
-    let mut cmd = if tsc_exists {
-        Command::new("tsc")
-    } else {
-        let mut c = Command::new("npx");
-        c.arg("tsc");
-        c
-    };
-
-    for arg in args {
-        cmd.arg(arg);
-    }
-
-    if verbose > 0 {
-        let tool = if tsc_exists { "tsc" } else { "npx tsc" };
-        eprintln!("Running: {} {}", tool, args.join(" "));
-    }
-
-    let output = cmd
-        .output()
-        .context("Failed to run tsc (try: npm install -g typescript)")?;
-    let stdout = String::from_utf8_lossy(&output.stdout);
-    let stderr = String::from_utf8_lossy(&output.stderr);
-    let raw = format!("{}\n{}", stdout, stderr);
-
-    let filtered = filter_tsc_output(&raw);
-
-    let exit_code = output.status.code().unwrap_or(1);
-    if let Some(hint) = crate::tee::tee_and_hint(&raw, "tsc", exit_code) {
-        println!("{}\n{}", filtered, hint);
-    } else {
-        println!("{}", filtered);
-    }
-
-    timer.track(
-        &format!("tsc {}", args.join(" ")),
-        &format!("rtk tsc {}", args.join(" ")),
-        &raw,
-        &filtered,
-    );
-
-    // Preserve tsc exit code for CI/CD compatibility
-    std::process::exit(exit_code);
-}
-
-/// Filter TypeScript compiler output - group errors by file, show every error
-fn filter_tsc_output(output: &str) -> String {
-    lazy_static::lazy_static! {
-        // Pattern: src/file.ts(12,5): error TS2322: Type 'string' is not assignable to type 'number'.
-        static ref TSC_ERROR: Regex = Regex::new(
-            r"^(.+?)\((\d+),(\d+)\):\s+(error|warning)\s+(TS\d+):\s+(.+)$"
-        ).unwrap();
-    }
-
-    struct TsError {
-        file: String,
-        line: usize,
-        code: String,
-        message: String,
-        context_lines: Vec<String>,
-    }
-
-    let mut errors: Vec<TsError> = Vec::new();
-    let lines: Vec<&str> = output.lines().collect();
-    let mut i = 0;
-
-    while i < lines.len() {
-        let line = lines[i];
-        if let Some(caps) = TSC_ERROR.captures(line) {
-            let mut err = TsError {
-                file: caps[1].to_string(),
-                line: caps[2].parse().unwrap_or(0),
-                code: caps[5].to_string(),
-                message: caps[6].to_string(),
-                context_lines: Vec::new(),
-            };
-
-            // Capture continuation lines (indented context from tsc)
-            i += 1;
-            while i < lines.len() {
-                let next = lines[i];
-                if !next.is_empty()
-                    && (next.starts_with("  ") || next.starts_with('\t'))
-                    && !TSC_ERROR.is_match(next)
-                {
-                    err.context_lines.push(next.trim().to_string());
-                    i += 1;
-                } else {
-                    break;
-                }
-            }
-
-            errors.push(err);
-        } else {
-            i += 1;
-        }
-    }
-
-    if errors.is_empty() {
-        if output.contains("Found 0 errors") {
-            return "✓ TypeScript: No errors found".to_string();
-        }
-        return "TypeScript compilation completed".to_string();
-    }
-
-    // Group by file
-    let mut by_file: HashMap<String, Vec<&TsError>> = HashMap::new();
-    for err in &errors {
-        by_file.entry(err.file.clone()).or_default().push(err);
-    }
-
-    // Count by error code for summary
-    let mut by_code: HashMap<String, usize> = HashMap::new();
-    for err in &errors {
-        *by_code.entry(err.code.clone()).or_insert(0) += 1;
-    }
-
-    let mut result = String::new();
-    result.push_str(&format!(
-        "TypeScript: {} errors in {} files\n",
-        errors.len(),
-        by_file.len()
-    ));
-    result.push_str("═══════════════════════════════════════\n");
-
-    // Top error codes summary (compact, one line)
-    let mut code_counts: Vec<_> = by_code.iter().collect();
-    code_counts.sort_by(|a, b| b.1.cmp(a.1));
-
-    if code_counts.len() > 1 {
-        let codes_str: Vec<String> = code_counts
-            .iter()
-            .take(5)
-            .map(|(code, count)| format!("{} ({}x)", code, count))
-            .collect();
-        result.push_str(&format!("Top codes: {}\n\n", codes_str.join(", ")));
-    }
-
-    // Files sorted by error count (most errors first)
-    let mut files_sorted: Vec<_> = by_file.iter().collect();
-    files_sorted.sort_by(|a, b| b.1.len().cmp(&a.1.len()));
-
-    // Show every error per file — no limits
-    for (file, file_errors) in &files_sorted {
-        result.push_str(&format!("{} ({} errors)\n", file, file_errors.len()));
-
-        for err in *file_errors {
-            result.push_str(&format!(
-                "  L{}: {} {}\n",
-                err.line,
-                err.code,
-                truncate(&err.message, 120)
-            ));
-            for ctx in &err.context_lines {
-                result.push_str(&format!("    {}\n", truncate(ctx, 120)));
-            }
-        }
-        result.push('\n');
-    }
-
-    result.trim().to_string()
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-
-    #[test]
-    fn test_filter_tsc_output() {
-        let output = r#"
-src/server/api/auth.ts(12,5): error TS2322: Type 'string' is not assignable to type 'number'.
-src/server/api/auth.ts(15,10): error TS2345: Argument of type 'number' is not assignable to parameter of type 'string'.
-src/components/Button.tsx(8,3): error TS2339: Property 'onClick' does not exist on type 'ButtonProps'.
-src/components/Button.tsx(10,5): error TS2322: Type 'string' is not assignable to type 'number'.
-
-Found 4 errors in 2 files.
-"#;
-        let result = filter_tsc_output(output);
-        assert!(result.contains("TypeScript: 4 errors in 2 files"));
-        assert!(result.contains("auth.ts (2 errors)"));
-        assert!(result.contains("Button.tsx (2 errors)"));
-        assert!(result.contains("TS2322"));
-        assert!(!result.contains("Found 4 errors")); // Summary line should be replaced
-    }
-
-    #[test]
-    fn test_every_error_message_shown() {
-        let output = "\
-src/api.ts(10,5): error TS2322: Type 'string' is not assignable to type 'number'.
-src/api.ts(20,5): error TS2322: Type 'boolean' is not assignable to type 'string'.
-src/api.ts(30,5): error TS2322: Type 'null' is not assignable to type 'object'.
-";
-        let result = filter_tsc_output(output);
-        // Each error message must be individually visible, not collapsed
-        assert!(result.contains("Type 'string' is not assignable to type 'number'"));
-        assert!(result.contains("Type 'boolean' is not assignable to type 'string'"));
-        assert!(result.contains("Type 'null' is not assignable to type 'object'"));
-        assert!(result.contains("L10:"));
-        assert!(result.contains("L20:"));
-        assert!(result.contains("L30:"));
-    }
-
-    #[test]
-    fn test_continuation_lines_preserved() {
-        let output = "\
-src/app.tsx(10,3): error TS2322: Type '{ children: Element; }' is not assignable to type 'Props'.
-  Property 'children' does not exist on type 'Props'.
-src/app.tsx(20,5): error TS2345: Argument of type 'number' is not assignable to parameter of type 'string'.
-";
-        let result = filter_tsc_output(output);
-        assert!(result.contains("Property 'children' does not exist on type 'Props'"));
-        assert!(result.contains("L10:"));
-        assert!(result.contains("L20:"));
-    }
-
-    #[test]
-    fn test_no_file_limit() {
-        // 15 files with errors — all must appear
-        let mut output = String::new();
-        for i in 1..=15 {
-            output.push_str(&format!(
-                "src/file{}.ts({},1): error TS2322: Error in file {}.\n",
-                i, i, i
-            ));
-        }
-        let result = filter_tsc_output(&output);
-        assert!(result.contains("15 errors in 15 files"));
-        for i in 1..=15 {
-            assert!(
-                result.contains(&format!("file{}.ts", i)),
-                "file{}.ts missing from output",
-                i
-            );
-        }
-    }
-
-    #[test]
-    fn test_filter_no_errors() {
-        let output = "Found 0 errors. Watching for file changes.";
-        let result = filter_tsc_output(output);
-        assert!(result.contains("No errors found"));
-    }
-}