@hasna/terminal 2.2.0 → 2.3.0

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

@@ -0,0 +1,202 @@
+use serde::Serialize;
+
+/// RTK support status for a command.
+#[derive(Debug, Serialize, Clone, Copy, PartialEq, Eq)]
+pub enum RtkStatus {
+    /// Dedicated handler with filtering (e.g., git status → git.rs:run_status())
+    Existing,
+    /// Works via external_subcommand passthrough, no filtering (e.g., cargo fmt → Other)
+    Passthrough,
+    /// RTK doesn't handle this command at all
+    NotSupported,
+}
+
+impl RtkStatus {
+    pub fn as_str(&self) -> &'static str {
+        match self {
+            RtkStatus::Existing => "existing",
+            RtkStatus::Passthrough => "passthrough",
+            RtkStatus::NotSupported => "not-supported",
+        }
+    }
+}
+
+/// A supported command that RTK already handles.
+#[derive(Debug, Serialize)]
+pub struct SupportedEntry {
+    pub command: String,
+    pub count: usize,
+    pub rtk_equivalent: &'static str,
+    pub category: &'static str,
+    pub estimated_savings_tokens: usize,
+    pub estimated_savings_pct: f64,
+    pub rtk_status: RtkStatus,
+}
+
+/// An unsupported command not yet handled by RTK.
+#[derive(Debug, Serialize)]
+pub struct UnsupportedEntry {
+    pub base_command: String,
+    pub count: usize,
+    pub example: String,
+}
+
+/// Full discover report.
+#[derive(Debug, Serialize)]
+pub struct DiscoverReport {
+    pub sessions_scanned: usize,
+    pub total_commands: usize,
+    pub already_rtk: usize,
+    pub since_days: u64,
+    pub supported: Vec<SupportedEntry>,
+    pub unsupported: Vec<UnsupportedEntry>,
+    pub parse_errors: usize,
+    pub rtk_disabled_count: usize,
+    pub rtk_disabled_examples: Vec<String>,
+}
+
+impl DiscoverReport {
+    pub fn total_saveable_tokens(&self) -> usize {
+        self.supported
+            .iter()
+            .map(|s| s.estimated_savings_tokens)
+            .sum()
+    }
+
+    pub fn total_supported_count(&self) -> usize {
+        self.supported.iter().map(|s| s.count).sum()
+    }
+}
+
+/// Format report as text.
+pub fn format_text(report: &DiscoverReport, limit: usize, verbose: bool) -> String {
+    let mut out = String::with_capacity(2048);
+
+    out.push_str("RTK Discover -- Savings Opportunities\n");
+    out.push_str(&"=".repeat(52));
+    out.push('\n');
+    out.push_str(&format!(
+        "Scanned: {} sessions (last {} days), {} Bash commands\n",
+        report.sessions_scanned, report.since_days, report.total_commands
+    ));
+    out.push_str(&format!(
+        "Already using RTK: {} commands ({}%)\n",
+        report.already_rtk,
+        if report.total_commands > 0 {
+            report.already_rtk * 100 / report.total_commands
+        } else {
+            0
+        }
+    ));
+
+    if report.supported.is_empty() && report.unsupported.is_empty() {
+        out.push_str("\nNo missed savings found. RTK usage looks good!\n");
+        return out;
+    }
+
+    // Missed savings
+    if !report.supported.is_empty() {
+        out.push_str("\nMISSED SAVINGS -- Commands RTK already handles\n");
+        out.push_str(&"-".repeat(72));
+        out.push('\n');
+        out.push_str(&format!(
+            "{:<24} {:>5}    {:<18} {:<13} {:>12}\n",
+            "Command", "Count", "RTK Equivalent", "Status", "Est. Savings"
+        ));
+
+        for entry in report.supported.iter().take(limit) {
+            out.push_str(&format!(
+                "{:<24} {:>5}    {:<18} {:<13} ~{}\n",
+                truncate_str(&entry.command, 23),
+                entry.count,
+                entry.rtk_equivalent,
+                entry.rtk_status.as_str(),
+                format_tokens(entry.estimated_savings_tokens),
+            ));
+        }
+
+        out.push_str(&"-".repeat(72));
+        out.push('\n');
+        out.push_str(&format!(
+            "Total: {} commands -> ~{} saveable\n",
+            report.total_supported_count(),
+            format_tokens(report.total_saveable_tokens()),
+        ));
+    }
+
+    // Unhandled
+    if !report.unsupported.is_empty() {
+        out.push_str("\nTOP UNHANDLED COMMANDS -- open an issue?\n");
+        out.push_str(&"-".repeat(52));
+        out.push('\n');
+        out.push_str(&format!(
+            "{:<24} {:>5}    {}\n",
+            "Command", "Count", "Example"
+        ));
+
+        for entry in report.unsupported.iter().take(limit) {
+            out.push_str(&format!(
+                "{:<24} {:>5}    {}\n",
+                truncate_str(&entry.base_command, 23),
+                entry.count,
+                truncate_str(&entry.example, 40),
+            ));
+        }
+
+        out.push_str(&"-".repeat(52));
+        out.push('\n');
+        out.push_str("-> github.com/rtk-ai/rtk/issues\n");
+    }
+
+    // RTK_DISABLED bypass warning
+    if report.rtk_disabled_count > 0 {
+        out.push_str(&format!(
+            "\nRTK_DISABLED BYPASS -- {} commands ran without filtering\n",
+            report.rtk_disabled_count
+        ));
+        out.push_str(&"-".repeat(72));
+        out.push('\n');
+        out.push_str("These commands used RTK_DISABLED=1 unnecessarily:\n");
+        if !report.rtk_disabled_examples.is_empty() {
+            out.push_str(&format!("  {}\n", report.rtk_disabled_examples.join(", ")));
+        }
+        out.push_str("-> Remove RTK_DISABLED=1 to recover token savings\n");
+    }
+
+    out.push_str("\n~estimated from tool_result output sizes\n");
+
+    if verbose && report.parse_errors > 0 {
+        out.push_str(&format!("Parse errors skipped: {}\n", report.parse_errors));
+    }
+
+    out
+}
+
+/// Format report as JSON.
+pub fn format_json(report: &DiscoverReport) -> String {
+    serde_json::to_string_pretty(report).unwrap_or_else(|_| "{}".to_string())
+}
+
+fn format_tokens(tokens: usize) -> String {
+    if tokens >= 1_000_000 {
+        format!("{:.1}M tokens", tokens as f64 / 1_000_000.0)
+    } else if tokens >= 1_000 {
+        format!("{:.1}K tokens", tokens as f64 / 1_000.0)
+    } else {
+        format!("{} tokens", tokens)
+    }
+}
+
+fn truncate_str(s: &str, max: usize) -> String {
+    if s.len() <= max {
+        s.to_string()
+    } else {
+        // UTF-8 safe truncation: collect chars up to max-2, then add ".."
+        let truncated: String = s
+            .char_indices()
+            .take_while(|(i, _)| *i < max.saturating_sub(2))
+            .map(|(_, c)| c)
+            .collect();
+        format!("{}..", truncated)
+    }
+}