@hasna/terminal 2.0.5 → 2.3.0

package/temp/rtk/src/env_cmd.rs

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

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