@hasna/terminal 2.3.0 → 2.3.1

package/temp/rtk/src/diff_cmd.rs

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

@@ -1,274 +0,0 @@
-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]),
-    }
-}