@hasna/terminal 2.0.5 → 2.3.0

package/temp/rtk/src/summary.rs

@@ -0,0 +1,297 @@
+use crate::tracking;
+use crate::utils::truncate;
+use anyhow::{Context, Result};
+use regex::Regex;
+use std::process::{Command, Stdio};
+
+/// Run a command and provide a heuristic summary
+pub fn run(command: &str, verbose: u8) -> Result<()> {
+    let timer = tracking::TimedExecution::start();
+
+    if verbose > 0 {
+        eprintln!("Running and summarizing: {}", 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 summary = summarize_output(&raw, command, output.status.success());
+    println!("{}", summary);
+    timer.track(command, "rtk summary", &raw, &summary);
+    Ok(())
+}
+
+fn summarize_output(output: &str, command: &str, success: bool) -> String {
+    let lines: Vec<&str> = output.lines().collect();
+    let mut result = Vec::new();
+
+    // Status
+    let status_icon = if success { "✅" } else { "❌" };
+    result.push(format!(
+        "{} Command: {}",
+        status_icon,
+        truncate(command, 60)
+    ));
+    result.push(format!("   {} lines of output", lines.len()));
+    result.push(String::new());
+
+    // Detect type of output and summarize accordingly
+    let output_type = detect_output_type(output, command);
+
+    match output_type {
+        OutputType::TestResults => summarize_tests(output, &mut result),
+        OutputType::BuildOutput => summarize_build(output, &mut result),
+        OutputType::LogOutput => summarize_logs_quick(output, &mut result),
+        OutputType::ListOutput => summarize_list(output, &mut result),
+        OutputType::JsonOutput => summarize_json(output, &mut result),
+        OutputType::Generic => summarize_generic(output, &mut result),
+    }
+
+    result.join("\n")
+}
+
+#[derive(Debug)]
+enum OutputType {
+    TestResults,
+    BuildOutput,
+    LogOutput,
+    ListOutput,
+    JsonOutput,
+    Generic,
+}
+
+fn detect_output_type(output: &str, command: &str) -> OutputType {
+    let cmd_lower = command.to_lowercase();
+    let out_lower = output.to_lowercase();
+
+    if cmd_lower.contains("test") || out_lower.contains("passed") && out_lower.contains("failed") {
+        OutputType::TestResults
+    } else if cmd_lower.contains("build")
+        || cmd_lower.contains("compile")
+        || out_lower.contains("compiling")
+    {
+        OutputType::BuildOutput
+    } else if out_lower.contains("error:")
+        || out_lower.contains("warn:")
+        || out_lower.contains("[info]")
+    {
+        OutputType::LogOutput
+    } else if output.trim_start().starts_with('{') || output.trim_start().starts_with('[') {
+        OutputType::JsonOutput
+    } else if output.lines().all(|l| {
+        l.len() < 200
+            && !l
+                .contains('\t')
+                .then_some(true)
+                .unwrap_or(l.split_whitespace().count() < 10)
+    }) {
+        OutputType::ListOutput
+    } else {
+        OutputType::Generic
+    }
+}
+
+fn summarize_tests(output: &str, result: &mut Vec<String>) {
+    result.push("📋 Test Results:".to_string());
+
+    let mut passed = 0;
+    let mut failed = 0;
+    let mut skipped = 0;
+    let mut failures = Vec::new();
+
+    for line in output.lines() {
+        let lower = line.to_lowercase();
+        if lower.contains("passed") || lower.contains("✓") || lower.contains("ok") {
+            // Try to extract number
+            if let Some(n) = extract_number(&lower, "passed") {
+                passed = n;
+            } else {
+                passed += 1;
+            }
+        }
+        if lower.contains("failed") || lower.contains("✗") || lower.contains("fail") {
+            if let Some(n) = extract_number(&lower, "failed") {
+                failed = n;
+            }
+            if !line.contains("0 failed") {
+                failures.push(line.to_string());
+            }
+        }
+        if lower.contains("skipped") || lower.contains("ignored") {
+            if let Some(n) = extract_number(&lower, "skipped").or(extract_number(&lower, "ignored"))
+            {
+                skipped = n;
+            }
+        }
+    }
+
+    result.push(format!("   ✅ {} passed", passed));
+    if failed > 0 {
+        result.push(format!("   ❌ {} failed", failed));
+    }
+    if skipped > 0 {
+        result.push(format!("   ⏭️  {} skipped", skipped));
+    }
+
+    if !failures.is_empty() {
+        result.push(String::new());
+        result.push("   Failures:".to_string());
+        for f in failures.iter().take(5) {
+            result.push(format!("   • {}", truncate(f, 70)));
+        }
+    }
+}
+
+fn summarize_build(output: &str, result: &mut Vec<String>) {
+    result.push("🔨 Build Summary:".to_string());
+
+    let mut errors = 0;
+    let mut warnings = 0;
+    let mut compiled = 0;
+    let mut error_msgs = Vec::new();
+
+    for line in output.lines() {
+        let lower = line.to_lowercase();
+        if lower.contains("error") && !lower.contains("0 error") {
+            errors += 1;
+            if error_msgs.len() < 5 {
+                error_msgs.push(line.to_string());
+            }
+        }
+        if lower.contains("warning") && !lower.contains("0 warning") {
+            warnings += 1;
+        }
+        if lower.contains("compiling") || lower.contains("compiled") {
+            compiled += 1;
+        }
+    }
+
+    if compiled > 0 {
+        result.push(format!("   📦 {} crates/files compiled", compiled));
+    }
+    if errors > 0 {
+        result.push(format!("   ❌ {} errors", errors));
+    }
+    if warnings > 0 {
+        result.push(format!("   ⚠️  {} warnings", warnings));
+    }
+    if errors == 0 && warnings == 0 {
+        result.push("   ✅ Build successful".to_string());
+    }
+
+    if !error_msgs.is_empty() {
+        result.push(String::new());
+        result.push("   Errors:".to_string());
+        for e in &error_msgs {
+            result.push(format!("   • {}", truncate(e, 70)));
+        }
+    }
+}
+
+fn summarize_logs_quick(output: &str, result: &mut Vec<String>) {
+    result.push("📝 Log Summary:".to_string());
+
+    let mut errors = 0;
+    let mut warnings = 0;
+    let mut info = 0;
+
+    for line in output.lines() {
+        let lower = line.to_lowercase();
+        if lower.contains("error") || lower.contains("fatal") {
+            errors += 1;
+        } else if lower.contains("warn") {
+            warnings += 1;
+        } else if lower.contains("info") {
+            info += 1;
+        }
+    }
+
+    result.push(format!("   ❌ {} errors", errors));
+    result.push(format!("   ⚠️  {} warnings", warnings));
+    result.push(format!("   ℹ️  {} info", info));
+}
+
+fn summarize_list(output: &str, result: &mut Vec<String>) {
+    let lines: Vec<&str> = output.lines().filter(|l| !l.trim().is_empty()).collect();
+    result.push(format!("📋 List ({} items):", lines.len()));
+
+    for line in lines.iter().take(10) {
+        result.push(format!("   • {}", truncate(line, 70)));
+    }
+    if lines.len() > 10 {
+        result.push(format!("   ... +{} more", lines.len() - 10));
+    }
+}
+
+fn summarize_json(output: &str, result: &mut Vec<String>) {
+    result.push("📋 JSON Output:".to_string());
+
+    // Try to parse and show structure
+    if let Ok(value) = serde_json::from_str::<serde_json::Value>(output) {
+        match &value {
+            serde_json::Value::Array(arr) => {
+                result.push(format!("   Array with {} items", arr.len()));
+            }
+            serde_json::Value::Object(obj) => {
+                result.push(format!("   Object with {} keys:", obj.len()));
+                for key in obj.keys().take(10) {
+                    result.push(format!("   • {}", key));
+                }
+                if obj.len() > 10 {
+                    result.push(format!("   ... +{} more keys", obj.len() - 10));
+                }
+            }
+            _ => {
+                result.push(format!("   {}", truncate(&value.to_string(), 100)));
+            }
+        }
+    } else {
+        result.push("   (Invalid JSON)".to_string());
+    }
+}
+
+fn summarize_generic(output: &str, result: &mut Vec<String>) {
+    let lines: Vec<&str> = output.lines().collect();
+
+    result.push("📋 Output:".to_string());
+
+    // First few lines
+    for line in lines.iter().take(5) {
+        if !line.trim().is_empty() {
+            result.push(format!("   {}", truncate(line, 75)));
+        }
+    }
+
+    if lines.len() > 10 {
+        result.push("   ...".to_string());
+        // Last few lines
+        for line in lines.iter().skip(lines.len() - 3) {
+            if !line.trim().is_empty() {
+                result.push(format!("   {}", truncate(line, 75)));
+            }
+        }
+    }
+}
+
+fn extract_number(text: &str, after: &str) -> Option<usize> {
+    let re = Regex::new(&format!(r"(\d+)\s*{}", after)).ok()?;
+    re.captures(text)
+        .and_then(|c| c.get(1))
+        .and_then(|m| m.as_str().parse().ok())
+}

package/temp/rtk/src/tee.rs

@@ -0,0 +1,405 @@
+use crate::config::Config;
+use std::path::PathBuf;
+
+/// Minimum output size to tee (smaller outputs don't need recovery)
+const MIN_TEE_SIZE: usize = 500;
+
+/// Default max files to keep in tee directory
+const DEFAULT_MAX_FILES: usize = 20;
+
+/// Default max file size (1MB)
+const DEFAULT_MAX_FILE_SIZE: usize = 1_048_576;
+
+/// Sanitize a command slug for use in filenames.
+/// Replaces non-alphanumeric chars (except underscore/hyphen) with underscore,
+/// truncates at 40 chars.
+fn sanitize_slug(slug: &str) -> String {
+    let sanitized: String = slug
+        .chars()
+        .map(|c| {
+            if c.is_ascii_alphanumeric() || c == '_' || c == '-' {
+                c
+            } else {
+                '_'
+            }
+        })
+        .collect();
+    if sanitized.len() > 40 {
+        sanitized[..40].to_string()
+    } else {
+        sanitized
+    }
+}
+
+/// Get the tee directory, respecting config and env overrides.
+fn get_tee_dir(config: &Config) -> Option<PathBuf> {
+    // Env var override
+    if let Ok(dir) = std::env::var("RTK_TEE_DIR") {
+        return Some(PathBuf::from(dir));
+    }
+
+    // Config override
+    if let Some(ref dir) = config.tee.directory {
+        return Some(dir.clone());
+    }
+
+    // Default: ~/.local/share/rtk/tee/
+    dirs::data_local_dir().map(|d| d.join("rtk").join("tee"))
+}
+
+/// Rotate old tee files: keep only the last `max_files`, delete oldest.
+fn cleanup_old_files(dir: &std::path::Path, max_files: usize) {
+    let mut entries: Vec<_> = std::fs::read_dir(dir)
+        .ok()
+        .into_iter()
+        .flatten()
+        .filter_map(|e| e.ok())
+        .filter(|e| e.path().extension().is_some_and(|ext| ext == "log"))
+        .collect();
+
+    if entries.len() <= max_files {
+        return;
+    }
+
+    // Sort by filename (which starts with epoch timestamp = chronological)
+    entries.sort_by_key(|e| e.file_name());
+
+    let to_remove = entries.len() - max_files;
+    for entry in entries.iter().take(to_remove) {
+        let _ = std::fs::remove_file(entry.path());
+    }
+}
+
+/// Check if tee should be skipped based on config, mode, exit code, and size.
+/// Returns None if should skip, Some(tee_dir) if should proceed.
+fn should_tee(
+    config: &TeeConfig,
+    raw_len: usize,
+    exit_code: i32,
+    tee_dir: Option<PathBuf>,
+) -> Option<PathBuf> {
+    if !config.enabled {
+        return None;
+    }
+
+    match config.mode {
+        TeeMode::Never => return None,
+        TeeMode::Failures => {
+            if exit_code == 0 {
+                return None;
+            }
+        }
+        TeeMode::Always => {}
+    }
+
+    if raw_len < MIN_TEE_SIZE {
+        return None;
+    }
+
+    tee_dir
+}
+
+/// Write raw output to a tee file in the given directory.
+/// Returns file path on success.
+fn write_tee_file(
+    raw: &str,
+    command_slug: &str,
+    tee_dir: &std::path::Path,
+    max_file_size: usize,
+    max_files: usize,
+) -> Option<PathBuf> {
+    std::fs::create_dir_all(tee_dir).ok()?;
+
+    let slug = sanitize_slug(command_slug);
+    let epoch = std::time::SystemTime::now()
+        .duration_since(std::time::UNIX_EPOCH)
+        .ok()?
+        .as_secs();
+    let filename = format!("{}_{}.log", epoch, slug);
+    let filepath = tee_dir.join(filename);
+
+    // Truncate at max_file_size
+    let content = if raw.len() > max_file_size {
+        format!(
+            "{}\n\n--- truncated at {} bytes ---",
+            &raw[..max_file_size],
+            max_file_size
+        )
+    } else {
+        raw.to_string()
+    };
+
+    std::fs::write(&filepath, content).ok()?;
+
+    // Rotate old files
+    cleanup_old_files(tee_dir, max_files);
+
+    Some(filepath)
+}
+
+/// Write raw output to tee file if conditions are met.
+/// Returns file path on success, None if skipped/failed.
+pub fn tee_raw(raw: &str, command_slug: &str, exit_code: i32) -> Option<PathBuf> {
+    // Check RTK_TEE=0 env override (disable)
+    if std::env::var("RTK_TEE").ok().as_deref() == Some("0") {
+        return None;
+    }
+
+    let config = Config::load().ok()?;
+    let tee_dir = get_tee_dir(&config)?;
+
+    let tee_dir = should_tee(&config.tee, raw.len(), exit_code, Some(tee_dir))?;
+
+    write_tee_file(
+        raw,
+        command_slug,
+        &tee_dir,
+        config.tee.max_file_size,
+        config.tee.max_files,
+    )
+}
+
+/// Format the hint line with ~ shorthand for home directory.
+fn format_hint(path: &std::path::Path) -> String {
+    let display = if let Some(home) = dirs::home_dir() {
+        if let Ok(relative) = path.strip_prefix(&home) {
+            format!("~/{}", relative.display())
+        } else {
+            path.display().to_string()
+        }
+    } else {
+        path.display().to_string()
+    };
+
+    format!("[full output: {}]", display)
+}
+
+/// Convenience: tee + format hint in one call.
+/// Returns hint string if file was written, None if skipped.
+pub fn tee_and_hint(raw: &str, command_slug: &str, exit_code: i32) -> Option<String> {
+    let path = tee_raw(raw, command_slug, exit_code)?;
+    Some(format_hint(&path))
+}
+
+/// TeeMode controls when tee writes files.
+#[derive(Debug, Clone, serde::Serialize, serde::Deserialize, PartialEq)]
+#[serde(rename_all = "lowercase")]
+pub enum TeeMode {
+    Failures,
+    Always,
+    Never,
+}
+
+impl Default for TeeMode {
+    fn default() -> Self {
+        Self::Failures
+    }
+}
+
+/// Configuration for the tee feature.
+#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
+pub struct TeeConfig {
+    pub enabled: bool,
+    pub mode: TeeMode,
+    pub max_files: usize,
+    pub max_file_size: usize,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub directory: Option<PathBuf>,
+}
+
+impl Default for TeeConfig {
+    fn default() -> Self {
+        Self {
+            enabled: true,
+            mode: TeeMode::default(),
+            max_files: DEFAULT_MAX_FILES,
+            max_file_size: DEFAULT_MAX_FILE_SIZE,
+            directory: None,
+        }
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use std::fs;
+
+    #[test]
+    fn test_sanitize_slug() {
+        assert_eq!(sanitize_slug("cargo_test"), "cargo_test");
+        assert_eq!(sanitize_slug("cargo test"), "cargo_test");
+        assert_eq!(sanitize_slug("cargo-test"), "cargo-test");
+        assert_eq!(sanitize_slug("go/test/./pkg"), "go_test___pkg");
+        // Truncate at 40
+        let long = "a".repeat(50);
+        assert_eq!(sanitize_slug(&long).len(), 40);
+    }
+
+    #[test]
+    fn test_should_tee_disabled() {
+        let config = TeeConfig {
+            enabled: false,
+            ..TeeConfig::default()
+        };
+        let dir = PathBuf::from("/tmp/tee");
+        assert!(should_tee(&config, 1000, 1, Some(dir)).is_none());
+    }
+
+    #[test]
+    fn test_should_tee_never_mode() {
+        let config = TeeConfig {
+            mode: TeeMode::Never,
+            ..TeeConfig::default()
+        };
+        let dir = PathBuf::from("/tmp/tee");
+        assert!(should_tee(&config, 1000, 1, Some(dir)).is_none());
+    }
+
+    #[test]
+    fn test_should_tee_skip_small_output() {
+        let config = TeeConfig::default();
+        let dir = PathBuf::from("/tmp/tee");
+        // Below MIN_TEE_SIZE (500)
+        assert!(should_tee(&config, 100, 1, Some(dir)).is_none());
+    }
+
+    #[test]
+    fn test_should_tee_skip_success_in_failures_mode() {
+        let config = TeeConfig::default(); // mode = Failures
+        let dir = PathBuf::from("/tmp/tee");
+        assert!(should_tee(&config, 1000, 0, Some(dir)).is_none());
+    }
+
+    #[test]
+    fn test_should_tee_proceed_on_failure() {
+        let config = TeeConfig::default(); // mode = Failures
+        let dir = PathBuf::from("/tmp/tee");
+        assert!(should_tee(&config, 1000, 1, Some(dir)).is_some());
+    }
+
+    #[test]
+    fn test_should_tee_always_mode_success() {
+        let config = TeeConfig {
+            mode: TeeMode::Always,
+            ..TeeConfig::default()
+        };
+        let dir = PathBuf::from("/tmp/tee");
+        assert!(should_tee(&config, 1000, 0, Some(dir)).is_some());
+    }
+
+    #[test]
+    fn test_write_tee_file_creates_file() {
+        let tmpdir = tempfile::tempdir().unwrap();
+        let content = "error: test failed\n".repeat(50);
+        let result = write_tee_file(
+            &content,
+            "cargo_test",
+            tmpdir.path(),
+            DEFAULT_MAX_FILE_SIZE,
+            20,
+        );
+        assert!(result.is_some());
+
+        let path = result.unwrap();
+        assert!(path.exists());
+        let written = fs::read_to_string(&path).unwrap();
+        assert!(written.contains("error: test failed"));
+    }
+
+    #[test]
+    fn test_write_tee_file_truncation() {
+        let tmpdir = tempfile::tempdir().unwrap();
+        let big_output = "x".repeat(2000);
+        // Set max_file_size to 1000 bytes
+        let result = write_tee_file(&big_output, "test", tmpdir.path(), 1000, 20);
+        assert!(result.is_some());
+
+        let path = result.unwrap();
+        let content = fs::read_to_string(&path).unwrap();
+        assert!(content.contains("--- truncated at 1000 bytes ---"));
+        assert!(content.len() < 2000);
+    }
+
+    #[test]
+    fn test_cleanup_old_files() {
+        let tmpdir = tempfile::tempdir().unwrap();
+        let dir = tmpdir.path();
+
+        // Create 25 .log files
+        for i in 0..25 {
+            let filename = format!("{:010}_{}.log", 1000000 + i, "test");
+            fs::write(dir.join(&filename), "content").unwrap();
+        }
+
+        cleanup_old_files(dir, 20);
+
+        let remaining: Vec<_> = fs::read_dir(dir).unwrap().filter_map(|e| e.ok()).collect();
+        assert_eq!(remaining.len(), 20);
+
+        // Oldest 5 should be removed
+        for i in 0..5 {
+            let filename = format!("{:010}_{}.log", 1000000 + i, "test");
+            assert!(!dir.join(&filename).exists());
+        }
+        // Newest 20 should remain
+        for i in 5..25 {
+            let filename = format!("{:010}_{}.log", 1000000 + i, "test");
+            assert!(dir.join(&filename).exists());
+        }
+    }
+
+    #[test]
+    fn test_format_hint() {
+        let path = PathBuf::from("/tmp/rtk/tee/123_cargo_test.log");
+        let hint = format_hint(&path);
+        assert!(hint.starts_with("[full output: "));
+        assert!(hint.ends_with(']'));
+        assert!(hint.contains("123_cargo_test.log"));
+    }
+
+    #[test]
+    fn test_tee_config_default() {
+        let config = TeeConfig::default();
+        assert!(config.enabled);
+        assert_eq!(config.mode, TeeMode::Failures);
+        assert_eq!(config.max_files, 20);
+        assert_eq!(config.max_file_size, 1_048_576);
+        assert!(config.directory.is_none());
+    }
+
+    #[test]
+    fn test_tee_config_deserialize() {
+        let toml_str = r#"
+enabled = true
+mode = "always"
+max_files = 10
+max_file_size = 524288
+directory = "/tmp/rtk-tee"
+"#;
+        let config: TeeConfig = toml::from_str(toml_str).unwrap();
+        assert!(config.enabled);
+        assert_eq!(config.mode, TeeMode::Always);
+        assert_eq!(config.max_files, 10);
+        assert_eq!(config.max_file_size, 524288);
+        assert_eq!(config.directory, Some(PathBuf::from("/tmp/rtk-tee")));
+
+        // Round-trip
+        let serialized = toml::to_string_pretty(&config).unwrap();
+        let deserialized: TeeConfig = toml::from_str(&serialized).unwrap();
+        assert_eq!(deserialized.mode, TeeMode::Always);
+        assert_eq!(deserialized.max_files, 10);
+    }
+
+    #[test]
+    fn test_tee_mode_serde() {
+        // Test all modes via JSON
+        let mode: TeeMode = serde_json::from_str(r#""always""#).unwrap();
+        assert_eq!(mode, TeeMode::Always);
+
+        let mode: TeeMode = serde_json::from_str(r#""failures""#).unwrap();
+        assert_eq!(mode, TeeMode::Failures);
+
+        let mode: TeeMode = serde_json::from_str(r#""never""#).unwrap();
+        assert_eq!(mode, TeeMode::Never);
+    }
+}