@hasna/terminal 2.2.0 → 2.3.0

package/temp/rtk/src/ccusage.rs

@@ -0,0 +1,340 @@
+//! ccusage CLI integration module
+//!
+//! Provides isolated interface to ccusage (npm package) for fetching
+//! Claude Code API usage metrics. Handles subprocess execution, JSON parsing,
+//! and graceful degradation when ccusage is unavailable.
+
+use anyhow::{Context, Result};
+use serde::Deserialize;
+use std::process::Command;
+
+// ── Public Types ──
+
+/// Metrics from ccusage for a single period (day/week/month)
+#[derive(Debug, Deserialize)]
+pub struct CcusageMetrics {
+    #[serde(rename = "inputTokens")]
+    pub input_tokens: u64,
+    #[serde(rename = "outputTokens")]
+    pub output_tokens: u64,
+    #[serde(rename = "cacheCreationTokens", default)]
+    pub cache_creation_tokens: u64,
+    #[serde(rename = "cacheReadTokens", default)]
+    pub cache_read_tokens: u64,
+    #[serde(rename = "totalTokens")]
+    pub total_tokens: u64,
+    #[serde(rename = "totalCost")]
+    pub total_cost: f64,
+}
+
+/// Period data with key (date/month/week) and metrics
+#[derive(Debug)]
+pub struct CcusagePeriod {
+    pub key: String, // "2026-01-30" (daily), "2026-01" (monthly), "2026-01-20" (weekly ISO monday)
+    pub metrics: CcusageMetrics,
+}
+
+/// Time granularity for ccusage reports
+#[derive(Debug, Clone, Copy)]
+pub enum Granularity {
+    Daily,
+    Weekly,
+    Monthly,
+}
+
+// ── Internal Types for JSON Deserialization ──
+
+#[derive(Debug, Deserialize)]
+struct DailyResponse {
+    daily: Vec<DailyEntry>,
+}
+
+#[derive(Debug, Deserialize)]
+struct DailyEntry {
+    date: String,
+    #[serde(flatten)]
+    metrics: CcusageMetrics,
+}
+
+#[derive(Debug, Deserialize)]
+struct WeeklyResponse {
+    weekly: Vec<WeeklyEntry>,
+}
+
+#[derive(Debug, Deserialize)]
+struct WeeklyEntry {
+    week: String, // ISO week start (Monday)
+    #[serde(flatten)]
+    metrics: CcusageMetrics,
+}
+
+#[derive(Debug, Deserialize)]
+struct MonthlyResponse {
+    monthly: Vec<MonthlyEntry>,
+}
+
+#[derive(Debug, Deserialize)]
+struct MonthlyEntry {
+    month: String,
+    #[serde(flatten)]
+    metrics: CcusageMetrics,
+}
+
+// ── Public API ──
+
+/// Check if ccusage binary exists in PATH
+fn binary_exists() -> bool {
+    Command::new("which")
+        .arg("ccusage")
+        .output()
+        .map(|o| o.status.success())
+        .unwrap_or(false)
+}
+
+/// Build the ccusage command, falling back to npx if binary not in PATH
+fn build_command() -> Option<Command> {
+    if binary_exists() {
+        return Some(Command::new("ccusage"));
+    }
+
+    // Fallback: try npx
+    let npx_check = Command::new("npx")
+        .arg("ccusage")
+        .arg("--help")
+        .stdout(std::process::Stdio::null())
+        .stderr(std::process::Stdio::null())
+        .status();
+
+    if npx_check.map(|s| s.success()).unwrap_or(false) {
+        let mut cmd = Command::new("npx");
+        cmd.arg("ccusage");
+        return Some(cmd);
+    }
+
+    None
+}
+
+/// Check if ccusage CLI is available (binary or via npx)
+pub fn is_available() -> bool {
+    build_command().is_some()
+}
+
+/// Fetch usage data from ccusage for the last 90 days
+///
+/// Returns `Ok(None)` if ccusage is unavailable (graceful degradation)
+/// Returns `Ok(Some(vec))` with parsed data on success
+/// Returns `Err` only on unexpected failures (JSON parse, etc.)
+pub fn fetch(granularity: Granularity) -> Result<Option<Vec<CcusagePeriod>>> {
+    let mut cmd = match build_command() {
+        Some(cmd) => cmd,
+        None => {
+            eprintln!("⚠️  ccusage not found. Install: npm i -g ccusage (or use npx ccusage)");
+            return Ok(None);
+        }
+    };
+
+    let subcommand = match granularity {
+        Granularity::Daily => "daily",
+        Granularity::Weekly => "weekly",
+        Granularity::Monthly => "monthly",
+    };
+
+    let output = cmd
+        .arg(subcommand)
+        .arg("--json")
+        .arg("--since")
+        .arg("20250101") // 90 days back approx
+        .output();
+
+    let output = match output {
+        Err(e) => {
+            eprintln!("⚠️  ccusage execution failed: {}", e);
+            return Ok(None);
+        }
+        Ok(o) => o,
+    };
+
+    if !output.status.success() {
+        let stderr = String::from_utf8_lossy(&output.stderr);
+        eprintln!(
+            "⚠️  ccusage exited with {}: {}",
+            output.status,
+            stderr.trim()
+        );
+        return Ok(None);
+    }
+
+    let stdout = String::from_utf8_lossy(&output.stdout);
+    let periods =
+        parse_json(&stdout, granularity).context("Failed to parse ccusage JSON output")?;
+
+    Ok(Some(periods))
+}
+
+// ── Internal Helpers ──
+
+fn parse_json(json: &str, granularity: Granularity) -> Result<Vec<CcusagePeriod>> {
+    match granularity {
+        Granularity::Daily => {
+            let resp: DailyResponse =
+                serde_json::from_str(json).context("Invalid JSON structure for daily data")?;
+            Ok(resp
+                .daily
+                .into_iter()
+                .map(|e| CcusagePeriod {
+                    key: e.date,
+                    metrics: e.metrics,
+                })
+                .collect())
+        }
+        Granularity::Weekly => {
+            let resp: WeeklyResponse =
+                serde_json::from_str(json).context("Invalid JSON structure for weekly data")?;
+            Ok(resp
+                .weekly
+                .into_iter()
+                .map(|e| CcusagePeriod {
+                    key: e.week,
+                    metrics: e.metrics,
+                })
+                .collect())
+        }
+        Granularity::Monthly => {
+            let resp: MonthlyResponse =
+                serde_json::from_str(json).context("Invalid JSON structure for monthly data")?;
+            Ok(resp
+                .monthly
+                .into_iter()
+                .map(|e| CcusagePeriod {
+                    key: e.month,
+                    metrics: e.metrics,
+                })
+                .collect())
+        }
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_parse_monthly_valid() {
+        let json = r#"{
+            "monthly": [
+                {
+                    "month": "2026-01",
+                    "inputTokens": 1000,
+                    "outputTokens": 500,
+                    "cacheCreationTokens": 100,
+                    "cacheReadTokens": 200,
+                    "totalTokens": 1800,
+                    "totalCost": 12.34
+                }
+            ]
+        }"#;
+
+        let result = parse_json(json, Granularity::Monthly);
+        assert!(result.is_ok());
+        let periods = result.unwrap();
+        assert_eq!(periods.len(), 1);
+        assert_eq!(periods[0].key, "2026-01");
+        assert_eq!(periods[0].metrics.input_tokens, 1000);
+        assert_eq!(periods[0].metrics.total_cost, 12.34);
+    }
+
+    #[test]
+    fn test_parse_daily_valid() {
+        let json = r#"{
+            "daily": [
+                {
+                    "date": "2026-01-30",
+                    "inputTokens": 100,
+                    "outputTokens": 50,
+                    "cacheCreationTokens": 0,
+                    "cacheReadTokens": 0,
+                    "totalTokens": 150,
+                    "totalCost": 0.15
+                }
+            ]
+        }"#;
+
+        let result = parse_json(json, Granularity::Daily);
+        assert!(result.is_ok());
+        let periods = result.unwrap();
+        assert_eq!(periods.len(), 1);
+        assert_eq!(periods[0].key, "2026-01-30");
+    }
+
+    #[test]
+    fn test_parse_weekly_valid() {
+        let json = r#"{
+            "weekly": [
+                {
+                    "week": "2026-01-20",
+                    "inputTokens": 500,
+                    "outputTokens": 250,
+                    "cacheCreationTokens": 50,
+                    "cacheReadTokens": 100,
+                    "totalTokens": 900,
+                    "totalCost": 5.67
+                }
+            ]
+        }"#;
+
+        let result = parse_json(json, Granularity::Weekly);
+        assert!(result.is_ok());
+        let periods = result.unwrap();
+        assert_eq!(periods.len(), 1);
+        assert_eq!(periods[0].key, "2026-01-20");
+    }
+
+    #[test]
+    fn test_parse_malformed_json() {
+        let json = r#"{ "monthly": [ { "broken": }"#;
+        let result = parse_json(json, Granularity::Monthly);
+        assert!(result.is_err());
+    }
+
+    #[test]
+    fn test_parse_missing_required_fields() {
+        let json = r#"{
+            "monthly": [
+                {
+                    "month": "2026-01",
+                    "inputTokens": 100
+                }
+            ]
+        }"#;
+        let result = parse_json(json, Granularity::Monthly);
+        assert!(result.is_err()); // Missing required fields like totalTokens
+    }
+
+    #[test]
+    fn test_parse_default_cache_fields() {
+        let json = r#"{
+            "monthly": [
+                {
+                    "month": "2026-01",
+                    "inputTokens": 100,
+                    "outputTokens": 50,
+                    "totalTokens": 150,
+                    "totalCost": 1.0
+                }
+            ]
+        }"#;
+
+        let result = parse_json(json, Granularity::Monthly);
+        assert!(result.is_ok());
+        let periods = result.unwrap();
+        assert_eq!(periods[0].metrics.cache_creation_tokens, 0); // default
+        assert_eq!(periods[0].metrics.cache_read_tokens, 0);
+    }
+
+    #[test]
+    fn test_is_available() {
+        // Just smoke test - actual availability depends on system
+        let _available = is_available();
+        // No assertion - just ensure it doesn't panic
+    }
+}

package/temp/rtk/src/config.rs

@@ -0,0 +1,187 @@
+use anyhow::Result;
+use serde::{Deserialize, Serialize};
+use std::path::PathBuf;
+
+#[derive(Debug, Serialize, Deserialize, Default)]
+pub struct Config {
+    #[serde(default)]
+    pub tracking: TrackingConfig,
+    #[serde(default)]
+    pub display: DisplayConfig,
+    #[serde(default)]
+    pub filters: FilterConfig,
+    #[serde(default)]
+    pub tee: crate::tee::TeeConfig,
+    #[serde(default)]
+    pub telemetry: TelemetryConfig,
+    #[serde(default)]
+    pub hooks: HooksConfig,
+}
+
+#[derive(Debug, Serialize, Deserialize, Default)]
+pub struct HooksConfig {
+    /// Commands to exclude from auto-rewrite (e.g. ["curl", "playwright"]).
+    /// Survives `rtk init -g` re-runs since config.toml is user-owned.
+    #[serde(default)]
+    pub exclude_commands: Vec<String>,
+}
+
+#[derive(Debug, Serialize, Deserialize)]
+pub struct TrackingConfig {
+    pub enabled: bool,
+    pub history_days: u32,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub database_path: Option<PathBuf>,
+}
+
+impl Default for TrackingConfig {
+    fn default() -> Self {
+        Self {
+            enabled: true,
+            history_days: 90,
+            database_path: None,
+        }
+    }
+}
+
+#[derive(Debug, Serialize, Deserialize)]
+pub struct DisplayConfig {
+    pub colors: bool,
+    pub emoji: bool,
+    pub max_width: usize,
+}
+
+impl Default for DisplayConfig {
+    fn default() -> Self {
+        Self {
+            colors: true,
+            emoji: true,
+            max_width: 120,
+        }
+    }
+}
+
+#[derive(Debug, Serialize, Deserialize)]
+pub struct FilterConfig {
+    pub ignore_dirs: Vec<String>,
+    pub ignore_files: Vec<String>,
+}
+
+impl Default for FilterConfig {
+    fn default() -> Self {
+        Self {
+            ignore_dirs: vec![
+                ".git".into(),
+                "node_modules".into(),
+                "target".into(),
+                "__pycache__".into(),
+                ".venv".into(),
+                "vendor".into(),
+            ],
+            ignore_files: vec!["*.lock".into(), "*.min.js".into(), "*.min.css".into()],
+        }
+    }
+}
+
+#[derive(Debug, Serialize, Deserialize)]
+pub struct TelemetryConfig {
+    pub enabled: bool,
+}
+
+impl Default for TelemetryConfig {
+    fn default() -> Self {
+        Self { enabled: true }
+    }
+}
+
+/// Check if telemetry is enabled in config. Returns None if config can't be loaded.
+pub fn telemetry_enabled() -> Option<bool> {
+    Config::load().ok().map(|c| c.telemetry.enabled)
+}
+
+impl Config {
+    pub fn load() -> Result<Self> {
+        let path = get_config_path()?;
+
+        if path.exists() {
+            let content = std::fs::read_to_string(&path)?;
+            let config: Config = toml::from_str(&content)?;
+            Ok(config)
+        } else {
+            Ok(Config::default())
+        }
+    }
+
+    pub fn save(&self) -> Result<()> {
+        let path = get_config_path()?;
+
+        if let Some(parent) = path.parent() {
+            std::fs::create_dir_all(parent)?;
+        }
+
+        let content = toml::to_string_pretty(self)?;
+        std::fs::write(&path, content)?;
+        Ok(())
+    }
+
+    pub fn create_default() -> Result<PathBuf> {
+        let config = Config::default();
+        config.save()?;
+        get_config_path()
+    }
+}
+
+fn get_config_path() -> Result<PathBuf> {
+    let config_dir = dirs::config_dir().unwrap_or_else(|| PathBuf::from("."));
+    Ok(config_dir.join("rtk").join("config.toml"))
+}
+
+pub fn show_config() -> Result<()> {
+    let path = get_config_path()?;
+    println!("Config: {}", path.display());
+    println!();
+
+    if path.exists() {
+        let config = Config::load()?;
+        println!("{}", toml::to_string_pretty(&config)?);
+    } else {
+        println!("(default config, file not created)");
+        println!();
+        let config = Config::default();
+        println!("{}", toml::to_string_pretty(&config)?);
+    }
+
+    Ok(())
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_hooks_config_deserialize() {
+        let toml = r#"
+[hooks]
+exclude_commands = ["curl", "gh"]
+"#;
+        let config: Config = toml::from_str(toml).expect("valid toml");
+        assert_eq!(config.hooks.exclude_commands, vec!["curl", "gh"]);
+    }
+
+    #[test]
+    fn test_hooks_config_default_empty() {
+        let config = Config::default();
+        assert!(config.hooks.exclude_commands.is_empty());
+    }
+
+    #[test]
+    fn test_config_without_hooks_section_is_valid() {
+        let toml = r#"
+[tracking]
+enabled = true
+history_days = 90
+"#;
+        let config: Config = toml::from_str(toml).expect("valid toml");
+        assert!(config.hooks.exclude_commands.is_empty());
+    }
+}