@hasna/terminal 2.3.0 → 2.3.2

package/temp/rtk/src/summary.rs

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

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