@hasna/terminal 2.3.0 → 2.3.2

package/temp/rtk/src/lint_cmd.rs

@@ -1,694 +0,0 @@
-use crate::mypy_cmd;
-use crate::ruff_cmd;
-use crate::tracking;
-use crate::utils::{package_manager_exec, truncate};
-use anyhow::{Context, Result};
-use regex::Regex;
-use serde::{Deserialize, Serialize};
-use std::collections::HashMap;
-use std::process::Command;
-
-#[derive(Debug, Deserialize, Serialize)]
-struct EslintMessage {
-    #[serde(rename = "ruleId")]
-    rule_id: Option<String>,
-    severity: u8,
-    message: String,
-    line: usize,
-    column: usize,
-}
-
-#[derive(Debug, Deserialize, Serialize)]
-struct EslintResult {
-    #[serde(rename = "filePath")]
-    file_path: String,
-    messages: Vec<EslintMessage>,
-    #[serde(rename = "errorCount")]
-    error_count: usize,
-    #[serde(rename = "warningCount")]
-    warning_count: usize,
-}
-
-#[derive(Debug, Deserialize)]
-struct PylintDiagnostic {
-    #[serde(rename = "type")]
-    msg_type: String, // "warning", "error", "convention", "refactor"
-    #[allow(dead_code)]
-    module: String,
-    #[allow(dead_code)]
-    obj: String,
-    line: usize,
-    #[allow(dead_code)]
-    column: usize,
-    path: String,
-    symbol: String, // rule code like "unused-variable"
-    message: String,
-    #[serde(rename = "message-id")]
-    message_id: String, // e.g., "W0612"
-}
-
-/// Check if a linter is Python-based (uses pip/pipx, not npm/pnpm)
-fn is_python_linter(linter: &str) -> bool {
-    matches!(linter, "ruff" | "pylint" | "mypy" | "flake8")
-}
-
-/// Strip package manager prefixes (npx, bunx, pnpm, pnpm exec, yarn) from args.
-/// Returns the number of args to skip.
-fn strip_pm_prefix(args: &[String]) -> usize {
-    let pm_names = ["npx", "bunx", "pnpm", "yarn"];
-    let mut skip = 0;
-    for arg in args {
-        if pm_names.contains(&arg.as_str()) || arg == "exec" {
-            skip += 1;
-        } else {
-            break;
-        }
-    }
-    skip
-}
-
-/// Detect the linter name from args (after stripping PM prefixes).
-/// Returns the linter name and whether it was explicitly specified.
-fn detect_linter(args: &[String]) -> (&str, bool) {
-    let is_path_or_flag = args.is_empty()
-        || args[0].starts_with('-')
-        || args[0].contains('/')
-        || args[0].contains('.');
-
-    if is_path_or_flag {
-        ("eslint", false)
-    } else {
-        (&args[0], true)
-    }
-}
-
-pub fn run(args: &[String], verbose: u8) -> Result<()> {
-    let timer = tracking::TimedExecution::start();
-
-    let skip = strip_pm_prefix(args);
-    let effective_args = &args[skip..];
-
-    let (linter, explicit) = detect_linter(effective_args);
-
-    // Python linters use Command::new() directly (they're on PATH via pip/pipx)
-    // JS linters use package_manager_exec (npx/pnpm exec)
-    let mut cmd = if is_python_linter(linter) {
-        Command::new(linter)
-    } else {
-        package_manager_exec(linter)
-    };
-
-    // Add format flags based on linter
-    match linter {
-        "eslint" => {
-            cmd.arg("-f").arg("json");
-        }
-        "ruff" => {
-            // Force JSON output for ruff check
-            if !effective_args.contains(&"--output-format".to_string()) {
-                cmd.arg("check").arg("--output-format=json");
-            }
-        }
-        "pylint" => {
-            // Force JSON2 output for pylint
-            if !effective_args.contains(&"--output-format".to_string()) {
-                cmd.arg("--output-format=json2");
-            }
-        }
-        "mypy" => {
-            // mypy uses default text output (no special flags)
-        }
-        _ => {
-            // Other linters: no special formatting
-        }
-    }
-
-    // Add user arguments (skip first if it was the linter name, and skip "check" for ruff if we added it)
-    let start_idx = if !explicit {
-        0
-    } else if linter == "ruff" && !effective_args.is_empty() && effective_args[0] == "ruff" {
-        // Skip "ruff" and "check" if we already added "check"
-        if effective_args.len() > 1 && effective_args[1] == "check" {
-            2
-        } else {
-            1
-        }
-    } else {
-        1
-    };
-
-    for arg in &effective_args[start_idx..] {
-        // Skip --output-format if we already added it
-        if linter == "ruff" && arg.starts_with("--output-format") {
-            continue;
-        }
-        if linter == "pylint" && arg.starts_with("--output-format") {
-            continue;
-        }
-        cmd.arg(arg);
-    }
-
-    // Default to current directory if no path specified (for ruff/pylint/mypy/eslint)
-    if matches!(linter, "ruff" | "pylint" | "mypy" | "eslint") {
-        let has_path = effective_args
-            .iter()
-            .skip(start_idx)
-            .any(|a| !a.starts_with('-') && !a.contains('='));
-        if !has_path {
-            cmd.arg(".");
-        }
-    }
-
-    if verbose > 0 {
-        eprintln!("Running: {} with structured output", linter);
-    }
-
-    let output = cmd.output().context(format!(
-        "Failed to run {}. Is it installed? Try: pip install {} (or npm/pnpm for JS linters)",
-        linter, linter
-    ))?;
-
-    // Check if process was killed by signal (SIGABRT, SIGKILL, etc.)
-    if !output.status.success() && output.status.code().is_none() {
-        let stderr = String::from_utf8_lossy(&output.stderr);
-        eprintln!("⚠️  Linter process terminated abnormally (possibly out of memory)");
-        if !stderr.is_empty() {
-            eprintln!(
-                "stderr: {}",
-                stderr.lines().take(5).collect::<Vec<_>>().join("\n")
-            );
-        }
-        return Ok(());
-    }
-
-    let stdout = String::from_utf8_lossy(&output.stdout);
-    let stderr = String::from_utf8_lossy(&output.stderr);
-    let raw = format!("{}\n{}", stdout, stderr);
-
-    // Dispatch to appropriate filter based on linter
-    let filtered = match linter {
-        "eslint" => filter_eslint_json(&stdout),
-        "ruff" => {
-            // Reuse ruff_cmd's JSON parser
-            if !stdout.trim().is_empty() {
-                ruff_cmd::filter_ruff_check_json(&stdout)
-            } else {
-                "✓ Ruff: No issues found".to_string()
-            }
-        }
-        "pylint" => filter_pylint_json(&stdout),
-        "mypy" => mypy_cmd::filter_mypy_output(&raw),
-        _ => filter_generic_lint(&raw),
-    };
-
-    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, "lint", exit_code) {
-        println!("{}\n{}", filtered, hint);
-    } else {
-        println!("{}", filtered);
-    }
-
-    timer.track(
-        &format!("{} {}", linter, args.join(" ")),
-        &format!("rtk lint {} {}", linter, args.join(" ")),
-        &raw,
-        &filtered,
-    );
-
-    if !output.status.success() {
-        std::process::exit(output.status.code().unwrap_or(1));
-    }
-
-    Ok(())
-}
-
-/// Filter ESLint JSON output - group by rule and file
-fn filter_eslint_json(output: &str) -> String {
-    let results: Result<Vec<EslintResult>, _> = serde_json::from_str(output);
-
-    let results = match results {
-        Ok(r) => r,
-        Err(e) => {
-            // Fallback if JSON parsing fails
-            return format!(
-                "ESLint output (JSON parse failed: {})\n{}",
-                e,
-                truncate(output, 500)
-            );
-        }
-    };
-
-    // Count total issues
-    let total_errors: usize = results.iter().map(|r| r.error_count).sum();
-    let total_warnings: usize = results.iter().map(|r| r.warning_count).sum();
-    let total_files = results.iter().filter(|r| !r.messages.is_empty()).count();
-
-    if total_errors == 0 && total_warnings == 0 {
-        return "✓ ESLint: No issues found".to_string();
-    }
-
-    // Group messages by rule
-    let mut by_rule: HashMap<String, usize> = HashMap::new();
-    for result in &results {
-        for msg in &result.messages {
-            if let Some(rule) = &msg.rule_id {
-                *by_rule.entry(rule.clone()).or_insert(0) += 1;
-            }
-        }
-    }
-
-    // Group by file
-    let mut by_file: Vec<(&EslintResult, usize)> = results
-        .iter()
-        .filter(|r| !r.messages.is_empty())
-        .map(|r| (r, r.messages.len()))
-        .collect();
-    by_file.sort_by(|a, b| b.1.cmp(&a.1));
-
-    // Build output
-    let mut result = String::new();
-    result.push_str(&format!(
-        "ESLint: {} errors, {} warnings in {} files\n",
-        total_errors, total_warnings, total_files
-    ));
-    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 with most issues
-    result.push_str("Top files:\n");
-    for (file_result, count) in by_file.iter().take(10) {
-        let short_path = compact_path(&file_result.file_path);
-        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 msg in &file_result.messages {
-            if let Some(rule) = &msg.rule_id {
-                *file_rules.entry(rule.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 by_file.len() > 10 {
-        result.push_str(&format!("\n... +{} more files\n", by_file.len() - 10));
-    }
-
-    result.trim().to_string()
-}
-
-/// Filter pylint JSON2 output - group by symbol and file
-fn filter_pylint_json(output: &str) -> String {
-    let diagnostics: Result<Vec<PylintDiagnostic>, _> = serde_json::from_str(output);
-
-    let diagnostics = match diagnostics {
-        Ok(d) => d,
-        Err(e) => {
-            // Fallback if JSON parsing fails
-            return format!(
-                "Pylint output (JSON parse failed: {})\n{}",
-                e,
-                truncate(output, 500)
-            );
-        }
-    };
-
-    if diagnostics.is_empty() {
-        return "✓ Pylint: No issues found".to_string();
-    }
-
-    // Count by type
-    let mut errors = 0;
-    let mut warnings = 0;
-    let mut conventions = 0;
-    let mut refactors = 0;
-
-    for diag in &diagnostics {
-        match diag.msg_type.as_str() {
-            "error" => errors += 1,
-            "warning" => warnings += 1,
-            "convention" => conventions += 1,
-            "refactor" => refactors += 1,
-            _ => {}
-        }
-    }
-
-    // Count unique files
-    let unique_files: std::collections::HashSet<_> = diagnostics.iter().map(|d| &d.path).collect();
-    let total_files = unique_files.len();
-
-    // Group by symbol (rule code)
-    let mut by_symbol: HashMap<String, usize> = HashMap::new();
-    for diag in &diagnostics {
-        let key = format!("{} ({})", diag.symbol, diag.message_id);
-        *by_symbol.entry(key).or_insert(0) += 1;
-    }
-
-    // Group by file
-    let mut by_file: HashMap<&str, usize> = HashMap::new();
-    for diag in &diagnostics {
-        *by_file.entry(&diag.path).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!(
-        "Pylint: {} issues in {} files\n",
-        diagnostics.len(),
-        total_files
-    ));
-
-    if errors > 0 || warnings > 0 {
-        result.push_str(&format!("  {} errors, {} warnings", errors, warnings));
-        if conventions > 0 || refactors > 0 {
-            result.push_str(&format!(
-                ", {} conventions, {} refactors",
-                conventions, refactors
-            ));
-        }
-        result.push('\n');
-    }
-
-    result.push_str("═══════════════════════════════════════\n");
-
-    // Show top symbols (rules)
-    let mut symbol_counts: Vec<_> = by_symbol.iter().collect();
-    symbol_counts.sort_by(|a, b| b.1.cmp(a.1));
-
-    if !symbol_counts.is_empty() {
-        result.push_str("Top rules:\n");
-        for (symbol, count) in symbol_counts.iter().take(10) {
-            result.push_str(&format!("  {} ({}x)\n", symbol, 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_symbols: HashMap<String, usize> = HashMap::new();
-        for diag in diagnostics.iter().filter(|d| &d.path == *file) {
-            let key = format!("{} ({})", diag.symbol, diag.message_id);
-            *file_symbols.entry(key).or_insert(0) += 1;
-        }
-
-        let mut file_symbol_counts: Vec<_> = file_symbols.iter().collect();
-        file_symbol_counts.sort_by(|a, b| b.1.cmp(a.1));
-
-        for (symbol, count) in file_symbol_counts.iter().take(3) {
-            result.push_str(&format!("    {} ({})\n", symbol, count));
-        }
-    }
-
-    if file_counts.len() > 10 {
-        result.push_str(&format!("\n... +{} more files\n", file_counts.len() - 10));
-    }
-
-    result.trim().to_string()
-}
-
-/// Filter generic linter output (fallback for non-ESLint linters)
-fn filter_generic_lint(output: &str) -> String {
-    let mut warnings = 0;
-    let mut errors = 0;
-    let mut issues: Vec<String> = Vec::new();
-
-    for line in output.lines() {
-        let line_lower = line.to_lowercase();
-        if line_lower.contains("warning") {
-            warnings += 1;
-            issues.push(line.to_string());
-        }
-        if line_lower.contains("error") && !line_lower.contains("0 error") {
-            errors += 1;
-            issues.push(line.to_string());
-        }
-    }
-
-    if errors == 0 && warnings == 0 {
-        return "✓ Lint: No issues found".to_string();
-    }
-
-    let mut result = String::new();
-    result.push_str(&format!("Lint: {} errors, {} warnings\n", errors, warnings));
-    result.push_str("═══════════════════════════════════════\n");
-
-    for issue in issues.iter().take(20) {
-        result.push_str(&format!("{}\n", truncate(issue, 100)));
-    }
-
-    if issues.len() > 20 {
-        result.push_str(&format!("\n... +{} more issues\n", issues.len() - 20));
-    }
-
-    result.trim().to_string()
-}
-
-/// Compact file path (remove common prefixes)
-fn compact_path(path: &str) -> String {
-    // Remove common prefixes like /Users/..., /home/..., C:\
-    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('/') {
-        path[pos + 1..].to_string()
-    } else {
-        path
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-
-    #[test]
-    fn test_filter_eslint_json() {
-        let json = r#"[
-            {
-                "filePath": "/Users/test/project/src/utils.ts",
-                "messages": [
-                    {
-                        "ruleId": "prefer-const",
-                        "severity": 1,
-                        "message": "Use const instead of let",
-                        "line": 10,
-                        "column": 5
-                    },
-                    {
-                        "ruleId": "prefer-const",
-                        "severity": 1,
-                        "message": "Use const instead of let",
-                        "line": 15,
-                        "column": 5
-                    }
-                ],
-                "errorCount": 0,
-                "warningCount": 2
-            },
-            {
-                "filePath": "/Users/test/project/src/api.ts",
-                "messages": [
-                    {
-                        "ruleId": "@typescript-eslint/no-unused-vars",
-                        "severity": 2,
-                        "message": "Variable x is unused",
-                        "line": 20,
-                        "column": 10
-                    }
-                ],
-                "errorCount": 1,
-                "warningCount": 0
-            }
-        ]"#;
-
-        let result = filter_eslint_json(json);
-        assert!(result.contains("ESLint:"));
-        assert!(result.contains("prefer-const"));
-        assert!(result.contains("no-unused-vars"));
-        assert!(result.contains("src/utils.ts"));
-    }
-
-    #[test]
-    fn test_compact_path() {
-        assert_eq!(
-            compact_path("/Users/foo/project/src/utils.ts"),
-            "src/utils.ts"
-        );
-        assert_eq!(
-            compact_path("C:\\Users\\project\\src\\api.ts"),
-            "src/api.ts"
-        );
-        assert_eq!(compact_path("simple.ts"), "simple.ts");
-    }
-
-    #[test]
-    fn test_filter_pylint_json_no_issues() {
-        let output = "[]";
-        let result = filter_pylint_json(output);
-        assert!(result.contains("✓ Pylint"));
-        assert!(result.contains("No issues found"));
-    }
-
-    #[test]
-    fn test_filter_pylint_json_with_issues() {
-        let json = r#"[
-            {
-                "type": "warning",
-                "module": "main",
-                "obj": "",
-                "line": 10,
-                "column": 0,
-                "path": "src/main.py",
-                "symbol": "unused-variable",
-                "message": "Unused variable 'x'",
-                "message-id": "W0612"
-            },
-            {
-                "type": "warning",
-                "module": "main",
-                "obj": "foo",
-                "line": 15,
-                "column": 4,
-                "path": "src/main.py",
-                "symbol": "unused-variable",
-                "message": "Unused variable 'y'",
-                "message-id": "W0612"
-            },
-            {
-                "type": "error",
-                "module": "utils",
-                "obj": "bar",
-                "line": 20,
-                "column": 0,
-                "path": "src/utils.py",
-                "symbol": "undefined-variable",
-                "message": "Undefined variable 'z'",
-                "message-id": "E0602"
-            }
-        ]"#;
-
-        let result = filter_pylint_json(json);
-        assert!(result.contains("3 issues"));
-        assert!(result.contains("2 files"));
-        assert!(result.contains("1 errors, 2 warnings"));
-        assert!(result.contains("unused-variable (W0612)"));
-        assert!(result.contains("undefined-variable (E0602)"));
-        assert!(result.contains("main.py"));
-        assert!(result.contains("utils.py"));
-    }
-
-    #[test]
-    fn test_strip_pm_prefix_npx() {
-        let args: Vec<String> = vec!["npx".into(), "eslint".into(), "src/".into()];
-        assert_eq!(strip_pm_prefix(&args), 1);
-    }
-
-    #[test]
-    fn test_strip_pm_prefix_bunx() {
-        let args: Vec<String> = vec!["bunx".into(), "eslint".into(), ".".into()];
-        assert_eq!(strip_pm_prefix(&args), 1);
-    }
-
-    #[test]
-    fn test_strip_pm_prefix_pnpm_exec() {
-        let args: Vec<String> = vec!["pnpm".into(), "exec".into(), "eslint".into()];
-        assert_eq!(strip_pm_prefix(&args), 2);
-    }
-
-    #[test]
-    fn test_strip_pm_prefix_none() {
-        let args: Vec<String> = vec!["eslint".into(), "src/".into()];
-        assert_eq!(strip_pm_prefix(&args), 0);
-    }
-
-    #[test]
-    fn test_strip_pm_prefix_empty() {
-        let args: Vec<String> = vec![];
-        assert_eq!(strip_pm_prefix(&args), 0);
-    }
-
-    #[test]
-    fn test_detect_linter_eslint() {
-        let args: Vec<String> = vec!["eslint".into(), "src/".into()];
-        let (linter, explicit) = detect_linter(&args);
-        assert_eq!(linter, "eslint");
-        assert!(explicit);
-    }
-
-    #[test]
-    fn test_detect_linter_default_on_path() {
-        let args: Vec<String> = vec!["src/".into()];
-        let (linter, explicit) = detect_linter(&args);
-        assert_eq!(linter, "eslint");
-        assert!(!explicit);
-    }
-
-    #[test]
-    fn test_detect_linter_default_on_flag() {
-        let args: Vec<String> = vec!["--max-warnings=0".into()];
-        let (linter, explicit) = detect_linter(&args);
-        assert_eq!(linter, "eslint");
-        assert!(!explicit);
-    }
-
-    #[test]
-    fn test_detect_linter_after_npx_strip() {
-        // Simulates: rtk lint npx eslint src/ → after strip_pm_prefix, args = ["eslint", "src/"]
-        let full_args: Vec<String> = vec!["npx".into(), "eslint".into(), "src/".into()];
-        let skip = strip_pm_prefix(&full_args);
-        let effective = &full_args[skip..];
-        let (linter, _) = detect_linter(effective);
-        assert_eq!(linter, "eslint");
-    }
-
-    #[test]
-    fn test_detect_linter_after_pnpm_exec_strip() {
-        let full_args: Vec<String> =
-            vec!["pnpm".into(), "exec".into(), "biome".into(), "check".into()];
-        let skip = strip_pm_prefix(&full_args);
-        let effective = &full_args[skip..];
-        let (linter, _) = detect_linter(effective);
-        assert_eq!(linter, "biome");
-    }
-
-    #[test]
-    fn test_is_python_linter() {
-        assert!(is_python_linter("ruff"));
-        assert!(is_python_linter("pylint"));
-        assert!(is_python_linter("mypy"));
-        assert!(is_python_linter("flake8"));
-        assert!(!is_python_linter("eslint"));
-        assert!(!is_python_linter("biome"));
-        assert!(!is_python_linter("unknown"));
-    }
-}