@hasna/terminal 2.0.5 → 2.3.0

package/temp/rtk/src/diff_cmd.rs

@@ -0,0 +1,367 @@
+use crate::tracking;
+use crate::utils::truncate;
+use anyhow::Result;
+use std::fs;
+use std::path::Path;
+
+/// Ultra-condensed diff - only changed lines, no context
+pub fn run(file1: &Path, file2: &Path, verbose: u8) -> Result<()> {
+    let timer = tracking::TimedExecution::start();
+
+    if verbose > 0 {
+        eprintln!("Comparing: {} vs {}", file1.display(), file2.display());
+    }
+
+    let content1 = fs::read_to_string(file1)?;
+    let content2 = fs::read_to_string(file2)?;
+    let raw = format!("{}\n---\n{}", content1, content2);
+
+    let lines1: Vec<&str> = content1.lines().collect();
+    let lines2: Vec<&str> = content2.lines().collect();
+    let diff = compute_diff(&lines1, &lines2);
+    let mut rtk = String::new();
+
+    if diff.added == 0 && diff.removed == 0 {
+        rtk.push_str("✅ Files are identical");
+        println!("{}", rtk);
+        timer.track(
+            &format!("diff {} {}", file1.display(), file2.display()),
+            "rtk diff",
+            &raw,
+            &rtk,
+        );
+        return Ok(());
+    }
+
+    rtk.push_str(&format!("📊 {} → {}\n", file1.display(), file2.display()));
+    rtk.push_str(&format!(
+        "   +{} added, -{} removed, ~{} modified\n\n",
+        diff.added, diff.removed, diff.modified
+    ));
+
+    for change in diff.changes.iter().take(50) {
+        match change {
+            DiffChange::Added(ln, c) => rtk.push_str(&format!("+{:4} {}\n", ln, truncate(c, 80))),
+            DiffChange::Removed(ln, c) => rtk.push_str(&format!("-{:4} {}\n", ln, truncate(c, 80))),
+            DiffChange::Modified(ln, old, new) => rtk.push_str(&format!(
+                "~{:4} {} → {}\n",
+                ln,
+                truncate(old, 70),
+                truncate(new, 70)
+            )),
+        }
+    }
+    if diff.changes.len() > 50 {
+        rtk.push_str(&format!("... +{} more changes", diff.changes.len() - 50));
+    }
+
+    print!("{}", rtk);
+    timer.track(
+        &format!("diff {} {}", file1.display(), file2.display()),
+        "rtk diff",
+        &raw,
+        &rtk,
+    );
+    Ok(())
+}
+
+/// Run diff from stdin (piped command output)
+pub fn run_stdin(_verbose: u8) -> Result<()> {
+    use std::io::{self, Read};
+    let timer = tracking::TimedExecution::start();
+
+    let mut input = String::new();
+    io::stdin().read_to_string(&mut input)?;
+
+    // Parse unified diff format
+    let condensed = condense_unified_diff(&input);
+    println!("{}", condensed);
+
+    timer.track("diff (stdin)", "rtk diff (stdin)", &input, &condensed);
+
+    Ok(())
+}
+
+#[derive(Debug)]
+enum DiffChange {
+    Added(usize, String),
+    Removed(usize, String),
+    Modified(usize, String, String),
+}
+
+struct DiffResult {
+    added: usize,
+    removed: usize,
+    modified: usize,
+    changes: Vec<DiffChange>,
+}
+
+fn compute_diff(lines1: &[&str], lines2: &[&str]) -> DiffResult {
+    let mut changes = Vec::new();
+    let mut added = 0;
+    let mut removed = 0;
+    let mut modified = 0;
+
+    // Simple line-by-line comparison (not optimal but fast)
+    let max_len = lines1.len().max(lines2.len());
+
+    for i in 0..max_len {
+        let l1 = lines1.get(i).copied();
+        let l2 = lines2.get(i).copied();
+
+        match (l1, l2) {
+            (Some(a), Some(b)) if a != b => {
+                // Check if it's similar (modification) or completely different
+                if similarity(a, b) > 0.5 {
+                    changes.push(DiffChange::Modified(i + 1, a.to_string(), b.to_string()));
+                    modified += 1;
+                } else {
+                    changes.push(DiffChange::Removed(i + 1, a.to_string()));
+                    changes.push(DiffChange::Added(i + 1, b.to_string()));
+                    removed += 1;
+                    added += 1;
+                }
+            }
+            (Some(a), None) => {
+                changes.push(DiffChange::Removed(i + 1, a.to_string()));
+                removed += 1;
+            }
+            (None, Some(b)) => {
+                changes.push(DiffChange::Added(i + 1, b.to_string()));
+                added += 1;
+            }
+            _ => {}
+        }
+    }
+
+    DiffResult {
+        added,
+        removed,
+        modified,
+        changes,
+    }
+}
+
+fn similarity(a: &str, b: &str) -> f64 {
+    let a_chars: std::collections::HashSet<char> = a.chars().collect();
+    let b_chars: std::collections::HashSet<char> = b.chars().collect();
+
+    let intersection = a_chars.intersection(&b_chars).count();
+    let union = a_chars.union(&b_chars).count();
+
+    if union == 0 {
+        1.0
+    } else {
+        intersection as f64 / union as f64
+    }
+}
+
+fn condense_unified_diff(diff: &str) -> String {
+    let mut result = Vec::new();
+    let mut current_file = String::new();
+    let mut added = 0;
+    let mut removed = 0;
+    let mut changes = Vec::new();
+
+    for line in diff.lines() {
+        if line.starts_with("diff --git") || line.starts_with("--- ") || line.starts_with("+++ ") {
+            // File header
+            if line.starts_with("+++ ") {
+                if !current_file.is_empty() && (added > 0 || removed > 0) {
+                    result.push(format!("📄 {} (+{} -{})", current_file, added, removed));
+                    for c in changes.iter().take(10) {
+                        result.push(format!("  {}", c));
+                    }
+                    if changes.len() > 10 {
+                        result.push(format!("  ... +{} more", changes.len() - 10));
+                    }
+                }
+                current_file = line
+                    .trim_start_matches("+++ ")
+                    .trim_start_matches("b/")
+                    .to_string();
+                added = 0;
+                removed = 0;
+                changes.clear();
+            }
+        } else if line.starts_with('+') && !line.starts_with("+++") {
+            added += 1;
+            if changes.len() < 15 {
+                changes.push(truncate(line, 70));
+            }
+        } else if line.starts_with('-') && !line.starts_with("---") {
+            removed += 1;
+            if changes.len() < 15 {
+                changes.push(truncate(line, 70));
+            }
+        }
+    }
+
+    // Last file
+    if !current_file.is_empty() && (added > 0 || removed > 0) {
+        result.push(format!("📄 {} (+{} -{})", current_file, added, removed));
+        for c in changes.iter().take(10) {
+            result.push(format!("  {}", c));
+        }
+        if changes.len() > 10 {
+            result.push(format!("  ... +{} more", changes.len() - 10));
+        }
+    }
+
+    result.join("\n")
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    // --- similarity ---
+
+    #[test]
+    fn test_similarity_identical() {
+        assert_eq!(similarity("hello", "hello"), 1.0);
+    }
+
+    #[test]
+    fn test_similarity_completely_different() {
+        assert_eq!(similarity("abc", "xyz"), 0.0);
+    }
+
+    #[test]
+    fn test_similarity_empty_strings() {
+        // Both empty: union is 0, returns 1.0 by convention
+        assert_eq!(similarity("", ""), 1.0);
+    }
+
+    #[test]
+    fn test_similarity_partial_overlap() {
+        let s = similarity("abcd", "abef");
+        // Shared: a, b. Union: a, b, c, d, e, f = 6. Jaccard = 2/6
+        assert!((s - 2.0 / 6.0).abs() < f64::EPSILON);
+    }
+
+    #[test]
+    fn test_similarity_threshold_for_modified() {
+        // "let x = 1;" vs "let x = 2;" should be > 0.5 (treated as modification)
+        assert!(similarity("let x = 1;", "let x = 2;") > 0.5);
+    }
+
+    // --- truncate ---
+
+    #[test]
+    fn test_truncate_short_string() {
+        assert_eq!(truncate("hello", 10), "hello");
+    }
+
+    #[test]
+    fn test_truncate_exact_length() {
+        assert_eq!(truncate("hello", 5), "hello");
+    }
+
+    #[test]
+    fn test_truncate_long_string() {
+        assert_eq!(truncate("hello world!", 8), "hello...");
+    }
+
+    // --- compute_diff ---
+
+    #[test]
+    fn test_compute_diff_identical() {
+        let a = vec!["line1", "line2", "line3"];
+        let b = vec!["line1", "line2", "line3"];
+        let result = compute_diff(&a, &b);
+        assert_eq!(result.added, 0);
+        assert_eq!(result.removed, 0);
+        assert_eq!(result.modified, 0);
+        assert!(result.changes.is_empty());
+    }
+
+    #[test]
+    fn test_compute_diff_added_lines() {
+        let a = vec!["line1"];
+        let b = vec!["line1", "line2", "line3"];
+        let result = compute_diff(&a, &b);
+        assert_eq!(result.added, 2);
+        assert_eq!(result.removed, 0);
+    }
+
+    #[test]
+    fn test_compute_diff_removed_lines() {
+        let a = vec!["line1", "line2", "line3"];
+        let b = vec!["line1"];
+        let result = compute_diff(&a, &b);
+        assert_eq!(result.removed, 2);
+        assert_eq!(result.added, 0);
+    }
+
+    #[test]
+    fn test_compute_diff_modified_line() {
+        // Similar lines (>0.5 similarity) are classified as modified
+        let a = vec!["let x = 1;"];
+        let b = vec!["let x = 2;"];
+        let result = compute_diff(&a, &b);
+        assert_eq!(result.modified, 1);
+        assert_eq!(result.added, 0);
+        assert_eq!(result.removed, 0);
+    }
+
+    #[test]
+    fn test_compute_diff_completely_different_line() {
+        // Dissimilar lines (<= 0.5 similarity) are added+removed, not modified
+        let a = vec!["aaaa"];
+        let b = vec!["zzzz"];
+        let result = compute_diff(&a, &b);
+        assert_eq!(result.modified, 0);
+        assert_eq!(result.added, 1);
+        assert_eq!(result.removed, 1);
+    }
+
+    #[test]
+    fn test_compute_diff_empty_inputs() {
+        let result = compute_diff(&[], &[]);
+        assert_eq!(result.added, 0);
+        assert_eq!(result.removed, 0);
+        assert!(result.changes.is_empty());
+    }
+
+    // --- condense_unified_diff ---
+
+    #[test]
+    fn test_condense_unified_diff_single_file() {
+        let diff = r#"diff --git a/src/main.rs b/src/main.rs
+--- a/src/main.rs
++++ b/src/main.rs
+@@ -1,3 +1,4 @@
+ fn main() {
++    println!("hello");
+     println!("world");
+ }
+"#;
+        let result = condense_unified_diff(diff);
+        assert!(result.contains("src/main.rs"));
+        assert!(result.contains("+1"));
+        assert!(result.contains("println"));
+    }
+
+    #[test]
+    fn test_condense_unified_diff_multiple_files() {
+        let diff = r#"diff --git a/a.rs b/a.rs
+--- a/a.rs
++++ b/a.rs
++added line
+diff --git a/b.rs b/b.rs
+--- a/b.rs
++++ b/b.rs
+-removed line
+"#;
+        let result = condense_unified_diff(diff);
+        assert!(result.contains("a.rs"));
+        assert!(result.contains("b.rs"));
+    }
+
+    #[test]
+    fn test_condense_unified_diff_empty() {
+        let result = condense_unified_diff("");
+        assert!(result.is_empty());
+    }
+}

package/temp/rtk/src/discover/mod.rs

@@ -0,0 +1,274 @@
+pub mod provider;
+pub mod registry;
+mod report;
+pub mod rules;
+
+use anyhow::Result;
+use std::collections::HashMap;
+
+use provider::{ClaudeProvider, SessionProvider};
+use registry::{
+    category_avg_tokens, classify_command, has_rtk_disabled_prefix, split_command_chain,
+    strip_disabled_prefix, Classification,
+};
+use report::{DiscoverReport, SupportedEntry, UnsupportedEntry};
+
+/// Aggregation bucket for supported commands.
+struct SupportedBucket {
+    rtk_equivalent: &'static str,
+    category: &'static str,
+    count: usize,
+    total_output_tokens: usize,
+    savings_pct: f64,
+    // For display: the most common raw command
+    command_counts: HashMap<String, usize>,
+}
+
+/// Aggregation bucket for unsupported commands.
+struct UnsupportedBucket {
+    count: usize,
+    example: String,
+}
+
+pub fn run(
+    project: Option<&str>,
+    all: bool,
+    since_days: u64,
+    limit: usize,
+    format: &str,
+    verbose: u8,
+) -> Result<()> {
+    let provider = ClaudeProvider;
+
+    // Determine project filter
+    let project_filter = if all {
+        None
+    } else if let Some(p) = project {
+        Some(p.to_string())
+    } else {
+        // Default: current working directory
+        let cwd = std::env::current_dir()?;
+        let cwd_str = cwd.to_string_lossy().to_string();
+        let encoded = ClaudeProvider::encode_project_path(&cwd_str);
+        Some(encoded)
+    };
+
+    let sessions = provider.discover_sessions(project_filter.as_deref(), Some(since_days))?;
+
+    if verbose > 0 {
+        eprintln!("Scanning {} session files...", sessions.len());
+        for s in &sessions {
+            eprintln!("  {}", s.display());
+        }
+    }
+
+    let mut total_commands: usize = 0;
+    let mut already_rtk: usize = 0;
+    let mut parse_errors: usize = 0;
+    let mut rtk_disabled_count: usize = 0;
+    let mut rtk_disabled_cmds: HashMap<String, usize> = HashMap::new();
+    let mut supported_map: HashMap<&'static str, SupportedBucket> = HashMap::new();
+    let mut unsupported_map: HashMap<String, UnsupportedBucket> = HashMap::new();
+
+    for session_path in &sessions {
+        let extracted = match provider.extract_commands(session_path) {
+            Ok(cmds) => cmds,
+            Err(e) => {
+                if verbose > 0 {
+                    eprintln!("Warning: skipping {}: {}", session_path.display(), e);
+                }
+                parse_errors += 1;
+                continue;
+            }
+        };
+
+        for ext_cmd in &extracted {
+            let parts = split_command_chain(&ext_cmd.command);
+            for part in parts {
+                total_commands += 1;
+
+                // Detect RTK_DISABLED= bypass before classification
+                if has_rtk_disabled_prefix(part) {
+                    let actual_cmd = strip_disabled_prefix(part);
+                    // Only count if the underlying command is one RTK supports
+                    match classify_command(actual_cmd) {
+                        Classification::Supported { .. } => {
+                            rtk_disabled_count += 1;
+                            let display = truncate_command(actual_cmd);
+                            *rtk_disabled_cmds.entry(display).or_insert(0) += 1;
+                        }
+                        _ => {
+                            // RTK_DISABLED on unsupported/ignored command — not interesting
+                        }
+                    }
+                    continue;
+                }
+
+                match classify_command(part) {
+                    Classification::Supported {
+                        rtk_equivalent,
+                        category,
+                        estimated_savings_pct,
+                        status,
+                    } => {
+                        let bucket = supported_map.entry(rtk_equivalent).or_insert_with(|| {
+                            SupportedBucket {
+                                rtk_equivalent,
+                                category,
+                                count: 0,
+                                total_output_tokens: 0,
+                                savings_pct: estimated_savings_pct,
+                                command_counts: HashMap::new(),
+                            }
+                        });
+
+                        bucket.count += 1;
+
+                        // Estimate tokens for this command
+                        let output_tokens = if let Some(len) = ext_cmd.output_len {
+                            // Real: from tool_result content length
+                            len / 4
+                        } else {
+                            // Fallback: category average
+                            let subcmd = extract_subcmd(part);
+                            category_avg_tokens(category, subcmd)
+                        };
+
+                        let savings =
+                            (output_tokens as f64 * estimated_savings_pct / 100.0) as usize;
+                        bucket.total_output_tokens += savings;
+
+                        // Track the display name with status
+                        let display_name = truncate_command(part);
+                        let entry = bucket
+                            .command_counts
+                            .entry(format!("{}:{:?}", display_name, status))
+                            .or_insert(0);
+                        *entry += 1;
+                    }
+                    Classification::Unsupported { base_command } => {
+                        let bucket = unsupported_map.entry(base_command).or_insert_with(|| {
+                            UnsupportedBucket {
+                                count: 0,
+                                example: part.to_string(),
+                            }
+                        });
+                        bucket.count += 1;
+                    }
+                    Classification::Ignored => {
+                        // Check if it starts with "rtk "
+                        if part.trim().starts_with("rtk ") {
+                            already_rtk += 1;
+                        }
+                        // Otherwise just skip
+                    }
+                }
+            }
+        }
+    }
+
+    // Build report
+    let mut supported: Vec<SupportedEntry> = supported_map
+        .into_values()
+        .map(|bucket| {
+            // Pick the most common command as the display name
+            let (command_with_status, status) = bucket
+                .command_counts
+                .into_iter()
+                .max_by_key(|(_, c)| *c)
+                .map(|(name, _)| {
+                    // Extract status from "command:Status" format
+                    if let Some(colon_pos) = name.rfind(':') {
+                        let cmd = name[..colon_pos].to_string();
+                        let status_str = &name[colon_pos + 1..];
+                        let status = match status_str {
+                            "Passthrough" => report::RtkStatus::Passthrough,
+                            "NotSupported" => report::RtkStatus::NotSupported,
+                            _ => report::RtkStatus::Existing,
+                        };
+                        (cmd, status)
+                    } else {
+                        (name, report::RtkStatus::Existing)
+                    }
+                })
+                .unwrap_or_else(|| (String::new(), report::RtkStatus::Existing));
+
+            SupportedEntry {
+                command: command_with_status,
+                count: bucket.count,
+                rtk_equivalent: bucket.rtk_equivalent,
+                category: bucket.category,
+                estimated_savings_tokens: bucket.total_output_tokens,
+                estimated_savings_pct: bucket.savings_pct,
+                rtk_status: status,
+            }
+        })
+        .collect();
+
+    // Sort by estimated savings descending
+    supported.sort_by(|a, b| b.estimated_savings_tokens.cmp(&a.estimated_savings_tokens));
+
+    let mut unsupported: Vec<UnsupportedEntry> = unsupported_map
+        .into_iter()
+        .map(|(base, bucket)| UnsupportedEntry {
+            base_command: base,
+            count: bucket.count,
+            example: bucket.example,
+        })
+        .collect();
+
+    // Sort by count descending
+    unsupported.sort_by(|a, b| b.count.cmp(&a.count));
+
+    // Build RTK_DISABLED examples sorted by frequency (top 5)
+    let rtk_disabled_examples: Vec<String> = {
+        let mut sorted: Vec<_> = rtk_disabled_cmds.into_iter().collect();
+        sorted.sort_by(|a, b| b.1.cmp(&a.1).then_with(|| a.0.cmp(&b.0)));
+        sorted
+            .into_iter()
+            .take(5)
+            .map(|(cmd, count)| format!("{} ({}x)", cmd, count))
+            .collect()
+    };
+
+    let report = DiscoverReport {
+        sessions_scanned: sessions.len(),
+        total_commands,
+        already_rtk,
+        since_days,
+        supported,
+        unsupported,
+        parse_errors,
+        rtk_disabled_count,
+        rtk_disabled_examples,
+    };
+
+    match format {
+        "json" => println!("{}", report::format_json(&report)),
+        _ => print!("{}", report::format_text(&report, limit, verbose > 0)),
+    }
+
+    Ok(())
+}
+
+/// Extract the subcommand from a command string (second word).
+fn extract_subcmd(cmd: &str) -> &str {
+    let parts: Vec<&str> = cmd.trim().splitn(3, char::is_whitespace).collect();
+    if parts.len() >= 2 {
+        parts[1]
+    } else {
+        ""
+    }
+}
+
+/// Truncate a command for display (keep first meaningful portion).
+fn truncate_command(cmd: &str) -> String {
+    let trimmed = cmd.trim();
+    // Keep first two words for display
+    let parts: Vec<&str> = trimmed.splitn(3, char::is_whitespace).collect();
+    match parts.len() {
+        0 => String::new(),
+        1 => parts[0].to_string(),
+        _ => format!("{} {}", parts[0], parts[1]),
+    }
+}