@hasna/terminal 2.0.5 → 2.3.0

package/temp/rtk/src/golangci_cmd.rs

@@ -0,0 +1,254 @@
+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 Position {
+    #[serde(rename = "Filename")]
+    filename: String,
+    #[serde(rename = "Line")]
+    line: usize,
+    #[serde(rename = "Column")]
+    column: usize,
+}
+
+#[derive(Debug, Deserialize)]
+struct Issue {
+    #[serde(rename = "FromLinter")]
+    from_linter: String,
+    #[serde(rename = "Text")]
+    text: String,
+    #[serde(rename = "Pos")]
+    pos: Position,
+}
+
+#[derive(Debug, Deserialize)]
+struct GolangciOutput {
+    #[serde(rename = "Issues")]
+    issues: Vec<Issue>,
+}
+
+pub fn run(args: &[String], verbose: u8) -> Result<()> {
+    let timer = tracking::TimedExecution::start();
+
+    let mut cmd = Command::new("golangci-lint");
+
+    // Force JSON output
+    let has_format = args
+        .iter()
+        .any(|a| a == "--out-format" || a.starts_with("--out-format="));
+
+    if !has_format {
+        cmd.arg("run").arg("--out-format=json");
+    } else {
+        cmd.arg("run");
+    }
+
+    for arg in args {
+        cmd.arg(arg);
+    }
+
+    if verbose > 0 {
+        eprintln!("Running: golangci-lint run --out-format=json");
+    }
+
+    let output = cmd.output().context(
+        "Failed to run golangci-lint. Is it installed? Try: go install github.com/golangci/golangci-lint/cmd/golangci-lint@latest",
+    )?;
+
+    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_golangci_json(&stdout);
+
+    println!("{}", filtered);
+
+    // Include stderr if present (config errors, etc.)
+    if !stderr.trim().is_empty() && verbose > 0 {
+        eprintln!("{}", stderr.trim());
+    }
+
+    timer.track(
+        &format!("golangci-lint {}", args.join(" ")),
+        &format!("rtk golangci-lint {}", args.join(" ")),
+        &raw,
+        &filtered,
+    );
+
+    // golangci-lint returns exit code 1 when issues found (expected behavior)
+    // Don't exit with error code in that case
+    Ok(())
+}
+
+/// Filter golangci-lint JSON output - group by linter and file
+fn filter_golangci_json(output: &str) -> String {
+    let result: Result<GolangciOutput, _> = serde_json::from_str(output);
+
+    let golangci_output = match result {
+        Ok(o) => o,
+        Err(e) => {
+            // Fallback if JSON parsing fails
+            return format!(
+                "golangci-lint (JSON parse failed: {})\n{}",
+                e,
+                truncate(output, 500)
+            );
+        }
+    };
+
+    let issues = golangci_output.issues;
+
+    if issues.is_empty() {
+        return "✓ golangci-lint: No issues found".to_string();
+    }
+
+    let total_issues = issues.len();
+
+    // Count unique files
+    let unique_files: std::collections::HashSet<_> =
+        issues.iter().map(|i| &i.pos.filename).collect();
+    let total_files = unique_files.len();
+
+    // Group by linter
+    let mut by_linter: HashMap<String, usize> = HashMap::new();
+    for issue in &issues {
+        *by_linter.entry(issue.from_linter.clone()).or_insert(0) += 1;
+    }
+
+    // Group by file
+    let mut by_file: HashMap<&str, usize> = HashMap::new();
+    for issue in &issues {
+        *by_file.entry(&issue.pos.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!(
+        "golangci-lint: {} issues in {} files\n",
+        total_issues, total_files
+    ));
+    result.push_str("═══════════════════════════════════════\n");
+
+    // Show top linters
+    let mut linter_counts: Vec<_> = by_linter.iter().collect();
+    linter_counts.sort_by(|a, b| b.1.cmp(a.1));
+
+    if !linter_counts.is_empty() {
+        result.push_str("Top linters:\n");
+        for (linter, count) in linter_counts.iter().take(10) {
+            result.push_str(&format!("  {} ({}x)\n", linter, 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 linters in this file
+        let mut file_linters: HashMap<String, usize> = HashMap::new();
+        for issue in issues.iter().filter(|i| &i.pos.filename == *file) {
+            *file_linters.entry(issue.from_linter.clone()).or_insert(0) += 1;
+        }
+
+        let mut file_linter_counts: Vec<_> = file_linters.iter().collect();
+        file_linter_counts.sort_by(|a, b| b.1.cmp(a.1));
+
+        for (linter, count) in file_linter_counts.iter().take(3) {
+            result.push_str(&format!("    {} ({})\n", linter, count));
+        }
+    }
+
+    if file_counts.len() > 10 {
+        result.push_str(&format!("\n... +{} more files\n", file_counts.len() - 10));
+    }
+
+    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("/pkg/") {
+        format!("pkg/{}", &path[pos + 5..])
+    } else if let Some(pos) = path.rfind("/cmd/") {
+        format!("cmd/{}", &path[pos + 5..])
+    } else if let Some(pos) = path.rfind("/internal/") {
+        format!("internal/{}", &path[pos + 10..])
+    } else if let Some(pos) = path.rfind('/') {
+        path[pos + 1..].to_string()
+    } else {
+        path
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_filter_golangci_no_issues() {
+        let output = r#"{"Issues":[]}"#;
+        let result = filter_golangci_json(output);
+        assert!(result.contains("✓ golangci-lint"));
+        assert!(result.contains("No issues found"));
+    }
+
+    #[test]
+    fn test_filter_golangci_with_issues() {
+        let output = r#"{
+  "Issues": [
+    {
+      "FromLinter": "errcheck",
+      "Text": "Error return value not checked",
+      "Pos": {"Filename": "main.go", "Line": 42, "Column": 5}
+    },
+    {
+      "FromLinter": "errcheck",
+      "Text": "Error return value not checked",
+      "Pos": {"Filename": "main.go", "Line": 50, "Column": 10}
+    },
+    {
+      "FromLinter": "gosimple",
+      "Text": "Should use strings.Contains",
+      "Pos": {"Filename": "utils.go", "Line": 15, "Column": 2}
+    }
+  ]
+}"#;
+
+        let result = filter_golangci_json(output);
+        assert!(result.contains("3 issues"));
+        assert!(result.contains("2 files"));
+        assert!(result.contains("errcheck"));
+        assert!(result.contains("gosimple"));
+        assert!(result.contains("main.go"));
+        assert!(result.contains("utils.go"));
+    }
+
+    #[test]
+    fn test_compact_path() {
+        assert_eq!(
+            compact_path("/Users/foo/project/pkg/handler/server.go"),
+            "pkg/handler/server.go"
+        );
+        assert_eq!(
+            compact_path("/home/user/app/cmd/main/main.go"),
+            "cmd/main/main.go"
+        );
+        assert_eq!(
+            compact_path("/project/internal/config/loader.go"),
+            "internal/config/loader.go"
+        );
+        assert_eq!(compact_path("relative/file.go"), "file.go");
+    }
+}

package/temp/rtk/src/grep_cmd.rs

@@ -0,0 +1,288 @@
+use crate::tracking;
+use anyhow::{Context, Result};
+use regex::Regex;
+use std::collections::HashMap;
+use std::process::Command;
+
+pub fn run(
+    pattern: &str,
+    path: &str,
+    max_line_len: usize,
+    max_results: usize,
+    context_only: bool,
+    file_type: Option<&str>,
+    extra_args: &[String],
+    verbose: u8,
+) -> Result<()> {
+    let timer = tracking::TimedExecution::start();
+
+    if verbose > 0 {
+        eprintln!("grep: '{}' in {}", pattern, path);
+    }
+
+    // Fix: convert BRE alternation \| → | for rg (which uses PCRE-style regex)
+    let rg_pattern = pattern.replace(r"\|", "|");
+
+    let mut rg_cmd = Command::new("rg");
+    rg_cmd.args(["-n", "--no-heading", &rg_pattern, path]);
+
+    if let Some(ft) = file_type {
+        rg_cmd.arg("--type").arg(ft);
+    }
+
+    for arg in extra_args {
+        // Fix: skip grep-ism -r flag (rg is recursive by default; rg -r means --replace)
+        if arg == "-r" || arg == "--recursive" {
+            continue;
+        }
+        rg_cmd.arg(arg);
+    }
+
+    let output = rg_cmd
+        .output()
+        .or_else(|_| Command::new("grep").args(["-rn", pattern, path]).output())
+        .context("grep/rg failed")?;
+
+    let stdout = String::from_utf8_lossy(&output.stdout);
+    let exit_code = output.status.code().unwrap_or(1);
+
+    let raw_output = stdout.to_string();
+
+    if stdout.trim().is_empty() {
+        // Show stderr for errors (bad regex, missing file, etc.)
+        if exit_code == 2 {
+            let stderr = String::from_utf8_lossy(&output.stderr);
+            if !stderr.trim().is_empty() {
+                eprintln!("{}", stderr.trim());
+            }
+        }
+        let msg = format!("🔍 0 for '{}'", pattern);
+        println!("{}", msg);
+        timer.track(
+            &format!("grep -rn '{}' {}", pattern, path),
+            "rtk grep",
+            &raw_output,
+            &msg,
+        );
+        if exit_code != 0 {
+            std::process::exit(exit_code);
+        }
+        return Ok(());
+    }
+
+    let mut by_file: HashMap<String, Vec<(usize, String)>> = HashMap::new();
+    let mut total = 0;
+
+    for line in stdout.lines() {
+        let parts: Vec<&str> = line.splitn(3, ':').collect();
+
+        let (file, line_num, content) = if parts.len() == 3 {
+            let ln = parts[1].parse().unwrap_or(0);
+            (parts[0].to_string(), ln, parts[2])
+        } else if parts.len() == 2 {
+            let ln = parts[0].parse().unwrap_or(0);
+            (path.to_string(), ln, parts[1])
+        } else {
+            continue;
+        };
+
+        total += 1;
+        let cleaned = clean_line(content, max_line_len, context_only, pattern);
+        by_file.entry(file).or_default().push((line_num, cleaned));
+    }
+
+    let mut rtk_output = String::new();
+    rtk_output.push_str(&format!("🔍 {} in {}F:\n\n", total, by_file.len()));
+
+    let mut shown = 0;
+    let mut files: Vec<_> = by_file.iter().collect();
+    files.sort_by_key(|(f, _)| *f);
+
+    for (file, matches) in files {
+        if shown >= max_results {
+            break;
+        }
+
+        let file_display = compact_path(file);
+        rtk_output.push_str(&format!("📄 {} ({}):\n", file_display, matches.len()));
+
+        for (line_num, content) in matches.iter().take(10) {
+            rtk_output.push_str(&format!("  {:>4}: {}\n", line_num, content));
+            shown += 1;
+            if shown >= max_results {
+                break;
+            }
+        }
+
+        if matches.len() > 10 {
+            rtk_output.push_str(&format!("  +{}\n", matches.len() - 10));
+        }
+        rtk_output.push('\n');
+    }
+
+    if total > shown {
+        rtk_output.push_str(&format!("... +{}\n", total - shown));
+    }
+
+    print!("{}", rtk_output);
+    timer.track(
+        &format!("grep -rn '{}' {}", pattern, path),
+        "rtk grep",
+        &raw_output,
+        &rtk_output,
+    );
+
+    if exit_code != 0 {
+        std::process::exit(exit_code);
+    }
+
+    Ok(())
+}
+
+fn clean_line(line: &str, max_len: usize, context_only: bool, pattern: &str) -> String {
+    let trimmed = line.trim();
+
+    if context_only {
+        if let Ok(re) = Regex::new(&format!("(?i).{{0,20}}{}.*", regex::escape(pattern))) {
+            if let Some(m) = re.find(trimmed) {
+                let matched = m.as_str();
+                if matched.len() <= max_len {
+                    return matched.to_string();
+                }
+            }
+        }
+    }
+
+    if trimmed.len() <= max_len {
+        trimmed.to_string()
+    } else {
+        let lower = trimmed.to_lowercase();
+        let pattern_lower = pattern.to_lowercase();
+
+        if let Some(pos) = lower.find(&pattern_lower) {
+            let char_pos = lower[..pos].chars().count();
+            let chars: Vec<char> = trimmed.chars().collect();
+            let char_len = chars.len();
+
+            let start = char_pos.saturating_sub(max_len / 3);
+            let end = (start + max_len).min(char_len);
+            let start = if end == char_len {
+                end.saturating_sub(max_len)
+            } else {
+                start
+            };
+
+            let slice: String = chars[start..end].iter().collect();
+            if start > 0 && end < char_len {
+                format!("...{}...", slice)
+            } else if start > 0 {
+                format!("...{}", slice)
+            } else {
+                format!("{}...", slice)
+            }
+        } else {
+            let t: String = trimmed.chars().take(max_len - 3).collect();
+            format!("{}...", t)
+        }
+    }
+}
+
+fn compact_path(path: &str) -> String {
+    if path.len() <= 50 {
+        return path.to_string();
+    }
+
+    let parts: Vec<&str> = path.split('/').collect();
+    if parts.len() <= 3 {
+        return path.to_string();
+    }
+
+    format!(
+        "{}/.../{}/{}",
+        parts[0],
+        parts[parts.len() - 2],
+        parts[parts.len() - 1]
+    )
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_clean_line() {
+        let line = "            const result = someFunction();";
+        let cleaned = clean_line(line, 50, false, "result");
+        assert!(!cleaned.starts_with(' '));
+        assert!(cleaned.len() <= 50);
+    }
+
+    #[test]
+    fn test_compact_path() {
+        let path = "/Users/patrick/dev/project/src/components/Button.tsx";
+        let compact = compact_path(path);
+        assert!(compact.len() <= 60);
+    }
+
+    #[test]
+    fn test_extra_args_accepted() {
+        // Test that the function signature accepts extra_args
+        // This is a compile-time test - if it compiles, the signature is correct
+        let _extra: Vec<String> = vec!["-i".to_string(), "-A".to_string(), "3".to_string()];
+        // No need to actually run - we're verifying the parameter exists
+    }
+
+    #[test]
+    fn test_clean_line_multibyte() {
+        // Thai text that exceeds max_len in bytes
+        let line = "  สวัสดีครับ นี่คือข้อความที่ยาวมากสำหรับทดสอบ  ";
+        let cleaned = clean_line(line, 20, false, "ครับ");
+        // Should not panic
+        assert!(!cleaned.is_empty());
+    }
+
+    #[test]
+    fn test_clean_line_emoji() {
+        let line = "🎉🎊🎈🎁🎂🎄 some text 🎃🎆🎇✨";
+        let cleaned = clean_line(line, 15, false, "text");
+        assert!(!cleaned.is_empty());
+    }
+
+    // Fix: BRE \| alternation is translated to PCRE | for rg
+    #[test]
+    fn test_bre_alternation_translated() {
+        let pattern = r"fn foo\|pub.*bar";
+        let rg_pattern = pattern.replace(r"\|", "|");
+        assert_eq!(rg_pattern, "fn foo|pub.*bar");
+    }
+
+    // Fix: -r flag (grep recursive) is stripped from extra_args (rg is recursive by default)
+    #[test]
+    fn test_recursive_flag_stripped() {
+        let extra_args: Vec<String> = vec!["-r".to_string(), "-i".to_string()];
+        let filtered: Vec<&String> = extra_args
+            .iter()
+            .filter(|a| *a != "-r" && *a != "--recursive")
+            .collect();
+        assert_eq!(filtered.len(), 1);
+        assert_eq!(filtered[0], "-i");
+    }
+
+    // Verify line numbers are always enabled in rg invocation (grep_cmd.rs:24).
+    // The -n/--line-numbers clap flag in main.rs is a no-op accepted for compat.
+    #[test]
+    fn test_rg_always_has_line_numbers() {
+        // grep_cmd::run() always passes "-n" to rg (line 24).
+        // This test documents that -n is built-in, so the clap flag is safe to ignore.
+        let mut cmd = std::process::Command::new("rg");
+        cmd.args(["-n", "--no-heading", "NONEXISTENT_PATTERN_12345", "."]);
+        // If rg is available, it should accept -n without error (exit 1 = no match, not error)
+        if let Ok(output) = cmd.output() {
+            assert!(
+                output.status.code() == Some(1) || output.status.success(),
+                "rg -n should be accepted"
+            );
+        }
+        // If rg is not installed, skip gracefully (test still passes)
+    }
+}