@hasna/terminal 2.3.0 → 2.3.2

package/temp/rtk/src/golangci_cmd.rs

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

@@ -1,288 +0,0 @@
-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)
-    }
-}