@hasna/terminal 2.3.0 → 2.3.1

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

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

@@ -1,302 +0,0 @@
-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"));
-    }
-}