@hasna/terminal 2.3.0 → 2.3.1

package/temp/rtk/src/curl_cmd.rs

@@ -1,134 +0,0 @@
-use crate::json_cmd;
-use crate::tracking;
-use crate::utils::truncate;
-use anyhow::{Context, Result};
-use std::process::Command;
-
-pub fn run(args: &[String], verbose: u8) -> Result<()> {
-    let timer = tracking::TimedExecution::start();
-    let mut cmd = Command::new("curl");
-    cmd.arg("-s"); // Silent mode (no progress bar)
-
-    for arg in args {
-        cmd.arg(arg);
-    }
-
-    if verbose > 0 {
-        eprintln!("Running: curl -s {}", args.join(" "));
-    }
-
-    let output = cmd.output().context("Failed to run curl")?;
-    let stdout = String::from_utf8_lossy(&output.stdout);
-    let stderr = String::from_utf8_lossy(&output.stderr);
-
-    if !output.status.success() {
-        let msg = if stderr.trim().is_empty() {
-            stdout.trim().to_string()
-        } else {
-            stderr.trim().to_string()
-        };
-        eprintln!("FAILED: curl {}", msg);
-        std::process::exit(output.status.code().unwrap_or(1));
-    }
-
-    let raw = stdout.to_string();
-
-    // Auto-detect JSON and pipe through filter
-    let filtered = filter_curl_output(&stdout);
-    println!("{}", filtered);
-
-    timer.track(
-        &format!("curl {}", args.join(" ")),
-        &format!("rtk curl {}", args.join(" ")),
-        &raw,
-        &filtered,
-    );
-
-    Ok(())
-}
-
-fn filter_curl_output(output: &str) -> String {
-    let trimmed = output.trim();
-
-    // Try JSON detection: starts with { or [
-    if (trimmed.starts_with('{') || trimmed.starts_with('['))
-        && (trimmed.ends_with('}') || trimmed.ends_with(']'))
-    {
-        if let Ok(schema) = json_cmd::filter_json_string(trimmed, 5) {
-            // Only use schema if it's actually shorter than the original (#297)
-            if schema.len() <= trimmed.len() {
-                return schema;
-            }
-        }
-    }
-
-    // Not JSON: truncate long output
-    let lines: Vec<&str> = trimmed.lines().collect();
-    if lines.len() > 30 {
-        let mut result: Vec<&str> = lines[..30].to_vec();
-        result.push("");
-        let msg = format!(
-            "... ({} more lines, {} bytes total)",
-            lines.len() - 30,
-            trimmed.len()
-        );
-        return format!("{}\n{}", result.join("\n"), msg);
-    }
-
-    // Short output: return as-is but truncate long lines
-    lines
-        .iter()
-        .map(|l| truncate(l, 200))
-        .collect::<Vec<_>>()
-        .join("\n")
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-
-    #[test]
-    fn test_filter_curl_json() {
-        // Large JSON where schema is shorter than original — schema should be returned
-        let output = r#"{"name": "a very long user name here", "count": 42, "items": [1, 2, 3], "description": "a very long description that takes up many characters in the original JSON payload", "status": "active", "url": "https://example.com/api/v1/users/123"}"#;
-        let result = filter_curl_output(output);
-        assert!(result.contains("name"));
-        assert!(result.contains("string"));
-        assert!(result.contains("int"));
-    }
-
-    #[test]
-    fn test_filter_curl_json_array() {
-        let output = r#"[{"id": 1}, {"id": 2}]"#;
-        let result = filter_curl_output(output);
-        assert!(result.contains("id"));
-    }
-
-    #[test]
-    fn test_filter_curl_non_json() {
-        let output = "Hello, World!\nThis is plain text.";
-        let result = filter_curl_output(output);
-        assert!(result.contains("Hello, World!"));
-        assert!(result.contains("plain text"));
-    }
-
-    #[test]
-    fn test_filter_curl_json_small_returns_original() {
-        // Small JSON where schema would be larger than original (issue #297)
-        let output = r#"{"r2Ready":true,"status":"ok"}"#;
-        let result = filter_curl_output(output);
-        // Schema would be "{\n  r2Ready: bool,\n  status: string\n}" which is longer
-        // Should return the original JSON unchanged
-        assert_eq!(result.trim(), output.trim());
-    }
-
-    #[test]
-    fn test_filter_curl_long_output() {
-        let lines: Vec<String> = (0..50).map(|i| format!("Line {}", i)).collect();
-        let output = lines.join("\n");
-        let result = filter_curl_output(&output);
-        assert!(result.contains("Line 0"));
-        assert!(result.contains("Line 29"));
-        assert!(result.contains("more lines"));
-    }
-}

package/temp/rtk/src/deps.rs

@@ -1,268 +0,0 @@
-use crate::tracking;
-use anyhow::Result;
-use regex::Regex;
-use std::fs;
-use std::path::Path;
-
-/// Summarize project dependencies
-pub fn run(path: &Path, verbose: u8) -> Result<()> {
-    let timer = tracking::TimedExecution::start();
-
-    let dir = if path.is_file() {
-        path.parent().unwrap_or(Path::new("."))
-    } else {
-        path
-    };
-
-    if verbose > 0 {
-        eprintln!("Scanning dependencies in: {}", dir.display());
-    }
-
-    let mut found = false;
-    let mut rtk = String::new();
-    let mut raw = String::new();
-
-    let cargo_path = dir.join("Cargo.toml");
-    if cargo_path.exists() {
-        found = true;
-        raw.push_str(&fs::read_to_string(&cargo_path).unwrap_or_default());
-        rtk.push_str("📦 Rust (Cargo.toml):\n");
-        rtk.push_str(&summarize_cargo_str(&cargo_path)?);
-    }
-
-    let package_path = dir.join("package.json");
-    if package_path.exists() {
-        found = true;
-        raw.push_str(&fs::read_to_string(&package_path).unwrap_or_default());
-        rtk.push_str("📦 Node.js (package.json):\n");
-        rtk.push_str(&summarize_package_json_str(&package_path)?);
-    }
-
-    let requirements_path = dir.join("requirements.txt");
-    if requirements_path.exists() {
-        found = true;
-        raw.push_str(&fs::read_to_string(&requirements_path).unwrap_or_default());
-        rtk.push_str("📦 Python (requirements.txt):\n");
-        rtk.push_str(&summarize_requirements_str(&requirements_path)?);
-    }
-
-    let pyproject_path = dir.join("pyproject.toml");
-    if pyproject_path.exists() {
-        found = true;
-        raw.push_str(&fs::read_to_string(&pyproject_path).unwrap_or_default());
-        rtk.push_str("📦 Python (pyproject.toml):\n");
-        rtk.push_str(&summarize_pyproject_str(&pyproject_path)?);
-    }
-
-    let gomod_path = dir.join("go.mod");
-    if gomod_path.exists() {
-        found = true;
-        raw.push_str(&fs::read_to_string(&gomod_path).unwrap_or_default());
-        rtk.push_str("📦 Go (go.mod):\n");
-        rtk.push_str(&summarize_gomod_str(&gomod_path)?);
-    }
-
-    if !found {
-        rtk.push_str(&format!("No dependency files found in {}", dir.display()));
-    }
-
-    print!("{}", rtk);
-    timer.track("cat */deps", "rtk deps", &raw, &rtk);
-    Ok(())
-}
-
-fn summarize_cargo_str(path: &Path) -> Result<String> {
-    let content = fs::read_to_string(path)?;
-    let dep_re =
-        Regex::new(r#"^([a-zA-Z0-9_-]+)\s*=\s*(?:"([^"]+)"|.*version\s*=\s*"([^"]+)")"#).unwrap();
-    let section_re = Regex::new(r"^\[([^\]]+)\]").unwrap();
-    let mut current_section = String::new();
-    let mut deps = Vec::new();
-    let mut dev_deps = Vec::new();
-    let mut out = String::new();
-
-    for line in content.lines() {
-        if let Some(caps) = section_re.captures(line) {
-            current_section = caps
-                .get(1)
-                .map(|m| m.as_str().to_string())
-                .unwrap_or_default();
-        } else if let Some(caps) = dep_re.captures(line) {
-            let name = caps.get(1).map(|m| m.as_str()).unwrap_or("");
-            let version = caps
-                .get(2)
-                .or(caps.get(3))
-                .map(|m| m.as_str())
-                .unwrap_or("*");
-            let dep = format!("{} ({})", name, version);
-            match current_section.as_str() {
-                "dependencies" => deps.push(dep),
-                "dev-dependencies" => dev_deps.push(dep),
-                _ => {}
-            }
-        }
-    }
-
-    if !deps.is_empty() {
-        out.push_str(&format!("  Dependencies ({}):\n", deps.len()));
-        for d in deps.iter().take(10) {
-            out.push_str(&format!("    {}\n", d));
-        }
-        if deps.len() > 10 {
-            out.push_str(&format!("    ... +{} more\n", deps.len() - 10));
-        }
-    }
-    if !dev_deps.is_empty() {
-        out.push_str(&format!("  Dev ({}):\n", dev_deps.len()));
-        for d in dev_deps.iter().take(5) {
-            out.push_str(&format!("    {}\n", d));
-        }
-        if dev_deps.len() > 5 {
-            out.push_str(&format!("    ... +{} more\n", dev_deps.len() - 5));
-        }
-    }
-    Ok(out)
-}
-
-fn summarize_package_json_str(path: &Path) -> Result<String> {
-    let content = fs::read_to_string(path)?;
-    let json: serde_json::Value = serde_json::from_str(&content)?;
-    let mut out = String::new();
-
-    if let Some(name) = json.get("name").and_then(|v| v.as_str()) {
-        let version = json.get("version").and_then(|v| v.as_str()).unwrap_or("?");
-        out.push_str(&format!("  {} @ {}\n", name, version));
-    }
-    if let Some(deps) = json.get("dependencies").and_then(|v| v.as_object()) {
-        out.push_str(&format!("  Dependencies ({}):\n", deps.len()));
-        for (i, (name, version)) in deps.iter().enumerate() {
-            if i >= 10 {
-                out.push_str(&format!("    ... +{} more\n", deps.len() - 10));
-                break;
-            }
-            out.push_str(&format!(
-                "    {} ({})\n",
-                name,
-                version.as_str().unwrap_or("*")
-            ));
-        }
-    }
-    if let Some(dev_deps) = json.get("devDependencies").and_then(|v| v.as_object()) {
-        out.push_str(&format!("  Dev Dependencies ({}):\n", dev_deps.len()));
-        for (i, (name, _)) in dev_deps.iter().enumerate() {
-            if i >= 5 {
-                out.push_str(&format!("    ... +{} more\n", dev_deps.len() - 5));
-                break;
-            }
-            out.push_str(&format!("    {}\n", name));
-        }
-    }
-    Ok(out)
-}
-
-fn summarize_requirements_str(path: &Path) -> Result<String> {
-    let content = fs::read_to_string(path)?;
-    let dep_re = Regex::new(r"^([a-zA-Z0-9_-]+)([=<>!~]+.*)?$").unwrap();
-    let mut deps = Vec::new();
-    let mut out = String::new();
-
-    for line in content.lines() {
-        let line = line.trim();
-        if line.is_empty() || line.starts_with('#') {
-            continue;
-        }
-        if let Some(caps) = dep_re.captures(line) {
-            let name = caps.get(1).map(|m| m.as_str()).unwrap_or("");
-            let version = caps.get(2).map(|m| m.as_str()).unwrap_or("");
-            deps.push(format!("{}{}", name, version));
-        }
-    }
-
-    out.push_str(&format!("  Packages ({}):\n", deps.len()));
-    for d in deps.iter().take(15) {
-        out.push_str(&format!("    {}\n", d));
-    }
-    if deps.len() > 15 {
-        out.push_str(&format!("    ... +{} more\n", deps.len() - 15));
-    }
-    Ok(out)
-}
-
-fn summarize_pyproject_str(path: &Path) -> Result<String> {
-    let content = fs::read_to_string(path)?;
-    let mut in_deps = false;
-    let mut deps = Vec::new();
-    let mut out = String::new();
-
-    for line in content.lines() {
-        if line.contains("dependencies") && line.contains("[") {
-            in_deps = true;
-            continue;
-        }
-        if in_deps {
-            if line.trim() == "]" {
-                break;
-            }
-            let line = line
-                .trim()
-                .trim_matches(|c| c == '"' || c == '\'' || c == ',');
-            if !line.is_empty() {
-                deps.push(line.to_string());
-            }
-        }
-    }
-
-    if !deps.is_empty() {
-        out.push_str(&format!("  Dependencies ({}):\n", deps.len()));
-        for d in deps.iter().take(10) {
-            out.push_str(&format!("    {}\n", d));
-        }
-        if deps.len() > 10 {
-            out.push_str(&format!("    ... +{} more\n", deps.len() - 10));
-        }
-    }
-    Ok(out)
-}
-
-fn summarize_gomod_str(path: &Path) -> Result<String> {
-    let content = fs::read_to_string(path)?;
-    let mut module_name = String::new();
-    let mut go_version = String::new();
-    let mut deps = Vec::new();
-    let mut in_require = false;
-    let mut out = String::new();
-
-    for line in content.lines() {
-        let line = line.trim();
-        if line.starts_with("module ") {
-            module_name = line.trim_start_matches("module ").to_string();
-        } else if line.starts_with("go ") {
-            go_version = line.trim_start_matches("go ").to_string();
-        } else if line == "require (" {
-            in_require = true;
-        } else if line == ")" {
-            in_require = false;
-        } else if in_require && !line.starts_with("//") {
-            let parts: Vec<&str> = line.split_whitespace().collect();
-            if parts.len() >= 2 {
-                deps.push(format!("{} {}", parts[0], parts[1]));
-            }
-        } else if line.starts_with("require ") && !line.contains("(") {
-            deps.push(line.trim_start_matches("require ").to_string());
-        }
-    }
-
-    if !module_name.is_empty() {
-        out.push_str(&format!("  {} (go {})\n", module_name, go_version));
-    }
-    if !deps.is_empty() {
-        out.push_str(&format!("  Dependencies ({}):\n", deps.len()));
-        for d in deps.iter().take(10) {
-            out.push_str(&format!("    {}\n", d));
-        }
-        if deps.len() > 10 {
-            out.push_str(&format!("    ... +{} more\n", deps.len() - 10));
-        }
-    }
-    Ok(out)
-}