@hasna/terminal 2.2.0 → 2.3.0

package/temp/rtk/src/pytest_cmd.rs

@@ -0,0 +1,384 @@
+use crate::tracking;
+use crate::utils::truncate;
+use anyhow::{Context, Result};
+use std::process::Command;
+
+#[derive(Debug, PartialEq)]
+enum ParseState {
+    Header,
+    TestProgress,
+    Failures,
+    Summary,
+}
+
+pub fn run(args: &[String], verbose: u8) -> Result<()> {
+    let timer = tracking::TimedExecution::start();
+
+    // Try to detect pytest command (could be "pytest", "python -m pytest", etc.)
+    let mut cmd = if which_command("pytest").is_some() {
+        Command::new("pytest")
+    } else {
+        // Fallback to python -m pytest
+        let mut c = Command::new("python");
+        c.arg("-m").arg("pytest");
+        c
+    };
+
+    // Force short traceback and quiet mode for compact output
+    let has_tb_flag = args.iter().any(|a| a.starts_with("--tb"));
+    let has_quiet_flag = args.iter().any(|a| a == "-q" || a == "--quiet");
+
+    if !has_tb_flag {
+        cmd.arg("--tb=short");
+    }
+    if !has_quiet_flag {
+        cmd.arg("-q");
+    }
+
+    for arg in args {
+        cmd.arg(arg);
+    }
+
+    if verbose > 0 {
+        eprintln!("Running: pytest --tb=short -q {}", args.join(" "));
+    }
+
+    let output = cmd
+        .output()
+        .context("Failed to run pytest. Is it installed? Try: pip install pytest")?;
+
+    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_pytest_output(&stdout);
+
+    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, "pytest", exit_code) {
+        println!("{}\n{}", filtered, hint);
+    } else {
+        println!("{}", filtered);
+    }
+
+    // Include stderr if present (import errors, etc.)
+    if !stderr.trim().is_empty() {
+        eprintln!("{}", stderr.trim());
+    }
+
+    timer.track(
+        &format!("pytest {}", args.join(" ")),
+        &format!("rtk pytest {}", args.join(" ")),
+        &raw,
+        &filtered,
+    );
+
+    // Preserve exit code for CI/CD
+    if !output.status.success() {
+        std::process::exit(exit_code);
+    }
+
+    Ok(())
+}
+
+/// Check if a command exists in PATH
+fn which_command(cmd: &str) -> Option<String> {
+    Command::new("which")
+        .arg(cmd)
+        .output()
+        .ok()
+        .filter(|o| o.status.success())
+        .and_then(|o| String::from_utf8(o.stdout).ok())
+        .map(|s| s.trim().to_string())
+        .filter(|s| !s.is_empty())
+}
+
+/// Parse pytest output using state machine
+fn filter_pytest_output(output: &str) -> String {
+    let mut state = ParseState::Header;
+    let mut test_files: Vec<String> = Vec::new();
+    let mut failures: Vec<String> = Vec::new();
+    let mut current_failure: Vec<String> = Vec::new();
+    let mut summary_line = String::new();
+
+    for line in output.lines() {
+        let trimmed = line.trim();
+
+        // State transitions
+        if trimmed.starts_with("===") && trimmed.contains("test session starts") {
+            state = ParseState::Header;
+            continue;
+        } else if trimmed.starts_with("===") && trimmed.contains("FAILURES") {
+            state = ParseState::Failures;
+            continue;
+        } else if trimmed.starts_with("===") && trimmed.contains("short test summary") {
+            state = ParseState::Summary;
+            // Save current failure if any
+            if !current_failure.is_empty() {
+                failures.push(current_failure.join("\n"));
+                current_failure.clear();
+            }
+            continue;
+        } else if trimmed.starts_with("===")
+            && (trimmed.contains("passed") || trimmed.contains("failed"))
+        {
+            summary_line = trimmed.to_string();
+            continue;
+        }
+
+        // Process based on state
+        match state {
+            ParseState::Header => {
+                if trimmed.starts_with("collected") {
+                    state = ParseState::TestProgress;
+                }
+            }
+            ParseState::TestProgress => {
+                // Lines like "tests/test_foo.py ....  [ 40%]"
+                if !trimmed.is_empty()
+                    && !trimmed.starts_with("===")
+                    && (trimmed.contains(".py") || trimmed.contains("%]"))
+                {
+                    test_files.push(trimmed.to_string());
+                }
+            }
+            ParseState::Failures => {
+                // Collect failure details
+                if trimmed.starts_with("___") {
+                    // New failure section
+                    if !current_failure.is_empty() {
+                        failures.push(current_failure.join("\n"));
+                        current_failure.clear();
+                    }
+                    current_failure.push(trimmed.to_string());
+                } else if !trimmed.is_empty() && !trimmed.starts_with("===") {
+                    current_failure.push(trimmed.to_string());
+                }
+            }
+            ParseState::Summary => {
+                // FAILED test lines
+                if trimmed.starts_with("FAILED") || trimmed.starts_with("ERROR") {
+                    failures.push(trimmed.to_string());
+                }
+            }
+        }
+    }
+
+    // Save last failure if any
+    if !current_failure.is_empty() {
+        failures.push(current_failure.join("\n"));
+    }
+
+    // Build compact output
+    build_pytest_summary(&summary_line, &test_files, &failures)
+}
+
+fn build_pytest_summary(summary: &str, _test_files: &[String], failures: &[String]) -> String {
+    // Parse summary line
+    let (passed, failed, skipped) = parse_summary_line(summary);
+
+    if failed == 0 && passed > 0 {
+        return format!("✓ Pytest: {} passed", passed);
+    }
+
+    if passed == 0 && failed == 0 {
+        return "Pytest: No tests collected".to_string();
+    }
+
+    let mut result = String::new();
+    result.push_str(&format!("Pytest: {} passed, {} failed", passed, failed));
+    if skipped > 0 {
+        result.push_str(&format!(", {} skipped", skipped));
+    }
+    result.push('\n');
+    result.push_str("═══════════════════════════════════════\n");
+
+    if failures.is_empty() {
+        return result.trim().to_string();
+    }
+
+    // Show failures (limit to key information)
+    result.push_str("\nFailures:\n");
+
+    for (i, failure) in failures.iter().take(5).enumerate() {
+        // Extract test name and key error info
+        let lines: Vec<&str> = failure.lines().collect();
+
+        // First line is usually test name (after ___)
+        if let Some(first_line) = lines.first() {
+            if first_line.starts_with("___") {
+                // Extract test name between ___
+                let test_name = first_line.trim_matches('_').trim();
+                result.push_str(&format!("{}. ❌ {}\n", i + 1, test_name));
+            } else if first_line.starts_with("FAILED") {
+                // Summary format: "FAILED tests/test_foo.py::test_bar - AssertionError"
+                let parts: Vec<&str> = first_line.split(" - ").collect();
+                if let Some(test_path) = parts.first() {
+                    let test_name = test_path.trim_start_matches("FAILED ");
+                    result.push_str(&format!("{}. ❌ {}\n", i + 1, test_name));
+                }
+                if parts.len() > 1 {
+                    result.push_str(&format!("     {}\n", truncate(parts[1], 100)));
+                }
+                continue;
+            }
+        }
+
+        // Show relevant error lines (assertions, errors, file locations)
+        let mut relevant_lines = 0;
+        for line in &lines[1..] {
+            let line_lower = line.to_lowercase();
+            let is_relevant = line.trim().starts_with('>')
+                || line.trim().starts_with('E')
+                || line_lower.contains("assert")
+                || line_lower.contains("error")
+                || line.contains(".py:");
+
+            if is_relevant && relevant_lines < 3 {
+                result.push_str(&format!("     {}\n", truncate(line, 100)));
+                relevant_lines += 1;
+            }
+        }
+
+        if i < failures.len() - 1 {
+            result.push('\n');
+        }
+    }
+
+    if failures.len() > 5 {
+        result.push_str(&format!("\n... +{} more failures\n", failures.len() - 5));
+    }
+
+    result.trim().to_string()
+}
+
+fn parse_summary_line(summary: &str) -> (usize, usize, usize) {
+    let mut passed = 0;
+    let mut failed = 0;
+    let mut skipped = 0;
+
+    // Parse lines like "=== 4 passed, 1 failed in 0.50s ==="
+    let parts: Vec<&str> = summary.split(',').collect();
+
+    for part in parts {
+        let words: Vec<&str> = part.split_whitespace().collect();
+        for (i, word) in words.iter().enumerate() {
+            if i > 0 {
+                if word.contains("passed") {
+                    if let Ok(n) = words[i - 1].parse::<usize>() {
+                        passed = n;
+                    }
+                } else if word.contains("failed") {
+                    if let Ok(n) = words[i - 1].parse::<usize>() {
+                        failed = n;
+                    }
+                } else if word.contains("skipped") {
+                    if let Ok(n) = words[i - 1].parse::<usize>() {
+                        skipped = n;
+                    }
+                }
+            }
+        }
+    }
+
+    (passed, failed, skipped)
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_filter_pytest_all_pass() {
+        let output = r#"=== test session starts ===
+platform darwin -- Python 3.11.0
+collected 5 items
+
+tests/test_foo.py .....                                            [100%]
+
+=== 5 passed in 0.50s ==="#;
+
+        let result = filter_pytest_output(output);
+        assert!(result.contains("✓ Pytest"));
+        assert!(result.contains("5 passed"));
+    }
+
+    #[test]
+    fn test_filter_pytest_with_failures() {
+        let output = r#"=== test session starts ===
+collected 5 items
+
+tests/test_foo.py ..F..                                            [100%]
+
+=== FAILURES ===
+___ test_something ___
+
+    def test_something():
+>       assert False
+E       assert False
+
+tests/test_foo.py:10: AssertionError
+
+=== short test summary info ===
+FAILED tests/test_foo.py::test_something - assert False
+=== 4 passed, 1 failed in 0.50s ==="#;
+
+        let result = filter_pytest_output(output);
+        assert!(result.contains("4 passed, 1 failed"));
+        assert!(result.contains("test_something"));
+        assert!(result.contains("assert False"));
+    }
+
+    #[test]
+    fn test_filter_pytest_multiple_failures() {
+        let output = r#"=== test session starts ===
+collected 3 items
+
+tests/test_foo.py FFF                                              [100%]
+
+=== FAILURES ===
+___ test_one ___
+E   AssertionError: expected 5
+
+___ test_two ___
+E   ValueError: invalid value
+
+=== short test summary info ===
+FAILED tests/test_foo.py::test_one - AssertionError: expected 5
+FAILED tests/test_foo.py::test_two - ValueError: invalid value
+FAILED tests/test_foo.py::test_three - KeyError
+=== 3 failed in 0.20s ==="#;
+
+        let result = filter_pytest_output(output);
+        assert!(result.contains("3 failed"));
+        assert!(result.contains("test_one"));
+        assert!(result.contains("test_two"));
+        assert!(result.contains("expected 5"));
+    }
+
+    #[test]
+    fn test_filter_pytest_no_tests() {
+        let output = r#"=== test session starts ===
+collected 0 items
+
+=== no tests ran in 0.00s ==="#;
+
+        let result = filter_pytest_output(output);
+        assert!(result.contains("No tests collected"));
+    }
+
+    #[test]
+    fn test_parse_summary_line() {
+        assert_eq!(parse_summary_line("=== 5 passed in 0.50s ==="), (5, 0, 0));
+        assert_eq!(
+            parse_summary_line("=== 4 passed, 1 failed in 0.50s ==="),
+            (4, 1, 0)
+        );
+        assert_eq!(
+            parse_summary_line("=== 3 passed, 1 failed, 2 skipped in 1.0s ==="),
+            (3, 1, 2)
+        );
+    }
+}

package/temp/rtk/src/read.rs

@@ -0,0 +1,217 @@
+use crate::filter::{self, FilterLevel, Language};
+use crate::tracking;
+use anyhow::{Context, Result};
+use std::fs;
+use std::path::Path;
+
+pub fn run(
+    file: &Path,
+    level: FilterLevel,
+    max_lines: Option<usize>,
+    tail_lines: Option<usize>,
+    line_numbers: bool,
+    verbose: u8,
+) -> Result<()> {
+    let timer = tracking::TimedExecution::start();
+
+    if verbose > 0 {
+        eprintln!("Reading: {} (filter: {})", file.display(), level);
+    }
+
+    // Read file content
+    let content = fs::read_to_string(file)
+        .with_context(|| format!("Failed to read file: {}", file.display()))?;
+
+    // Detect language from extension
+    let lang = file
+        .extension()
+        .and_then(|e| e.to_str())
+        .map(Language::from_extension)
+        .unwrap_or(Language::Unknown);
+
+    if verbose > 1 {
+        eprintln!("Detected language: {:?}", lang);
+    }
+
+    // Apply filter
+    let filter = filter::get_filter(level);
+    let mut filtered = filter.filter(&content, &lang);
+
+    if verbose > 0 {
+        let original_lines = content.lines().count();
+        let filtered_lines = filtered.lines().count();
+        let reduction = if original_lines > 0 {
+            ((original_lines - filtered_lines) as f64 / original_lines as f64) * 100.0
+        } else {
+            0.0
+        };
+        eprintln!(
+            "Lines: {} -> {} ({:.1}% reduction)",
+            original_lines, filtered_lines, reduction
+        );
+    }
+
+    filtered = apply_line_window(&filtered, max_lines, tail_lines, &lang);
+
+    let rtk_output = if line_numbers {
+        format_with_line_numbers(&filtered)
+    } else {
+        filtered.clone()
+    };
+    println!("{}", rtk_output);
+    timer.track(
+        &format!("cat {}", file.display()),
+        "rtk read",
+        &content,
+        &rtk_output,
+    );
+    Ok(())
+}
+
+pub fn run_stdin(
+    level: FilterLevel,
+    max_lines: Option<usize>,
+    tail_lines: Option<usize>,
+    line_numbers: bool,
+    verbose: u8,
+) -> Result<()> {
+    use std::io::{self, Read as IoRead};
+
+    let timer = tracking::TimedExecution::start();
+
+    if verbose > 0 {
+        eprintln!("Reading from stdin (filter: {})", level);
+    }
+
+    // Read from stdin
+    let mut content = String::new();
+    io::stdin()
+        .lock()
+        .read_to_string(&mut content)
+        .context("Failed to read from stdin")?;
+
+    // No file extension, so use Unknown language
+    let lang = Language::Unknown;
+
+    if verbose > 1 {
+        eprintln!("Language: {:?} (stdin has no extension)", lang);
+    }
+
+    // Apply filter
+    let filter = filter::get_filter(level);
+    let mut filtered = filter.filter(&content, &lang);
+
+    if verbose > 0 {
+        let original_lines = content.lines().count();
+        let filtered_lines = filtered.lines().count();
+        let reduction = if original_lines > 0 {
+            ((original_lines - filtered_lines) as f64 / original_lines as f64) * 100.0
+        } else {
+            0.0
+        };
+        eprintln!(
+            "Lines: {} -> {} ({:.1}% reduction)",
+            original_lines, filtered_lines, reduction
+        );
+    }
+
+    filtered = apply_line_window(&filtered, max_lines, tail_lines, &lang);
+
+    let rtk_output = if line_numbers {
+        format_with_line_numbers(&filtered)
+    } else {
+        filtered.clone()
+    };
+    println!("{}", rtk_output);
+
+    timer.track("cat - (stdin)", "rtk read -", &content, &rtk_output);
+    Ok(())
+}
+
+fn format_with_line_numbers(content: &str) -> String {
+    let lines: Vec<&str> = content.lines().collect();
+    let width = lines.len().to_string().len();
+    let mut out = String::new();
+    for (i, line) in lines.iter().enumerate() {
+        out.push_str(&format!("{:>width$} │ {}\n", i + 1, line, width = width));
+    }
+    out
+}
+
+fn apply_line_window(
+    content: &str,
+    max_lines: Option<usize>,
+    tail_lines: Option<usize>,
+    lang: &Language,
+) -> String {
+    if let Some(tail) = tail_lines {
+        if tail == 0 {
+            return String::new();
+        }
+        let lines: Vec<&str> = content.lines().collect();
+        let start = lines.len().saturating_sub(tail);
+        let mut result = lines[start..].join("\n");
+        if content.ends_with('\n') {
+            result.push('\n');
+        }
+        return result;
+    }
+
+    if let Some(max) = max_lines {
+        return filter::smart_truncate(content, max, lang);
+    }
+
+    content.to_string()
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use std::io::Write;
+    use tempfile::NamedTempFile;
+
+    #[test]
+    fn test_read_rust_file() -> Result<()> {
+        let mut file = NamedTempFile::with_suffix(".rs")?;
+        writeln!(
+            file,
+            r#"// Comment
+fn main() {{
+    println!("Hello");
+}}"#
+        )?;
+
+        // Just verify it doesn't panic
+        run(file.path(), FilterLevel::Minimal, None, None, false, 0)?;
+        Ok(())
+    }
+
+    #[test]
+    fn test_stdin_support_signature() {
+        // Test that run_stdin has correct signature and compiles
+        // We don't actually run it because it would hang waiting for stdin
+        // Compile-time verification that the function exists with correct signature
+    }
+
+    #[test]
+    fn test_apply_line_window_tail_lines() {
+        let input = "a\nb\nc\nd\n";
+        let output = apply_line_window(input, None, Some(2), &Language::Unknown);
+        assert_eq!(output, "c\nd\n");
+    }
+
+    #[test]
+    fn test_apply_line_window_tail_lines_no_trailing_newline() {
+        let input = "a\nb\nc\nd";
+        let output = apply_line_window(input, None, Some(2), &Language::Unknown);
+        assert_eq!(output, "c\nd");
+    }
+
+    #[test]
+    fn test_apply_line_window_max_lines_still_works() {
+        let input = "a\nb\nc\nd\n";
+        let output = apply_line_window(input, Some(2), None, &Language::Unknown);
+        assert!(output.starts_with("a\n"));
+        assert!(output.contains("more lines"));
+    }
+}

package/temp/rtk/src/rewrite_cmd.rs

@@ -0,0 +1,50 @@
+use crate::discover::registry;
+
+/// Run the `rtk rewrite` command.
+///
+/// Prints the RTK-rewritten command to stdout and exits 0.
+/// Exits 1 (without output) if the command has no RTK equivalent.
+///
+/// Used by shell hooks to rewrite commands transparently:
+/// ```bash
+/// REWRITTEN=$(rtk rewrite "$CMD") || exit 0
+/// [ "$CMD" = "$REWRITTEN" ] && exit 0  # already RTK, skip
+/// ```
+pub fn run(cmd: &str) -> anyhow::Result<()> {
+    let excluded = crate::config::Config::load()
+        .map(|c| c.hooks.exclude_commands)
+        .unwrap_or_default();
+
+    match registry::rewrite_command(cmd, &excluded) {
+        Some(rewritten) => {
+            print!("{}", rewritten);
+            Ok(())
+        }
+        None => {
+            std::process::exit(1);
+        }
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_run_supported_command_succeeds() {
+        assert!(registry::rewrite_command("git status", &[]).is_some());
+    }
+
+    #[test]
+    fn test_run_unsupported_returns_none() {
+        assert!(registry::rewrite_command("htop", &[]).is_none());
+    }
+
+    #[test]
+    fn test_run_already_rtk_returns_some() {
+        assert_eq!(
+            registry::rewrite_command("rtk git status", &[]),
+            Some("rtk git status".into())
+        );
+    }
+}