@hasna/terminal 2.2.0 → 2.3.0

package/temp/rtk/src/ruff_cmd.rs

@@ -0,0 +1,402 @@
+use crate::tracking;
+use crate::utils::truncate;
+use anyhow::{Context, Result};
+use serde::Deserialize;
+use std::collections::HashMap;
+use std::process::Command;
+
+#[derive(Debug, Deserialize)]
+struct RuffLocation {
+    row: usize,
+    column: usize,
+}
+
+#[derive(Debug, Deserialize)]
+struct RuffFix {
+    #[allow(dead_code)]
+    applicability: Option<String>,
+}
+
+#[derive(Debug, Deserialize)]
+struct RuffDiagnostic {
+    code: String,
+    message: String,
+    location: RuffLocation,
+    #[allow(dead_code)]
+    end_location: Option<RuffLocation>,
+    filename: String,
+    fix: Option<RuffFix>,
+}
+
+pub fn run(args: &[String], verbose: u8) -> Result<()> {
+    let timer = tracking::TimedExecution::start();
+
+    // Detect subcommand: check, format, or version
+    let is_check = args.is_empty()
+        || args[0] == "check"
+        || (!args[0].starts_with('-') && args[0] != "format" && args[0] != "version");
+
+    let is_format = args.iter().any(|a| a == "format");
+
+    let mut cmd = Command::new("ruff");
+
+    if is_check {
+        // Force JSON output for check command
+        if !args.contains(&"--output-format".to_string()) {
+            cmd.arg("check").arg("--output-format=json");
+        } else {
+            cmd.arg("check");
+        }
+
+        // Add user arguments (skip "check" if it was the first arg)
+        let start_idx = if !args.is_empty() && args[0] == "check" {
+            1
+        } else {
+            0
+        };
+        for arg in &args[start_idx..] {
+            cmd.arg(arg);
+        }
+
+        // Default to current directory if no path specified
+        if args
+            .iter()
+            .skip(start_idx)
+            .all(|a| a.starts_with('-') || a.contains('='))
+        {
+            cmd.arg(".");
+        }
+    } else {
+        // Format or other commands - pass through
+        for arg in args {
+            cmd.arg(arg);
+        }
+    }
+
+    if verbose > 0 {
+        eprintln!("Running: ruff {}", args.join(" "));
+    }
+
+    let output = cmd
+        .output()
+        .context("Failed to run ruff. Is it installed? Try: pip install ruff")?;
+
+    let stdout = String::from_utf8_lossy(&output.stdout);
+    let stderr = String::from_utf8_lossy(&output.stderr);
+    let raw = format!("{}\n{}", stdout, stderr);
+
+    let filtered = if is_check && !stdout.trim().is_empty() {
+        filter_ruff_check_json(&stdout)
+    } else if is_format {
+        filter_ruff_format(&raw)
+    } else {
+        // Fallback for other commands (version, etc.)
+        raw.trim().to_string()
+    };
+
+    println!("{}", filtered);
+
+    timer.track(
+        &format!("ruff {}", args.join(" ")),
+        &format!("rtk ruff {}", args.join(" ")),
+        &raw,
+        &filtered,
+    );
+
+    // Preserve exit code for CI/CD
+    if !output.status.success() {
+        std::process::exit(output.status.code().unwrap_or(1));
+    }
+
+    Ok(())
+}
+
+/// Filter ruff check JSON output - group by rule and file
+pub fn filter_ruff_check_json(output: &str) -> String {
+    let diagnostics: Result<Vec<RuffDiagnostic>, _> = serde_json::from_str(output);
+
+    let diagnostics = match diagnostics {
+        Ok(d) => d,
+        Err(e) => {
+            // Fallback if JSON parsing fails
+            return format!(
+                "Ruff check (JSON parse failed: {})\n{}",
+                e,
+                truncate(output, 500)
+            );
+        }
+    };
+
+    if diagnostics.is_empty() {
+        return "✓ Ruff: No issues found".to_string();
+    }
+
+    let total_issues = diagnostics.len();
+    let fixable_count = diagnostics.iter().filter(|d| d.fix.is_some()).count();
+
+    // Count unique files
+    let unique_files: std::collections::HashSet<_> =
+        diagnostics.iter().map(|d| &d.filename).collect();
+    let total_files = unique_files.len();
+
+    // Group by rule code
+    let mut by_rule: HashMap<String, usize> = HashMap::new();
+    for diag in &diagnostics {
+        *by_rule.entry(diag.code.clone()).or_insert(0) += 1;
+    }
+
+    // Group by file
+    let mut by_file: HashMap<&str, usize> = HashMap::new();
+    for diag in &diagnostics {
+        *by_file.entry(&diag.filename).or_insert(0) += 1;
+    }
+
+    let mut file_counts: Vec<_> = by_file.iter().collect();
+    file_counts.sort_by(|a, b| b.1.cmp(a.1));
+
+    // Build output
+    let mut result = String::new();
+    result.push_str(&format!(
+        "Ruff: {} issues in {} files",
+        total_issues, total_files
+    ));
+
+    if fixable_count > 0 {
+        result.push_str(&format!(" ({} fixable)", fixable_count));
+    }
+    result.push('\n');
+    result.push_str("═══════════════════════════════════════\n");
+
+    // Show top rules
+    let mut rule_counts: Vec<_> = by_rule.iter().collect();
+    rule_counts.sort_by(|a, b| b.1.cmp(a.1));
+
+    if !rule_counts.is_empty() {
+        result.push_str("Top rules:\n");
+        for (rule, count) in rule_counts.iter().take(10) {
+            result.push_str(&format!("  {} ({}x)\n", rule, count));
+        }
+        result.push('\n');
+    }
+
+    // Show top files
+    result.push_str("Top files:\n");
+    for (file, count) in file_counts.iter().take(10) {
+        let short_path = compact_path(file);
+        result.push_str(&format!("  {} ({} issues)\n", short_path, count));
+
+        // Show top 3 rules in this file
+        let mut file_rules: HashMap<String, usize> = HashMap::new();
+        for diag in diagnostics.iter().filter(|d| &d.filename == *file) {
+            *file_rules.entry(diag.code.clone()).or_insert(0) += 1;
+        }
+
+        let mut file_rule_counts: Vec<_> = file_rules.iter().collect();
+        file_rule_counts.sort_by(|a, b| b.1.cmp(a.1));
+
+        for (rule, count) in file_rule_counts.iter().take(3) {
+            result.push_str(&format!("    {} ({})\n", rule, count));
+        }
+    }
+
+    if file_counts.len() > 10 {
+        result.push_str(&format!("\n... +{} more files\n", file_counts.len() - 10));
+    }
+
+    if fixable_count > 0 {
+        result.push_str(&format!(
+            "\n💡 Run `ruff check --fix` to auto-fix {} issues\n",
+            fixable_count
+        ));
+    }
+
+    result.trim().to_string()
+}
+
+/// Filter ruff format output - show files that need formatting
+pub fn filter_ruff_format(output: &str) -> String {
+    let mut files_to_format: Vec<String> = Vec::new();
+    let mut files_checked = 0;
+
+    for line in output.lines() {
+        let trimmed = line.trim();
+        let lower = trimmed.to_lowercase();
+
+        // Count "would reformat" lines (check mode) - case insensitive
+        if lower.contains("would reformat:") {
+            // Extract filename from "Would reformat: path/to/file.py"
+            if let Some(filename) = trimmed.split(':').nth(1) {
+                files_to_format.push(filename.trim().to_string());
+            }
+        }
+
+        // Count total checked files - look for patterns like "3 files left unchanged"
+        if lower.contains("left unchanged") {
+            // Find "X file(s) left unchanged" pattern specifically
+            // Split by comma to handle "2 files would be reformatted, 3 files left unchanged"
+            let parts: Vec<&str> = trimmed.split(',').collect();
+            for part in parts {
+                let part_lower = part.to_lowercase();
+                if part_lower.contains("left unchanged") {
+                    let words: Vec<&str> = part.trim().split_whitespace().collect();
+                    // Look for number before "file" or "files"
+                    for (i, word) in words.iter().enumerate() {
+                        if (word == &"file" || word == &"files") && i > 0 {
+                            if let Ok(count) = words[i - 1].parse::<usize>() {
+                                files_checked = count;
+                                break;
+                            }
+                        }
+                    }
+                    break;
+                }
+            }
+        }
+    }
+
+    let output_lower = output.to_lowercase();
+
+    // Check if all files are formatted
+    if files_to_format.is_empty() && output_lower.contains("left unchanged") {
+        return "✓ Ruff format: All files formatted correctly".to_string();
+    }
+
+    let mut result = String::new();
+
+    if output_lower.contains("would reformat") {
+        // Check mode: show files that need formatting
+        if files_to_format.is_empty() {
+            result.push_str("✓ Ruff format: All files formatted correctly\n");
+        } else {
+            result.push_str(&format!(
+                "Ruff format: {} files need formatting\n",
+                files_to_format.len()
+            ));
+            result.push_str("═══════════════════════════════════════\n");
+
+            for (i, file) in files_to_format.iter().take(10).enumerate() {
+                result.push_str(&format!("{}. {}\n", i + 1, compact_path(file)));
+            }
+
+            if files_to_format.len() > 10 {
+                result.push_str(&format!(
+                    "\n... +{} more files\n",
+                    files_to_format.len() - 10
+                ));
+            }
+
+            if files_checked > 0 {
+                result.push_str(&format!("\n✓ {} files already formatted\n", files_checked));
+            }
+
+            result.push_str("\n💡 Run `ruff format` to format these files\n");
+        }
+    } else {
+        // Write mode or other output - show summary
+        result.push_str(output.trim());
+    }
+
+    result.trim().to_string()
+}
+
+/// Compact file path (remove common prefixes)
+fn compact_path(path: &str) -> String {
+    let path = path.replace('\\', "/");
+
+    if let Some(pos) = path.rfind("/src/") {
+        format!("src/{}", &path[pos + 5..])
+    } else if let Some(pos) = path.rfind("/lib/") {
+        format!("lib/{}", &path[pos + 5..])
+    } else if let Some(pos) = path.rfind("/tests/") {
+        format!("tests/{}", &path[pos + 7..])
+    } else if let Some(pos) = path.rfind('/') {
+        path[pos + 1..].to_string()
+    } else {
+        path
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_filter_ruff_check_no_issues() {
+        let output = "[]";
+        let result = filter_ruff_check_json(output);
+        assert!(result.contains("✓ Ruff"));
+        assert!(result.contains("No issues found"));
+    }
+
+    #[test]
+    fn test_filter_ruff_check_with_issues() {
+        let output = r#"[
+  {
+    "code": "F401",
+    "message": "`os` imported but unused",
+    "location": {"row": 1, "column": 8},
+    "end_location": {"row": 1, "column": 10},
+    "filename": "src/main.py",
+    "fix": {"applicability": "safe"}
+  },
+  {
+    "code": "F401",
+    "message": "`sys` imported but unused",
+    "location": {"row": 2, "column": 8},
+    "end_location": {"row": 2, "column": 11},
+    "filename": "src/main.py",
+    "fix": null
+  },
+  {
+    "code": "E501",
+    "message": "Line too long (100 > 88 characters)",
+    "location": {"row": 10, "column": 89},
+    "end_location": {"row": 10, "column": 100},
+    "filename": "src/utils.py",
+    "fix": null
+  }
+]"#;
+        let result = filter_ruff_check_json(output);
+        assert!(result.contains("3 issues"));
+        assert!(result.contains("2 files"));
+        assert!(result.contains("1 fixable"));
+        assert!(result.contains("F401"));
+        assert!(result.contains("E501"));
+        assert!(result.contains("main.py"));
+        assert!(result.contains("utils.py"));
+    }
+
+    #[test]
+    fn test_filter_ruff_format_all_formatted() {
+        let output = "5 files left unchanged";
+        let result = filter_ruff_format(output);
+        assert!(result.contains("✓ Ruff format"));
+        assert!(result.contains("All files formatted correctly"));
+    }
+
+    #[test]
+    fn test_filter_ruff_format_needs_formatting() {
+        let output = r#"Would reformat: src/main.py
+Would reformat: tests/test_utils.py
+2 files would be reformatted, 3 files left unchanged"#;
+        let result = filter_ruff_format(output);
+        assert!(result.contains("2 files need formatting"));
+        assert!(result.contains("main.py"));
+        assert!(result.contains("test_utils.py"));
+        assert!(result.contains("3 files already formatted"));
+    }
+
+    #[test]
+    fn test_compact_path() {
+        assert_eq!(
+            compact_path("/Users/foo/project/src/main.py"),
+            "src/main.py"
+        );
+        assert_eq!(compact_path("/home/user/app/lib/utils.py"), "lib/utils.py");
+        assert_eq!(
+            compact_path("C:\\Users\\foo\\project\\tests\\test.py"),
+            "tests/test.py"
+        );
+        assert_eq!(compact_path("relative/file.py"), "file.py");
+    }
+}

package/temp/rtk/src/runner.rs

@@ -0,0 +1,271 @@
+use crate::tracking;
+use anyhow::{Context, Result};
+use regex::Regex;
+use std::process::{Command, Stdio};
+
+/// Run a command and filter output to show only errors/warnings
+pub fn run_err(command: &str, verbose: u8) -> Result<()> {
+    let timer = tracking::TimedExecution::start();
+
+    if verbose > 0 {
+        eprintln!("Running: {}", command);
+    }
+
+    let output = if cfg!(target_os = "windows") {
+        Command::new("cmd")
+            .args(["/C", command])
+            .stdout(Stdio::piped())
+            .stderr(Stdio::piped())
+            .output()
+    } else {
+        Command::new("sh")
+            .args(["-c", command])
+            .stdout(Stdio::piped())
+            .stderr(Stdio::piped())
+            .output()
+    }
+    .context("Failed to execute command")?;
+
+    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_errors(&raw);
+    let mut rtk = String::new();
+
+    if filtered.is_empty() {
+        if output.status.success() {
+            rtk.push_str("✅ Command completed successfully (no errors)");
+        } else {
+            rtk.push_str(&format!(
+                "❌ Command failed (exit code: {:?})\n",
+                output.status.code()
+            ));
+            let lines: Vec<&str> = raw.lines().collect();
+            for line in lines.iter().rev().take(10).rev() {
+                rtk.push_str(&format!("  {}\n", line));
+            }
+        }
+    } else {
+        rtk.push_str(&filtered);
+    }
+
+    let exit_code = output
+        .status
+        .code()
+        .unwrap_or(if output.status.success() { 0 } else { 1 });
+    if let Some(hint) = crate::tee::tee_and_hint(&raw, "err", exit_code) {
+        println!("{}\n{}", rtk, hint);
+    } else {
+        println!("{}", rtk);
+    }
+    timer.track(command, "rtk run-err", &raw, &rtk);
+    Ok(())
+}
+
+/// Run tests and show only failures
+pub fn run_test(command: &str, verbose: u8) -> Result<()> {
+    let timer = tracking::TimedExecution::start();
+
+    if verbose > 0 {
+        eprintln!("Running tests: {}", command);
+    }
+
+    let output = if cfg!(target_os = "windows") {
+        Command::new("cmd")
+            .args(["/C", command])
+            .stdout(Stdio::piped())
+            .stderr(Stdio::piped())
+            .output()
+    } else {
+        Command::new("sh")
+            .args(["-c", command])
+            .stdout(Stdio::piped())
+            .stderr(Stdio::piped())
+            .output()
+    }
+    .context("Failed to execute test command")?;
+
+    let stdout = String::from_utf8_lossy(&output.stdout);
+    let stderr = String::from_utf8_lossy(&output.stderr);
+    let raw = format!("{}\n{}", stdout, stderr);
+
+    let exit_code = output
+        .status
+        .code()
+        .unwrap_or(if output.status.success() { 0 } else { 1 });
+    let summary = extract_test_summary(&raw, command);
+    if let Some(hint) = crate::tee::tee_and_hint(&raw, "test", exit_code) {
+        println!("{}\n{}", summary, hint);
+    } else {
+        println!("{}", summary);
+    }
+    timer.track(command, "rtk run-test", &raw, &summary);
+    Ok(())
+}
+
+fn filter_errors(output: &str) -> String {
+    lazy_static::lazy_static! {
+        static ref ERROR_PATTERNS: Vec<Regex> = vec![
+            // Generic errors
+            Regex::new(r"(?i)^.*error[\s:\[].*$").unwrap(),
+            Regex::new(r"(?i)^.*\berr\b.*$").unwrap(),
+            Regex::new(r"(?i)^.*warning[\s:\[].*$").unwrap(),
+            Regex::new(r"(?i)^.*\bwarn\b.*$").unwrap(),
+            Regex::new(r"(?i)^.*failed.*$").unwrap(),
+            Regex::new(r"(?i)^.*failure.*$").unwrap(),
+            Regex::new(r"(?i)^.*exception.*$").unwrap(),
+            Regex::new(r"(?i)^.*panic.*$").unwrap(),
+            // Rust specific
+            Regex::new(r"^error\[E\d+\]:.*$").unwrap(),
+            Regex::new(r"^\s*--> .*:\d+:\d+$").unwrap(),
+            // Python
+            Regex::new(r"^Traceback.*$").unwrap(),
+            Regex::new(r#"^\s*File ".*", line \d+.*$"#).unwrap(),
+            // JavaScript/TypeScript
+            Regex::new(r"^\s*at .*:\d+:\d+.*$").unwrap(),
+            // Go
+            Regex::new(r"^.*\.go:\d+:.*$").unwrap(),
+        ];
+    }
+
+    let mut result = Vec::new();
+    let mut in_error_block = false;
+    let mut blank_count = 0;
+
+    for line in output.lines() {
+        let is_error_line = ERROR_PATTERNS.iter().any(|p| p.is_match(line));
+
+        if is_error_line {
+            in_error_block = true;
+            blank_count = 0;
+            result.push(line.to_string());
+        } else if in_error_block {
+            if line.trim().is_empty() {
+                blank_count += 1;
+                if blank_count >= 2 {
+                    in_error_block = false;
+                } else {
+                    result.push(line.to_string());
+                }
+            } else if line.starts_with(' ') || line.starts_with('\t') {
+                // Continuation of error
+                result.push(line.to_string());
+                blank_count = 0;
+            } else {
+                in_error_block = false;
+            }
+        }
+    }
+
+    result.join("\n")
+}
+
+fn extract_test_summary(output: &str, command: &str) -> String {
+    let mut result = Vec::new();
+    let lines: Vec<&str> = output.lines().collect();
+
+    // Detect test framework
+    let is_cargo = command.contains("cargo test");
+    let is_pytest = command.contains("pytest");
+    let is_jest =
+        command.contains("jest") || command.contains("npm test") || command.contains("yarn test");
+    let is_go = command.contains("go test");
+
+    // Collect failures
+    let mut failures = Vec::new();
+    let mut in_failure = false;
+    let mut failure_lines = Vec::new();
+
+    for line in lines.iter() {
+        // Cargo test
+        if is_cargo {
+            if line.contains("test result:") {
+                result.push(line.to_string());
+            }
+            if line.contains("FAILED") && !line.contains("test result") {
+                failures.push(line.to_string());
+            }
+            if line.starts_with("failures:") {
+                in_failure = true;
+            }
+            if in_failure && line.starts_with("    ") {
+                failure_lines.push(line.to_string());
+            }
+        }
+
+        // Pytest
+        if is_pytest {
+            if line.contains(" passed") || line.contains(" failed") || line.contains(" error") {
+                result.push(line.to_string());
+            }
+            if line.contains("FAILED") {
+                failures.push(line.to_string());
+            }
+        }
+
+        // Jest
+        if is_jest {
+            if line.contains("Tests:") || line.contains("Test Suites:") {
+                result.push(line.to_string());
+            }
+            if line.contains("✕") || line.contains("FAIL") {
+                failures.push(line.to_string());
+            }
+        }
+
+        // Go test
+        if is_go {
+            if line.starts_with("ok") || line.starts_with("FAIL") || line.starts_with("---") {
+                result.push(line.to_string());
+            }
+            if line.contains("FAIL") {
+                failures.push(line.to_string());
+            }
+        }
+    }
+
+    // Build output
+    let mut output = String::new();
+
+    if !failures.is_empty() {
+        output.push_str("❌ FAILURES:\n");
+        for f in failures.iter().take(10) {
+            output.push_str(&format!("  {}\n", f));
+        }
+        if failures.len() > 10 {
+            output.push_str(&format!("  ... +{} more failures\n", failures.len() - 10));
+        }
+        output.push('\n');
+    }
+
+    if !result.is_empty() {
+        output.push_str("📊 SUMMARY:\n");
+        for r in &result {
+            output.push_str(&format!("  {}\n", r));
+        }
+    } else {
+        // Fallback: show last few lines
+        output.push_str("📊 OUTPUT (last 5 lines):\n");
+        let start = lines.len().saturating_sub(5);
+        for line in &lines[start..] {
+            if !line.trim().is_empty() {
+                output.push_str(&format!("  {}\n", line));
+            }
+        }
+    }
+
+    output
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_filter_errors() {
+        let output = "info: compiling\nerror: something failed\n  at line 10\ninfo: done";
+        let filtered = filter_errors(output);
+        assert!(filtered.contains("error"));
+        assert!(!filtered.contains("info"));
+    }
+}