@hasna/terminal 2.2.0 → 2.3.0

package/temp/rtk/src/parser/types.rs

@@ -0,0 +1,119 @@
+/// Canonical types for tool outputs
+/// These provide a unified interface across different tool versions
+use serde::{Deserialize, Serialize};
+
+/// Test execution result (vitest, playwright, jest, etc.)
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct TestResult {
+    pub total: usize,
+    pub passed: usize,
+    pub failed: usize,
+    pub skipped: usize,
+    pub duration_ms: Option<u64>,
+    pub failures: Vec<TestFailure>,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct TestFailure {
+    pub test_name: String,
+    pub file_path: String,
+    pub error_message: String,
+    pub stack_trace: Option<String>,
+}
+
+/// Linting result (eslint, biome, tsc, etc.)
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct LintResult {
+    pub total_files: usize,
+    pub files_with_issues: usize,
+    pub total_issues: usize,
+    pub errors: usize,
+    pub warnings: usize,
+    pub issues: Vec<LintIssue>,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct LintIssue {
+    pub file_path: String,
+    pub line: usize,
+    pub column: usize,
+    pub severity: LintSeverity,
+    pub rule_id: String,
+    pub message: String,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
+pub enum LintSeverity {
+    Error,
+    Warning,
+    Info,
+}
+
+/// Dependency state (pnpm, npm, cargo, etc.)
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct DependencyState {
+    pub total_packages: usize,
+    pub outdated_count: usize,
+    pub dependencies: Vec<Dependency>,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct Dependency {
+    pub name: String,
+    pub current_version: String,
+    pub latest_version: Option<String>,
+    pub wanted_version: Option<String>,
+    pub dev_dependency: bool,
+}
+
+/// Build output (next, webpack, vite, cargo, etc.)
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct BuildOutput {
+    pub success: bool,
+    pub duration_ms: Option<u64>,
+    pub warnings: usize,
+    pub errors: usize,
+    pub bundles: Vec<BundleInfo>,
+    pub routes: Vec<RouteInfo>,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct BundleInfo {
+    pub name: String,
+    pub size_bytes: u64,
+    pub gzip_size_bytes: Option<u64>,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct RouteInfo {
+    pub path: String,
+    pub size_kb: f64,
+    pub first_load_js_kb: Option<f64>,
+}
+
+/// Git operation result
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct GitResult {
+    pub operation: String,
+    pub files_changed: usize,
+    pub insertions: usize,
+    pub deletions: usize,
+    pub commits: Vec<GitCommit>,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct GitCommit {
+    pub hash: String,
+    pub author: String,
+    pub message: String,
+    pub timestamp: Option<String>,
+}
+
+/// Generic command output (for tools without specific types)
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct GenericOutput {
+    pub exit_code: i32,
+    pub stdout: String,
+    pub stderr: String,
+    pub summary: Option<String>,
+}

package/temp/rtk/src/pip_cmd.rs

@@ -0,0 +1,302 @@
+use crate::tracking;
+use anyhow::{Context, Result};
+use serde::Deserialize;
+use std::process::Command;
+
+#[derive(Debug, Deserialize)]
+struct Package {
+    name: String,
+    version: String,
+    #[serde(default)]
+    latest_version: Option<String>,
+}
+
+pub fn run(args: &[String], verbose: u8) -> Result<()> {
+    let timer = tracking::TimedExecution::start();
+
+    // Auto-detect uv vs pip
+    let use_uv = which_command("uv").is_some();
+    let base_cmd = if use_uv { "uv" } else { "pip" };
+
+    if verbose > 0 && use_uv {
+        eprintln!("Using uv (pip-compatible)");
+    }
+
+    // Detect subcommand
+    let subcommand = args.first().map(|s| s.as_str()).unwrap_or("");
+
+    let (cmd_str, filtered) = match subcommand {
+        "list" => run_list(base_cmd, &args[1..], verbose)?,
+        "outdated" => run_outdated(base_cmd, &args[1..], verbose)?,
+        "install" | "uninstall" | "show" => {
+            // Passthrough for write operations
+            run_passthrough(base_cmd, args, verbose)?
+        }
+        _ => {
+            anyhow::bail!(
+                "rtk pip: unsupported subcommand '{}'\nSupported: list, outdated, install, uninstall, show",
+                subcommand
+            );
+        }
+    };
+
+    timer.track(
+        &format!("{} {}", base_cmd, args.join(" ")),
+        &format!("rtk {} {}", base_cmd, args.join(" ")),
+        &cmd_str,
+        &filtered,
+    );
+
+    Ok(())
+}
+
+fn run_list(base_cmd: &str, args: &[String], verbose: u8) -> Result<(String, String)> {
+    let mut cmd = Command::new(base_cmd);
+
+    if base_cmd == "uv" {
+        cmd.arg("pip");
+    }
+
+    cmd.arg("list").arg("--format=json");
+
+    for arg in args {
+        cmd.arg(arg);
+    }
+
+    if verbose > 0 {
+        eprintln!("Running: {} pip list --format=json", base_cmd);
+    }
+
+    let output = cmd
+        .output()
+        .with_context(|| format!("Failed to run {} pip list", base_cmd))?;
+
+    let stdout = String::from_utf8_lossy(&output.stdout);
+    let stderr = String::from_utf8_lossy(&output.stderr);
+    let raw = format!("{}\n{}", stdout, stderr);
+
+    let filtered = filter_pip_list(&stdout);
+    println!("{}", filtered);
+
+    if !output.status.success() {
+        std::process::exit(output.status.code().unwrap_or(1));
+    }
+
+    Ok((raw, filtered))
+}
+
+fn run_outdated(base_cmd: &str, args: &[String], verbose: u8) -> Result<(String, String)> {
+    let mut cmd = Command::new(base_cmd);
+
+    if base_cmd == "uv" {
+        cmd.arg("pip");
+    }
+
+    cmd.arg("list").arg("--outdated").arg("--format=json");
+
+    for arg in args {
+        cmd.arg(arg);
+    }
+
+    if verbose > 0 {
+        eprintln!("Running: {} pip list --outdated --format=json", base_cmd);
+    }
+
+    let output = cmd
+        .output()
+        .with_context(|| format!("Failed to run {} pip list --outdated", base_cmd))?;
+
+    let stdout = String::from_utf8_lossy(&output.stdout);
+    let stderr = String::from_utf8_lossy(&output.stderr);
+    let raw = format!("{}\n{}", stdout, stderr);
+
+    let filtered = filter_pip_outdated(&stdout);
+    println!("{}", filtered);
+
+    if !output.status.success() {
+        std::process::exit(output.status.code().unwrap_or(1));
+    }
+
+    Ok((raw, filtered))
+}
+
+fn run_passthrough(base_cmd: &str, args: &[String], verbose: u8) -> Result<(String, String)> {
+    let mut cmd = Command::new(base_cmd);
+
+    if base_cmd == "uv" {
+        cmd.arg("pip");
+    }
+
+    for arg in args {
+        cmd.arg(arg);
+    }
+
+    if verbose > 0 {
+        eprintln!("Running: {} pip {}", base_cmd, args.join(" "));
+    }
+
+    let output = cmd
+        .output()
+        .with_context(|| format!("Failed to run {} pip {}", base_cmd, args.join(" ")))?;
+
+    let stdout = String::from_utf8_lossy(&output.stdout);
+    let stderr = String::from_utf8_lossy(&output.stderr);
+    let raw = format!("{}\n{}", stdout, stderr);
+
+    print!("{}", stdout);
+    eprint!("{}", stderr);
+
+    if !output.status.success() {
+        std::process::exit(output.status.code().unwrap_or(1));
+    }
+
+    Ok((raw.clone(), raw))
+}
+
+/// Check if a command exists in PATH
+fn which_command(cmd: &str) -> Option<String> {
+    Command::new("which")
+        .arg(cmd)
+        .output()
+        .ok()
+        .filter(|o| o.status.success())
+        .and_then(|o| String::from_utf8(o.stdout).ok())
+        .map(|s| s.trim().to_string())
+        .filter(|s| !s.is_empty())
+}
+
+/// Filter pip list JSON output
+fn filter_pip_list(output: &str) -> String {
+    let packages: Vec<Package> = match serde_json::from_str(output) {
+        Ok(p) => p,
+        Err(e) => {
+            return format!("pip list (JSON parse failed: {})", e);
+        }
+    };
+
+    if packages.is_empty() {
+        return "pip list: No packages installed".to_string();
+    }
+
+    let mut result = String::new();
+    result.push_str(&format!("pip list: {} packages\n", packages.len()));
+    result.push_str("═══════════════════════════════════════\n");
+
+    // Group by first letter for easier scanning
+    let mut by_letter: std::collections::HashMap<char, Vec<&Package>> =
+        std::collections::HashMap::new();
+
+    for pkg in &packages {
+        let first_char = pkg.name.chars().next().unwrap_or('?').to_ascii_lowercase();
+        by_letter.entry(first_char).or_default().push(pkg);
+    }
+
+    let mut letters: Vec<_> = by_letter.keys().collect();
+    letters.sort();
+
+    for letter in letters {
+        let pkgs = by_letter.get(letter).unwrap();
+        result.push_str(&format!("\n[{}]\n", letter.to_uppercase()));
+
+        for pkg in pkgs.iter().take(10) {
+            result.push_str(&format!("  {} ({})\n", pkg.name, pkg.version));
+        }
+
+        if pkgs.len() > 10 {
+            result.push_str(&format!("  ... +{} more\n", pkgs.len() - 10));
+        }
+    }
+
+    result.trim().to_string()
+}
+
+/// Filter pip outdated JSON output
+fn filter_pip_outdated(output: &str) -> String {
+    let packages: Vec<Package> = match serde_json::from_str(output) {
+        Ok(p) => p,
+        Err(e) => {
+            return format!("pip outdated (JSON parse failed: {})", e);
+        }
+    };
+
+    if packages.is_empty() {
+        return "✓ pip outdated: All packages up to date".to_string();
+    }
+
+    let mut result = String::new();
+    result.push_str(&format!("pip outdated: {} packages\n", packages.len()));
+    result.push_str("═══════════════════════════════════════\n");
+
+    for (i, pkg) in packages.iter().take(20).enumerate() {
+        let latest = pkg
+            .latest_version
+            .as_ref()
+            .map(|v| v.as_str())
+            .unwrap_or("unknown");
+        result.push_str(&format!(
+            "{}. {} ({} → {})\n",
+            i + 1,
+            pkg.name,
+            pkg.version,
+            latest
+        ));
+    }
+
+    if packages.len() > 20 {
+        result.push_str(&format!("\n... +{} more packages\n", packages.len() - 20));
+    }
+
+    result.push_str("\n💡 Run `pip install --upgrade <package>` to update\n");
+
+    result.trim().to_string()
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_filter_pip_list() {
+        let output = r#"[
+  {"name": "requests", "version": "2.31.0"},
+  {"name": "pytest", "version": "7.4.0"},
+  {"name": "rich", "version": "13.0.0"}
+]"#;
+
+        let result = filter_pip_list(output);
+        assert!(result.contains("3 packages"));
+        assert!(result.contains("requests"));
+        assert!(result.contains("2.31.0"));
+        assert!(result.contains("pytest"));
+    }
+
+    #[test]
+    fn test_filter_pip_list_empty() {
+        let output = "[]";
+        let result = filter_pip_list(output);
+        assert!(result.contains("No packages installed"));
+    }
+
+    #[test]
+    fn test_filter_pip_outdated_none() {
+        let output = "[]";
+        let result = filter_pip_outdated(output);
+        assert!(result.contains("✓"));
+        assert!(result.contains("All packages up to date"));
+    }
+
+    #[test]
+    fn test_filter_pip_outdated_some() {
+        let output = r#"[
+  {"name": "requests", "version": "2.31.0", "latest_version": "2.32.0"},
+  {"name": "pytest", "version": "7.4.0", "latest_version": "8.0.0"}
+]"#;
+
+        let result = filter_pip_outdated(output);
+        assert!(result.contains("2 packages"));
+        assert!(result.contains("requests"));
+        assert!(result.contains("2.31.0 → 2.32.0"));
+        assert!(result.contains("pytest"));
+        assert!(result.contains("7.4.0 → 8.0.0"));
+    }
+}