@hasna/terminal 2.3.0 → 2.3.2

package/temp/rtk/src/hook_audit_cmd.rs

@@ -1,283 +0,0 @@
-use anyhow::{Context, Result};
-use std::collections::HashMap;
-use std::path::PathBuf;
-
-/// Default log file location (aligned with hook's $HOME/.local/share/rtk/).
-fn default_log_path() -> PathBuf {
-    if let Ok(dir) = std::env::var("RTK_AUDIT_DIR") {
-        PathBuf::from(dir).join("hook-audit.log")
-    } else {
-        let home = std::env::var("HOME").unwrap_or_else(|_| "/tmp".to_string());
-        PathBuf::from(home)
-            .join(".local/share/rtk")
-            .join("hook-audit.log")
-    }
-}
-
-/// A single parsed audit log entry.
-struct AuditEntry {
-    timestamp: String,
-    action: String,
-    original_cmd: String,
-    _rewritten_cmd: String,
-}
-
-/// Parse a single log line: "timestamp | action | original_cmd | rewritten_cmd"
-fn parse_line(line: &str) -> Option<AuditEntry> {
-    let parts: Vec<&str> = line.splitn(4, " | ").collect();
-    if parts.len() < 3 {
-        return None;
-    }
-    Some(AuditEntry {
-        timestamp: parts[0].to_string(),
-        action: parts[1].to_string(),
-        original_cmd: parts[2].to_string(),
-        _rewritten_cmd: parts.get(3).unwrap_or(&"-").to_string(),
-    })
-}
-
-/// Extract the base command (first 1-2 words) for grouping.
-fn base_command(cmd: &str) -> String {
-    // Strip env var prefixes (FOO=bar ...)
-    let stripped = cmd
-        .split_whitespace()
-        .skip_while(|w| w.contains('='))
-        .collect::<Vec<_>>();
-
-    match stripped.len() {
-        0 => cmd.to_string(),
-        1 => stripped[0].to_string(),
-        _ => format!("{} {}", stripped[0], stripped[1]),
-    }
-}
-
-/// Filter entries to those within the last N days.
-fn filter_since_days(entries: &[AuditEntry], days: u64) -> Vec<&AuditEntry> {
-    if days == 0 {
-        return entries.iter().collect();
-    }
-
-    let cutoff = chrono::Utc::now() - chrono::Duration::days(days as i64);
-    let cutoff_str = cutoff.format("%Y-%m-%dT%H:%M:%SZ").to_string();
-
-    entries
-        .iter()
-        .filter(|e| e.timestamp >= cutoff_str)
-        .collect()
-}
-
-pub fn run(since_days: u64, verbose: u8) -> Result<()> {
-    let log_path = default_log_path();
-
-    if !log_path.exists() {
-        println!("No audit log found at {}", log_path.display());
-        println!("Enable audit mode: export RTK_HOOK_AUDIT=1 in your shell, then use Claude Code.");
-        return Ok(());
-    }
-
-    let content = std::fs::read_to_string(&log_path)
-        .context(format!("Failed to read {}", log_path.display()))?;
-
-    let entries: Vec<AuditEntry> = content.lines().filter_map(parse_line).collect();
-
-    if entries.is_empty() {
-        println!("Audit log is empty.");
-        return Ok(());
-    }
-
-    let filtered = filter_since_days(&entries, since_days);
-
-    if filtered.is_empty() {
-        println!("No entries in the last {} days.", since_days);
-        return Ok(());
-    }
-
-    // Count by action
-    let mut action_counts: HashMap<&str, usize> = HashMap::new();
-    let mut cmd_counts: HashMap<String, usize> = HashMap::new();
-
-    for entry in &filtered {
-        *action_counts.entry(&entry.action).or_insert(0) += 1;
-        if entry.action == "rewrite" {
-            *cmd_counts
-                .entry(base_command(&entry.original_cmd))
-                .or_insert(0) += 1;
-        }
-    }
-
-    let total = filtered.len();
-    let rewrites = action_counts.get("rewrite").copied().unwrap_or(0);
-    let skips = total - rewrites;
-    let rewrite_pct = if total > 0 {
-        rewrites as f64 / total as f64 * 100.0
-    } else {
-        0.0
-    };
-    let skip_pct = if total > 0 {
-        skips as f64 / total as f64 * 100.0
-    } else {
-        0.0
-    };
-
-    // Period label
-    let period = if since_days == 0 {
-        "all time".to_string()
-    } else {
-        format!("last {} days", since_days)
-    };
-
-    println!("Hook Audit ({})", period);
-    println!("{}", "─".repeat(30));
-    println!("Total invocations: {}", total);
-    println!("Rewrites:          {} ({:.1}%)", rewrites, rewrite_pct);
-    println!("Skips:             {} ({:.1}%)", skips, skip_pct);
-
-    // Skip breakdown
-    let skip_actions: Vec<(&str, usize)> = action_counts
-        .iter()
-        .filter(|(k, _)| k.starts_with("skip:"))
-        .map(|(k, v)| (*k, *v))
-        .collect();
-
-    if !skip_actions.is_empty() {
-        let mut sorted_skips = skip_actions;
-        sorted_skips.sort_by(|a, b| b.1.cmp(&a.1));
-        for (action, count) in &sorted_skips {
-            let reason = action.strip_prefix("skip:").unwrap_or(action);
-            println!(
-                "  {}:{}{}",
-                reason,
-                " ".repeat(14 - reason.len().min(13)),
-                count
-            );
-        }
-    }
-
-    // Top commands (rewrites only)
-    if !cmd_counts.is_empty() {
-        let mut sorted_cmds: Vec<_> = cmd_counts.iter().collect();
-        sorted_cmds.sort_by(|a, b| b.1.cmp(a.1));
-        let top: Vec<String> = sorted_cmds
-            .iter()
-            .take(5)
-            .map(|(cmd, count)| format!("{} ({})", cmd, count))
-            .collect();
-        println!("Top commands: {}", top.join(", "));
-    }
-
-    if verbose > 0 {
-        println!("\nLog: {}", log_path.display());
-    }
-
-    Ok(())
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-
-    #[test]
-    fn test_parse_line_rewrite() {
-        let line = "2026-02-16T14:30:01Z | rewrite | git status | rtk git status";
-        let entry = parse_line(line).unwrap();
-        assert_eq!(entry.action, "rewrite");
-        assert_eq!(entry.original_cmd, "git status");
-        assert_eq!(entry._rewritten_cmd, "rtk git status");
-    }
-
-    #[test]
-    fn test_parse_line_skip() {
-        let line = "2026-02-16T14:30:02Z | skip:no_match | echo hello | -";
-        let entry = parse_line(line).unwrap();
-        assert_eq!(entry.action, "skip:no_match");
-        assert_eq!(entry.original_cmd, "echo hello");
-    }
-
-    #[test]
-    fn test_parse_line_invalid() {
-        assert!(parse_line("garbage").is_none());
-        assert!(parse_line("").is_none());
-    }
-
-    #[test]
-    fn test_base_command_simple() {
-        assert_eq!(base_command("git status"), "git status");
-        assert_eq!(base_command("cargo test --nocapture"), "cargo test");
-    }
-
-    #[test]
-    fn test_base_command_with_env() {
-        assert_eq!(base_command("GIT_PAGER=cat git status"), "git status");
-        assert_eq!(base_command("NODE_ENV=test CI=1 npx vitest"), "npx vitest");
-    }
-
-    #[test]
-    fn test_base_command_single_word() {
-        assert_eq!(base_command("ls"), "ls");
-        assert_eq!(base_command("pytest"), "pytest");
-    }
-
-    fn make_entry(action: &str, cmd: &str) -> AuditEntry {
-        AuditEntry {
-            timestamp: "2026-02-16T14:30:00Z".to_string(),
-            action: action.to_string(),
-            original_cmd: cmd.to_string(),
-            _rewritten_cmd: "-".to_string(),
-        }
-    }
-
-    #[test]
-    fn test_filter_since_days_zero_returns_all() {
-        let entries = vec![
-            make_entry("rewrite", "git status"),
-            make_entry("skip:no_match", "echo hi"),
-        ];
-        let result = filter_since_days(&entries, 0);
-        assert_eq!(result.len(), 2);
-    }
-
-    #[test]
-    fn test_token_savings() {
-        // Simulate what rtk hook-audit would output vs raw log dump
-        let raw_log = r#"2026-02-16T14:30:01Z | rewrite | git status | rtk git status
-2026-02-16T14:30:02Z | skip:no_match | echo hello | -
-2026-02-16T14:30:03Z | rewrite | cargo test | rtk cargo test
-2026-02-16T14:30:04Z | skip:already_rtk | rtk git log | -
-2026-02-16T14:30:05Z | rewrite | git log --oneline -10 | rtk git log --oneline -10
-2026-02-16T14:30:06Z | rewrite | gh pr view 42 | rtk gh pr view 42
-2026-02-16T14:30:07Z | skip:no_match | mkdir -p foo | -
-2026-02-16T14:30:08Z | rewrite | cargo clippy --all-targets | rtk cargo clippy --all-targets"#;
-
-        let entries: Vec<AuditEntry> = raw_log.lines().filter_map(parse_line).collect();
-        assert_eq!(entries.len(), 8);
-
-        let rewrites = entries.iter().filter(|e| e.action == "rewrite").count();
-        assert_eq!(rewrites, 5);
-
-        let skips = entries
-            .iter()
-            .filter(|e| e.action.starts_with("skip:"))
-            .count();
-        assert_eq!(skips, 3);
-
-        // Compact output would be ~10 lines vs 8 raw lines — savings test:
-        // The purpose of hook-audit is metrics, not filtering, so savings are moderate
-        let input_tokens: usize = raw_log.split_whitespace().count();
-        // Simulated compact output
-        let compact = format!(
-            "Hook Audit (all time)\nTotal: {}\nRewrites: {} ({:.1}%)\nSkips: {} ({:.1}%)\nTop: git status (1), cargo test (1)",
-            entries.len(),
-            rewrites,
-            rewrites as f64 / entries.len() as f64 * 100.0,
-            skips,
-            skips as f64 / entries.len() as f64 * 100.0,
-        );
-        let output_tokens: usize = compact.split_whitespace().count();
-        let savings = 100.0 - (output_tokens as f64 / input_tokens as f64 * 100.0);
-        assert!(
-            savings >= 30.0,
-            "Expected >=30% savings for audit summary, got {:.1}%",
-            savings
-        );
-    }
-}

package/temp/rtk/src/hook_check.rs

@@ -1,171 +0,0 @@
-use std::path::PathBuf;
-
-const CURRENT_HOOK_VERSION: u8 = 2;
-const WARN_INTERVAL_SECS: u64 = 24 * 3600;
-
-/// Hook status for diagnostics and `rtk gain`.
-#[derive(Debug, PartialEq, Clone)]
-pub enum HookStatus {
-    /// Hook is installed and up to date.
-    Ok,
-    /// Hook exists but is outdated or unreadable.
-    Outdated,
-    /// No hook file found (but Claude Code is installed).
-    Missing,
-}
-
-/// Return the current hook status without printing anything.
-/// Returns `Ok` if no Claude Code is detected (not applicable).
-pub fn status() -> HookStatus {
-    // Don't warn users who don't have Claude Code installed
-    let home = match dirs::home_dir() {
-        Some(h) => h,
-        None => return HookStatus::Ok,
-    };
-    if !home.join(".claude").exists() {
-        return HookStatus::Ok;
-    }
-
-    let Some(hook_path) = hook_installed_path() else {
-        return HookStatus::Missing;
-    };
-    let Ok(content) = std::fs::read_to_string(&hook_path) else {
-        return HookStatus::Outdated; // exists but unreadable — treat as needs-update
-    };
-    if parse_hook_version(&content) >= CURRENT_HOOK_VERSION {
-        HookStatus::Ok
-    } else {
-        HookStatus::Outdated
-    }
-}
-
-/// Check if the installed hook is missing or outdated, warn once per day.
-pub fn maybe_warn() {
-    // Don't block startup — fail silently on any error
-    let _ = check_and_warn();
-}
-
-/// Single source of truth: delegates to `status()` then rate-limits the warning.
-fn check_and_warn() -> Option<()> {
-    let warning = match status() {
-        HookStatus::Ok => return Some(()),
-        HookStatus::Missing => {
-            "[rtk] /!\\ No hook installed — run `rtk init -g` for automatic token savings"
-        }
-        HookStatus::Outdated => "[rtk] /!\\ Hook outdated — run `rtk init -g` to update",
-    };
-
-    // Rate limit: warn once per day
-    let marker = warn_marker_path()?;
-    if let Ok(meta) = std::fs::metadata(&marker) {
-        if let Ok(modified) = meta.modified() {
-            if modified.elapsed().map(|e| e.as_secs()).unwrap_or(u64::MAX) < WARN_INTERVAL_SECS {
-                return Some(());
-            }
-        }
-    }
-
-    eprintln!("{}", warning);
-
-    // Touch marker after warning is printed
-    let _ = std::fs::create_dir_all(marker.parent()?);
-    let _ = std::fs::write(&marker, b"");
-
-    Some(())
-}
-
-pub fn parse_hook_version(content: &str) -> u8 {
-    // Version tag must be in the first 5 lines (shebang + header convention)
-    for line in content.lines().take(5) {
-        if let Some(rest) = line.strip_prefix("# rtk-hook-version:") {
-            if let Ok(v) = rest.trim().parse::<u8>() {
-                return v;
-            }
-        }
-    }
-    0 // No version tag = version 0 (outdated)
-}
-
-fn hook_installed_path() -> Option<PathBuf> {
-    let home = dirs::home_dir()?;
-    let path = home.join(".claude").join("hooks").join("rtk-rewrite.sh");
-    if path.exists() {
-        Some(path)
-    } else {
-        None
-    }
-}
-
-fn warn_marker_path() -> Option<PathBuf> {
-    let data_dir = dirs::data_local_dir()?.join("rtk");
-    Some(data_dir.join(".hook_warn_last"))
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-
-    #[test]
-    fn test_parse_hook_version_present() {
-        let content = "#!/usr/bin/env bash\n# rtk-hook-version: 2\n# some comment\n";
-        assert_eq!(parse_hook_version(content), 2);
-    }
-
-    #[test]
-    fn test_parse_hook_version_missing() {
-        let content = "#!/usr/bin/env bash\n# old hook without version\n";
-        assert_eq!(parse_hook_version(content), 0);
-    }
-
-    #[test]
-    fn test_parse_hook_version_future() {
-        let content = "#!/usr/bin/env bash\n# rtk-hook-version: 5\n";
-        assert_eq!(parse_hook_version(content), 5);
-    }
-
-    #[test]
-    fn test_parse_hook_version_no_tag() {
-        assert_eq!(parse_hook_version("no version here"), 0);
-        assert_eq!(parse_hook_version(""), 0);
-    }
-
-    #[test]
-    fn test_hook_status_enum() {
-        assert_ne!(HookStatus::Ok, HookStatus::Missing);
-        assert_ne!(HookStatus::Outdated, HookStatus::Missing);
-        assert_eq!(HookStatus::Ok, HookStatus::Ok);
-        // Clone works
-        let s = HookStatus::Missing;
-        assert_eq!(s.clone(), HookStatus::Missing);
-    }
-
-    #[test]
-    fn test_status_returns_valid_variant() {
-        // Skip on machines without Claude Code or without hook
-        let home = match dirs::home_dir() {
-            Some(h) => h,
-            None => return,
-        };
-        if !home
-            .join(".claude")
-            .join("hooks")
-            .join("rtk-rewrite.sh")
-            .exists()
-        {
-            // No hook — status should be Missing (if .claude exists) or Ok (if not)
-            let s = status();
-            if home.join(".claude").exists() {
-                assert_eq!(s, HookStatus::Missing);
-            } else {
-                assert_eq!(s, HookStatus::Ok);
-            }
-            return;
-        }
-        let s = status();
-        assert!(
-            s == HookStatus::Ok || s == HookStatus::Outdated,
-            "Expected Ok or Outdated when hook exists, got {:?}",
-            s
-        );
-    }
-}