@hasna/terminal 2.3.0 → 2.3.1

package/temp/rtk/src/env_cmd.rs

@@ -1,204 +0,0 @@
-use crate::tracking;
-use anyhow::Result;
-use std::collections::HashSet;
-use std::env;
-
-/// Show filtered environment variables (hide sensitive data)
-pub fn run(filter: Option<&str>, show_all: bool, verbose: u8) -> Result<()> {
-    let timer = tracking::TimedExecution::start();
-
-    if verbose > 0 {
-        eprintln!("Environment variables:");
-    }
-
-    let sensitive_patterns = get_sensitive_patterns();
-    let mut vars: Vec<(String, String)> = env::vars().collect();
-    vars.sort_by(|a, b| a.0.cmp(&b.0));
-
-    // Interesting categories
-    let mut path_vars = Vec::new();
-    let mut lang_vars = Vec::new();
-    let mut cloud_vars = Vec::new();
-    let mut tool_vars = Vec::new();
-    let mut other_vars = Vec::new();
-
-    for (key, value) in &vars {
-        // Apply filter if provided
-        if let Some(f) = filter {
-            if !key.to_lowercase().contains(&f.to_lowercase()) {
-                continue;
-            }
-        }
-
-        // Check if sensitive
-        let is_sensitive = sensitive_patterns
-            .iter()
-            .any(|p| key.to_lowercase().contains(p));
-
-        let display_value = if is_sensitive && !show_all {
-            mask_value(value)
-        } else if value.len() > 100 {
-            let preview: String = value.chars().take(50).collect();
-            format!("{}... ({} chars)", preview, value.chars().count())
-        } else {
-            value.clone()
-        };
-
-        let entry = (key.clone(), display_value);
-
-        // Categorize
-        if key.contains("PATH") {
-            path_vars.push(entry);
-        } else if is_lang_var(key) {
-            lang_vars.push(entry);
-        } else if is_cloud_var(key) {
-            cloud_vars.push(entry);
-        } else if is_tool_var(key) {
-            tool_vars.push(entry);
-        } else if filter.is_some() || is_interesting_var(key) {
-            other_vars.push(entry);
-        }
-    }
-
-    // Print categorized
-    if !path_vars.is_empty() {
-        println!("📂 PATH Variables:");
-        for (k, v) in &path_vars {
-            if k == "PATH" {
-                // Split PATH for readability
-                let paths: Vec<&str> = v.split(':').collect();
-                println!("  PATH ({} entries):", paths.len());
-                for p in paths.iter().take(5) {
-                    println!("    {}", p);
-                }
-                if paths.len() > 5 {
-                    println!("    ... +{} more", paths.len() - 5);
-                }
-            } else {
-                println!("  {}={}", k, v);
-            }
-        }
-    }
-
-    if !lang_vars.is_empty() {
-        println!("\n🔧 Language/Runtime:");
-        for (k, v) in &lang_vars {
-            println!("  {}={}", k, v);
-        }
-    }
-
-    if !cloud_vars.is_empty() {
-        println!("\n☁️  Cloud/Services:");
-        for (k, v) in &cloud_vars {
-            println!("  {}={}", k, v);
-        }
-    }
-
-    if !tool_vars.is_empty() {
-        println!("\n🛠️  Tools:");
-        for (k, v) in &tool_vars {
-            println!("  {}={}", k, v);
-        }
-    }
-
-    if !other_vars.is_empty() {
-        println!("\n📋 Other:");
-        for (k, v) in other_vars.iter().take(20) {
-            println!("  {}={}", k, v);
-        }
-        if other_vars.len() > 20 {
-            println!("  ... +{} more", other_vars.len() - 20);
-        }
-    }
-
-    let total = vars.len();
-    let shown = path_vars.len()
-        + lang_vars.len()
-        + cloud_vars.len()
-        + tool_vars.len()
-        + other_vars.len().min(20);
-    if filter.is_none() {
-        println!("\n📊 Total: {} vars (showing {} relevant)", total, shown);
-    }
-
-    let raw: String = vars.iter().map(|(k, v)| format!("{}={}\n", k, v)).collect();
-    let rtk = format!("{} vars -> {} shown", total, shown);
-    timer.track("env", "rtk env", &raw, &rtk);
-    Ok(())
-}
-
-fn get_sensitive_patterns() -> HashSet<&'static str> {
-    let mut set = HashSet::new();
-    set.insert("key");
-    set.insert("secret");
-    set.insert("password");
-    set.insert("token");
-    set.insert("credential");
-    set.insert("auth");
-    set.insert("private");
-    set.insert("api_key");
-    set.insert("apikey");
-    set.insert("access_key");
-    set.insert("jwt");
-    set
-}
-
-fn mask_value(value: &str) -> String {
-    let chars: Vec<char> = value.chars().collect();
-    if chars.len() <= 4 {
-        "****".to_string()
-    } else {
-        let prefix: String = chars[..2].iter().collect();
-        let suffix: String = chars[chars.len() - 2..].iter().collect();
-        format!("{}****{}", prefix, suffix)
-    }
-}
-
-fn is_lang_var(key: &str) -> bool {
-    let patterns = [
-        "RUST", "CARGO", "PYTHON", "PIP", "NODE", "NPM", "YARN", "DENO", "BUN", "JAVA", "MAVEN",
-        "GRADLE", "GO", "GOPATH", "GOROOT", "RUBY", "GEM", "PERL", "PHP", "DOTNET", "NUGET",
-    ];
-    patterns.iter().any(|p| key.to_uppercase().contains(p))
-}
-
-fn is_cloud_var(key: &str) -> bool {
-    let patterns = [
-        "AWS",
-        "AZURE",
-        "GCP",
-        "GOOGLE_CLOUD",
-        "DOCKER",
-        "KUBERNETES",
-        "K8S",
-        "HELM",
-        "TERRAFORM",
-        "VAULT",
-        "CONSUL",
-        "NOMAD",
-    ];
-    patterns.iter().any(|p| key.to_uppercase().contains(p))
-}
-
-fn is_tool_var(key: &str) -> bool {
-    let patterns = [
-        "EDITOR",
-        "VISUAL",
-        "SHELL",
-        "TERM",
-        "GIT",
-        "SSH",
-        "GPG",
-        "BREW",
-        "HOMEBREW",
-        "XDG",
-        "CLAUDE",
-        "ANTHROPIC",
-    ];
-    patterns.iter().any(|p| key.to_uppercase().contains(p))
-}
-
-fn is_interesting_var(key: &str) -> bool {
-    let patterns = ["HOME", "USER", "LANG", "LC_", "TZ", "PWD", "OLDPWD"];
-    patterns.iter().any(|p| key.to_uppercase().starts_with(p))
-}

package/temp/rtk/src/filter.rs

@@ -1,462 +0,0 @@
-use lazy_static::lazy_static;
-use regex::Regex;
-use std::str::FromStr;
-
-#[derive(Debug, Clone, Copy, PartialEq, Eq)]
-pub enum FilterLevel {
-    None,
-    Minimal,
-    Aggressive,
-}
-
-impl FromStr for FilterLevel {
-    type Err = String;
-
-    fn from_str(s: &str) -> Result<Self, Self::Err> {
-        match s.to_lowercase().as_str() {
-            "none" => Ok(FilterLevel::None),
-            "minimal" => Ok(FilterLevel::Minimal),
-            "aggressive" => Ok(FilterLevel::Aggressive),
-            _ => Err(format!("Unknown filter level: {}", s)),
-        }
-    }
-}
-
-impl std::fmt::Display for FilterLevel {
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        match self {
-            FilterLevel::None => write!(f, "none"),
-            FilterLevel::Minimal => write!(f, "minimal"),
-            FilterLevel::Aggressive => write!(f, "aggressive"),
-        }
-    }
-}
-
-pub trait FilterStrategy {
-    fn filter(&self, content: &str, lang: &Language) -> String;
-    #[allow(dead_code)]
-    fn name(&self) -> &'static str;
-}
-
-#[derive(Debug, Clone, Copy, PartialEq, Eq)]
-pub enum Language {
-    Rust,
-    Python,
-    JavaScript,
-    TypeScript,
-    Go,
-    C,
-    Cpp,
-    Java,
-    Ruby,
-    Shell,
-    Data,
-    Unknown,
-}
-
-impl Language {
-    pub fn from_extension(ext: &str) -> Self {
-        match ext.to_lowercase().as_str() {
-            "rs" => Language::Rust,
-            "py" | "pyw" => Language::Python,
-            "js" | "mjs" | "cjs" => Language::JavaScript,
-            "ts" | "tsx" => Language::TypeScript,
-            "go" => Language::Go,
-            "c" | "h" => Language::C,
-            "cpp" | "cc" | "cxx" | "hpp" | "hh" => Language::Cpp,
-            "java" => Language::Java,
-            "rb" => Language::Ruby,
-            "sh" | "bash" | "zsh" => Language::Shell,
-            "json" | "jsonc" | "json5" | "yaml" | "yml" | "toml" | "xml" | "html" | "htm"
-            | "css" | "scss" | "svg" | "md" | "markdown" | "txt" | "csv" | "tsv" | "env"
-            | "ini" | "cfg" | "conf" | "lock" => Language::Data,
-            _ => Language::Unknown,
-        }
-    }
-
-    pub fn comment_patterns(&self) -> CommentPatterns {
-        match self {
-            Language::Rust => CommentPatterns {
-                line: Some("//"),
-                block_start: Some("/*"),
-                block_end: Some("*/"),
-                doc_line: Some("///"),
-                doc_block_start: Some("/**"),
-            },
-            Language::Python => CommentPatterns {
-                line: Some("#"),
-                block_start: Some("\"\"\""),
-                block_end: Some("\"\"\""),
-                doc_line: None,
-                doc_block_start: Some("\"\"\""),
-            },
-            Language::JavaScript
-            | Language::TypeScript
-            | Language::Go
-            | Language::C
-            | Language::Cpp
-            | Language::Java => CommentPatterns {
-                line: Some("//"),
-                block_start: Some("/*"),
-                block_end: Some("*/"),
-                doc_line: None,
-                doc_block_start: Some("/**"),
-            },
-            Language::Ruby => CommentPatterns {
-                line: Some("#"),
-                block_start: Some("=begin"),
-                block_end: Some("=end"),
-                doc_line: None,
-                doc_block_start: None,
-            },
-            Language::Shell => CommentPatterns {
-                line: Some("#"),
-                block_start: None,
-                block_end: None,
-                doc_line: None,
-                doc_block_start: None,
-            },
-            Language::Data => CommentPatterns {
-                line: None,
-                block_start: None,
-                block_end: None,
-                doc_line: None,
-                doc_block_start: None,
-            },
-            Language::Unknown => CommentPatterns {
-                line: Some("//"),
-                block_start: Some("/*"),
-                block_end: Some("*/"),
-                doc_line: None,
-                doc_block_start: None,
-            },
-        }
-    }
-}
-
-#[derive(Debug, Clone)]
-pub struct CommentPatterns {
-    pub line: Option<&'static str>,
-    pub block_start: Option<&'static str>,
-    pub block_end: Option<&'static str>,
-    pub doc_line: Option<&'static str>,
-    pub doc_block_start: Option<&'static str>,
-}
-
-pub struct NoFilter;
-
-impl FilterStrategy for NoFilter {
-    fn filter(&self, content: &str, _lang: &Language) -> String {
-        content.to_string()
-    }
-
-    fn name(&self) -> &'static str {
-        "none"
-    }
-}
-
-pub struct MinimalFilter;
-
-lazy_static! {
-    static ref MULTIPLE_BLANK_LINES: Regex = Regex::new(r"\n{3,}").unwrap();
-    static ref TRAILING_WHITESPACE: Regex = Regex::new(r"[ \t]+$").unwrap();
-}
-
-impl FilterStrategy for MinimalFilter {
-    fn filter(&self, content: &str, lang: &Language) -> String {
-        let patterns = lang.comment_patterns();
-        let mut result = String::with_capacity(content.len());
-        let mut in_block_comment = false;
-        let mut in_docstring = false;
-
-        for line in content.lines() {
-            let trimmed = line.trim();
-
-            // Handle block comments
-            if let (Some(start), Some(end)) = (patterns.block_start, patterns.block_end) {
-                if !in_docstring
-                    && trimmed.contains(start)
-                    && !trimmed.starts_with(patterns.doc_block_start.unwrap_or("###"))
-                {
-                    in_block_comment = true;
-                }
-                if in_block_comment {
-                    if trimmed.contains(end) {
-                        in_block_comment = false;
-                    }
-                    continue;
-                }
-            }
-
-            // Handle Python docstrings (keep them in minimal mode)
-            if *lang == Language::Python && trimmed.starts_with("\"\"\"") {
-                in_docstring = !in_docstring;
-                result.push_str(line);
-                result.push('\n');
-                continue;
-            }
-
-            if in_docstring {
-                result.push_str(line);
-                result.push('\n');
-                continue;
-            }
-
-            // Skip single-line comments (but keep doc comments)
-            if let Some(line_comment) = patterns.line {
-                if trimmed.starts_with(line_comment) {
-                    // Keep doc comments
-                    if let Some(doc) = patterns.doc_line {
-                        if trimmed.starts_with(doc) {
-                            result.push_str(line);
-                            result.push('\n');
-                        }
-                    }
-                    continue;
-                }
-            }
-
-            // Skip empty lines at this point, we'll normalize later
-            if trimmed.is_empty() {
-                result.push('\n');
-                continue;
-            }
-
-            result.push_str(line);
-            result.push('\n');
-        }
-
-        // Normalize multiple blank lines to max 2
-        let result = MULTIPLE_BLANK_LINES.replace_all(&result, "\n\n");
-        result.trim().to_string()
-    }
-
-    fn name(&self) -> &'static str {
-        "minimal"
-    }
-}
-
-pub struct AggressiveFilter;
-
-lazy_static! {
-    static ref IMPORT_PATTERN: Regex =
-        Regex::new(r"^(use |import |from |require\(|#include)").unwrap();
-    static ref FUNC_SIGNATURE: Regex = Regex::new(
-        r"^(pub\s+)?(async\s+)?(fn|def|function|func|class|struct|enum|trait|interface|type)\s+\w+"
-    )
-    .unwrap();
-}
-
-impl FilterStrategy for AggressiveFilter {
-    fn filter(&self, content: &str, lang: &Language) -> String {
-        let minimal = MinimalFilter.filter(content, lang);
-        let mut result = String::with_capacity(minimal.len() / 2);
-        let mut brace_depth = 0;
-        let mut in_impl_body = false;
-
-        for line in minimal.lines() {
-            let trimmed = line.trim();
-
-            // Always keep imports
-            if IMPORT_PATTERN.is_match(trimmed) {
-                result.push_str(line);
-                result.push('\n');
-                continue;
-            }
-
-            // Always keep function/struct/class signatures
-            if FUNC_SIGNATURE.is_match(trimmed) {
-                result.push_str(line);
-                result.push('\n');
-                in_impl_body = true;
-                brace_depth = 0;
-                continue;
-            }
-
-            // Track brace depth for implementation bodies
-            let open_braces = trimmed.matches('{').count();
-            let close_braces = trimmed.matches('}').count();
-
-            if in_impl_body {
-                brace_depth += open_braces as i32;
-                brace_depth -= close_braces as i32;
-
-                // Only keep the opening and closing braces
-                if brace_depth <= 1 && (trimmed == "{" || trimmed == "}" || trimmed.ends_with('{'))
-                {
-                    result.push_str(line);
-                    result.push('\n');
-                }
-
-                if brace_depth <= 0 {
-                    in_impl_body = false;
-                    if !trimmed.is_empty() && trimmed != "}" {
-                        result.push_str("    // ... implementation\n");
-                    }
-                }
-                continue;
-            }
-
-            // Keep type definitions, constants, etc.
-            if trimmed.starts_with("const ")
-                || trimmed.starts_with("static ")
-                || trimmed.starts_with("let ")
-                || trimmed.starts_with("pub const ")
-                || trimmed.starts_with("pub static ")
-            {
-                result.push_str(line);
-                result.push('\n');
-            }
-        }
-
-        result.trim().to_string()
-    }
-
-    fn name(&self) -> &'static str {
-        "aggressive"
-    }
-}
-
-pub fn get_filter(level: FilterLevel) -> Box<dyn FilterStrategy> {
-    match level {
-        FilterLevel::None => Box::new(NoFilter),
-        FilterLevel::Minimal => Box::new(MinimalFilter),
-        FilterLevel::Aggressive => Box::new(AggressiveFilter),
-    }
-}
-
-pub fn smart_truncate(content: &str, max_lines: usize, _lang: &Language) -> String {
-    let lines: Vec<&str> = content.lines().collect();
-    if lines.len() <= max_lines {
-        return content.to_string();
-    }
-
-    let mut result = Vec::with_capacity(max_lines);
-    let mut kept_lines = 0;
-    let mut skipped_section = false;
-
-    for line in &lines {
-        let trimmed = line.trim();
-
-        // Always keep signatures and important structural elements
-        let is_important = FUNC_SIGNATURE.is_match(trimmed)
-            || IMPORT_PATTERN.is_match(trimmed)
-            || trimmed.starts_with("pub ")
-            || trimmed.starts_with("export ")
-            || trimmed == "}"
-            || trimmed == "{";
-
-        if is_important || kept_lines < max_lines / 2 {
-            if skipped_section {
-                result.push(format!(
-                    "    // ... {} lines omitted",
-                    lines.len() - kept_lines
-                ));
-                skipped_section = false;
-            }
-            result.push((*line).to_string());
-            kept_lines += 1;
-        } else {
-            skipped_section = true;
-        }
-
-        if kept_lines >= max_lines - 1 {
-            break;
-        }
-    }
-
-    if skipped_section || kept_lines < lines.len() {
-        result.push(format!(
-            "// ... {} more lines (total: {})",
-            lines.len() - kept_lines,
-            lines.len()
-        ));
-    }
-
-    result.join("\n")
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-
-    #[test]
-    fn test_filter_level_parsing() {
-        assert_eq!(FilterLevel::from_str("none").unwrap(), FilterLevel::None);
-        assert_eq!(
-            FilterLevel::from_str("minimal").unwrap(),
-            FilterLevel::Minimal
-        );
-        assert_eq!(
-            FilterLevel::from_str("aggressive").unwrap(),
-            FilterLevel::Aggressive
-        );
-    }
-
-    #[test]
-    fn test_language_detection() {
-        assert_eq!(Language::from_extension("rs"), Language::Rust);
-        assert_eq!(Language::from_extension("py"), Language::Python);
-        assert_eq!(Language::from_extension("js"), Language::JavaScript);
-    }
-
-    #[test]
-    fn test_language_detection_data_formats() {
-        assert_eq!(Language::from_extension("json"), Language::Data);
-        assert_eq!(Language::from_extension("yaml"), Language::Data);
-        assert_eq!(Language::from_extension("yml"), Language::Data);
-        assert_eq!(Language::from_extension("toml"), Language::Data);
-        assert_eq!(Language::from_extension("xml"), Language::Data);
-        assert_eq!(Language::from_extension("md"), Language::Data);
-        assert_eq!(Language::from_extension("csv"), Language::Data);
-        assert_eq!(Language::from_extension("lock"), Language::Data);
-    }
-
-    #[test]
-    fn test_data_files_no_comment_stripping() {
-        // Regression test for #464: package.json with `/*` in strings
-        let json = r#"{
-  "workspaces": {
-    "packages": [
-      "packages/*"
-    ]
-  },
-  "scripts": {
-    "build": "bun run --workspaces build"
-  },
-  "lint-staged": {
-    "**/package.json": [
-      "sort-package-json"
-    ]
-  }
-}"#;
-        let filter = MinimalFilter;
-        let result = filter.filter(json, &Language::Data);
-        assert!(
-            result.contains("scripts"),
-            "scripts section must be preserved"
-        );
-        assert!(
-            result.contains("packages/*"),
-            "glob pattern must be preserved"
-        );
-        assert!(
-            result.contains("**/package.json"),
-            "glob pattern must be preserved"
-        );
-    }
-
-    #[test]
-    fn test_minimal_filter_removes_comments() {
-        let code = r#"
-// This is a comment
-fn main() {
-    println!("Hello");
-}
-"#;
-        let filter = MinimalFilter;
-        let result = filter.filter(code, &Language::Rust);
-        assert!(!result.contains("// This is a comment"));
-        assert!(result.contains("fn main()"));
-    }
-}