@hasna/terminal 2.3.0 → 2.3.1

package/temp/rtk/src/local_llm.rs

@@ -1,316 +0,0 @@
-use anyhow::{Context, Result};
-use regex::Regex;
-use std::fs;
-use std::path::Path;
-
-use crate::filter::Language;
-
-/// Heuristic-based code summarizer - no external model needed
-pub fn run(file: &Path, _model: &str, _force_download: bool, verbose: u8) -> Result<()> {
-    if verbose > 0 {
-        eprintln!("Analyzing: {}", file.display());
-    }
-
-    let content = fs::read_to_string(file)
-        .with_context(|| format!("Failed to read file: {}", file.display()))?;
-
-    let lang = file
-        .extension()
-        .and_then(|e| e.to_str())
-        .map(Language::from_extension)
-        .unwrap_or(Language::Unknown);
-
-    let summary = analyze_code(&content, &lang);
-
-    println!("{}", summary.line1);
-    println!("{}", summary.line2);
-
-    Ok(())
-}
-
-struct CodeSummary {
-    line1: String,
-    line2: String,
-}
-
-fn analyze_code(content: &str, lang: &Language) -> CodeSummary {
-    let lines: Vec<&str> = content.lines().collect();
-    let total_lines = lines.len();
-
-    // Extract components
-    let imports = extract_imports(content, lang);
-    let functions = extract_functions(content, lang);
-    let structs = extract_structs(content, lang);
-    let traits = extract_traits(content, lang);
-
-    // Detect patterns
-    let patterns = detect_patterns(content, lang);
-
-    // Build line 1: What it is
-    let lang_name = lang_display_name(lang);
-    let main_type = if !structs.is_empty() && !functions.is_empty() {
-        format!("{} module", lang_name)
-    } else if !structs.is_empty() {
-        format!("{} data structures", lang_name)
-    } else if !functions.is_empty() {
-        format!("{} functions", lang_name)
-    } else {
-        format!("{} code", lang_name)
-    };
-
-    let components: Vec<String> = [
-        (!functions.is_empty()).then(|| format!("{} fn", functions.len())),
-        (!structs.is_empty()).then(|| format!("{} struct", structs.len())),
-        (!traits.is_empty()).then(|| format!("{} trait", traits.len())),
-    ]
-    .into_iter()
-    .flatten()
-    .collect();
-
-    let line1 = if components.is_empty() {
-        format!("{} ({} lines)", main_type, total_lines)
-    } else {
-        format!(
-            "{} ({}) - {} lines",
-            main_type,
-            components.join(", "),
-            total_lines
-        )
-    };
-
-    // Build line 2: Key details
-    let mut details = Vec::new();
-
-    // Main imports/dependencies
-    if !imports.is_empty() {
-        let key_imports: Vec<&str> = imports.iter().take(3).map(|s| s.as_str()).collect();
-        details.push(format!("uses: {}", key_imports.join(", ")));
-    }
-
-    // Key patterns detected
-    if !patterns.is_empty() {
-        details.push(format!("patterns: {}", patterns.join(", ")));
-    }
-
-    // Main functions/structs
-    if !functions.is_empty() {
-        let key_fns: Vec<&str> = functions.iter().take(3).map(|s| s.as_str()).collect();
-        if details.is_empty() {
-            details.push(format!("defines: {}", key_fns.join(", ")));
-        }
-    }
-
-    let line2 = if details.is_empty() {
-        "General purpose code file".to_string()
-    } else {
-        details.join(" | ")
-    };
-
-    CodeSummary { line1, line2 }
-}
-
-fn lang_display_name(lang: &Language) -> &'static str {
-    match lang {
-        Language::Rust => "Rust",
-        Language::Python => "Python",
-        Language::JavaScript => "JavaScript",
-        Language::TypeScript => "TypeScript",
-        Language::Go => "Go",
-        Language::C => "C",
-        Language::Cpp => "C++",
-        Language::Java => "Java",
-        Language::Ruby => "Ruby",
-        Language::Shell => "Shell",
-        Language::Data => "Data",
-        Language::Unknown => "Code",
-    }
-}
-
-fn extract_imports(content: &str, lang: &Language) -> Vec<String> {
-    let pattern = match lang {
-        Language::Rust => r"^use\s+([a-zA-Z_][a-zA-Z0-9_]*(?:::[a-zA-Z_][a-zA-Z0-9_]*)?)",
-        Language::Python => r"^(?:from\s+(\S+)|import\s+(\S+))",
-        Language::JavaScript | Language::TypeScript => {
-            r#"(?:import.*from\s+['"]([^'"]+)['"]|require\(['"]([^'"]+)['"]\))"#
-        }
-        Language::Go => r#"^\s*"([^"]+)"$"#,
-        _ => return Vec::new(),
-    };
-
-    let re = Regex::new(pattern).unwrap();
-    let mut imports = Vec::new();
-    let mut seen = std::collections::HashSet::new();
-
-    for line in content.lines() {
-        if let Some(caps) = re.captures(line) {
-            let import = caps.get(1).or(caps.get(2)).map(|m| m.as_str().to_string());
-            if let Some(imp) = import {
-                let base = imp.split("::").next().unwrap_or(&imp).to_string();
-                if !seen.contains(&base) && !is_std_import(&base, lang) {
-                    seen.insert(base.clone());
-                    imports.push(base);
-                }
-            }
-        }
-    }
-
-    imports.into_iter().take(5).collect()
-}
-
-fn is_std_import(name: &str, lang: &Language) -> bool {
-    match lang {
-        Language::Rust => matches!(name, "std" | "core" | "alloc"),
-        Language::Python => matches!(name, "os" | "sys" | "re" | "json" | "typing"),
-        _ => false,
-    }
-}
-
-fn extract_functions(content: &str, lang: &Language) -> Vec<String> {
-    let pattern = match lang {
-        Language::Rust => r"(?:pub\s+)?(?:async\s+)?fn\s+([a-zA-Z_][a-zA-Z0-9_]*)",
-        Language::Python => r"def\s+([a-zA-Z_][a-zA-Z0-9_]*)",
-        Language::JavaScript | Language::TypeScript => {
-            r"(?:async\s+)?function\s+([a-zA-Z_][a-zA-Z0-9_]*)|(?:const|let|var)\s+([a-zA-Z_][a-zA-Z0-9_]*)\s*=\s*(?:async\s+)?\("
-        }
-        Language::Go => r"func\s+(?:\([^)]+\)\s+)?([a-zA-Z_][a-zA-Z0-9_]*)",
-        _ => return Vec::new(),
-    };
-
-    let re = Regex::new(pattern).unwrap();
-    let mut functions = Vec::new();
-
-    for line in content.lines() {
-        if let Some(caps) = re.captures(line) {
-            let name = caps.get(1).or(caps.get(2)).map(|m| m.as_str().to_string());
-            if let Some(n) = name {
-                if !n.starts_with("test_") && n != "main" && n != "new" {
-                    functions.push(n);
-                }
-            }
-        }
-    }
-
-    functions.into_iter().take(10).collect()
-}
-
-fn extract_structs(content: &str, lang: &Language) -> Vec<String> {
-    let pattern = match lang {
-        Language::Rust => r"(?:pub\s+)?(?:struct|enum)\s+([a-zA-Z_][a-zA-Z0-9_]*)",
-        Language::Python => r"class\s+([a-zA-Z_][a-zA-Z0-9_]*)",
-        Language::TypeScript => r"(?:interface|class|type)\s+([a-zA-Z_][a-zA-Z0-9_]*)",
-        Language::Go => r"type\s+([a-zA-Z_][a-zA-Z0-9_]*)\s+struct",
-        Language::Java => r"(?:public\s+)?class\s+([a-zA-Z_][a-zA-Z0-9_]*)",
-        _ => return Vec::new(),
-    };
-
-    let re = Regex::new(pattern).unwrap();
-    re.captures_iter(content)
-        .filter_map(|caps| caps.get(1).map(|m| m.as_str().to_string()))
-        .take(10)
-        .collect()
-}
-
-fn extract_traits(content: &str, lang: &Language) -> Vec<String> {
-    let pattern = match lang {
-        Language::Rust => r"(?:pub\s+)?trait\s+([a-zA-Z_][a-zA-Z0-9_]*)",
-        Language::TypeScript => r"interface\s+([a-zA-Z_][a-zA-Z0-9_]*)",
-        _ => return Vec::new(),
-    };
-
-    let re = Regex::new(pattern).unwrap();
-    re.captures_iter(content)
-        .filter_map(|caps| caps.get(1).map(|m| m.as_str().to_string()))
-        .take(5)
-        .collect()
-}
-
-fn detect_patterns(content: &str, lang: &Language) -> Vec<String> {
-    let mut patterns = Vec::new();
-
-    // Common patterns
-    if content.contains("async") && content.contains("await") {
-        patterns.push("async".to_string());
-    }
-
-    match lang {
-        Language::Rust => {
-            if content.contains("impl") && content.contains("for") {
-                patterns.push("trait impl".to_string());
-            }
-            if content.contains("#[derive") {
-                patterns.push("derive".to_string());
-            }
-            if content.contains("Result<") || content.contains("anyhow::") {
-                patterns.push("error handling".to_string());
-            }
-            if content.contains("#[test]") {
-                patterns.push("tests".to_string());
-            }
-            if content.contains("Box<dyn") || content.contains("&dyn") {
-                patterns.push("dyn dispatch".to_string());
-            }
-        }
-        Language::Python => {
-            if content.contains("@dataclass") {
-                patterns.push("dataclass".to_string());
-            }
-            if content.contains("def __init__") {
-                patterns.push("OOP".to_string());
-            }
-        }
-        Language::JavaScript | Language::TypeScript => {
-            if content.contains("useState") || content.contains("useEffect") {
-                patterns.push("React hooks".to_string());
-            }
-            if content.contains("export default") {
-                patterns.push("ES modules".to_string());
-            }
-        }
-        _ => {}
-    }
-
-    patterns.into_iter().take(3).collect()
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-
-    #[test]
-    fn test_rust_analysis() {
-        let code = r#"
-use anyhow::Result;
-use std::fs;
-
-pub struct Config {
-    name: String,
-}
-
-pub fn load_config() -> Result<Config> {
-    Ok(Config { name: "test".into() })
-}
-
-fn helper() {}
-"#;
-        let summary = analyze_code(code, &Language::Rust);
-        assert!(summary.line1.contains("Rust"));
-        assert!(summary.line1.contains("fn"));
-    }
-
-    #[test]
-    fn test_python_analysis() {
-        let code = r#"
-import json
-from pathlib import Path
-
-class Config:
-    def __init__(self, name):
-        self.name = name
-
-def load_config():
-    return Config("test")
-"#;
-        let summary = analyze_code(code, &Language::Python);
-        assert!(summary.line1.contains("Python"));
-    }
-}

package/temp/rtk/src/log_cmd.rs

@@ -1,248 +0,0 @@
-use crate::tracking;
-use anyhow::Result;
-use regex::Regex;
-use std::collections::HashMap;
-use std::fs;
-use std::io::{self, BufRead};
-use std::path::Path;
-
-/// Filter and deduplicate log output
-pub fn run_file(file: &Path, verbose: u8) -> Result<()> {
-    let timer = tracking::TimedExecution::start();
-
-    if verbose > 0 {
-        eprintln!("Analyzing log: {}", file.display());
-    }
-
-    let content = fs::read_to_string(file)?;
-    let result = analyze_logs(&content);
-    println!("{}", result);
-    timer.track(
-        &format!("cat {}", file.display()),
-        "rtk log",
-        &content,
-        &result,
-    );
-    Ok(())
-}
-
-/// Filter logs from stdin
-pub fn run_stdin(_verbose: u8) -> Result<()> {
-    let timer = tracking::TimedExecution::start();
-
-    let mut content = String::new();
-    let stdin = io::stdin();
-    for line in stdin.lock().lines() {
-        content.push_str(&line?);
-        content.push('\n');
-    }
-
-    let result = analyze_logs(&content);
-    println!("{}", result);
-
-    timer.track("log (stdin)", "rtk log (stdin)", &content, &result);
-
-    Ok(())
-}
-
-/// For use by other modules
-pub fn run_stdin_str(content: &str) -> String {
-    analyze_logs(content)
-}
-
-fn analyze_logs(content: &str) -> String {
-    let mut result = Vec::new();
-    let mut error_counts: HashMap<String, usize> = HashMap::new();
-    let mut warn_counts: HashMap<String, usize> = HashMap::new();
-    let mut info_counts: HashMap<String, usize> = HashMap::new();
-    let mut unique_errors: Vec<String> = Vec::new();
-    let mut unique_warnings: Vec<String> = Vec::new();
-
-    // Patterns to normalize log messages
-    let timestamp_re =
-        Regex::new(r"^\d{4}[-/]\d{2}[-/]\d{2}[T ]\d{2}:\d{2}:\d{2}[.,]?\d*\s*").unwrap();
-    let uuid_re =
-        Regex::new(r"[0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{12}")
-            .unwrap();
-    let hex_re = Regex::new(r"0x[0-9a-fA-F]+").unwrap();
-    let num_re = Regex::new(r"\b\d{4,}\b").unwrap();
-    let path_re = Regex::new(r"/[\w./\-]+").unwrap();
-
-    for line in content.lines() {
-        let line_lower = line.to_lowercase();
-
-        // Normalize for deduplication
-        let normalized =
-            normalize_log_line(line, &timestamp_re, &uuid_re, &hex_re, &num_re, &path_re);
-
-        // Categorize
-        if line_lower.contains("error")
-            || line_lower.contains("fatal")
-            || line_lower.contains("panic")
-        {
-            let count = error_counts.entry(normalized.clone()).or_insert(0);
-            if *count == 0 {
-                unique_errors.push(line.to_string());
-            }
-            *count += 1;
-        } else if line_lower.contains("warn") {
-            let count = warn_counts.entry(normalized.clone()).or_insert(0);
-            if *count == 0 {
-                unique_warnings.push(line.to_string());
-            }
-            *count += 1;
-        } else if line_lower.contains("info") {
-            *info_counts.entry(normalized).or_insert(0) += 1;
-        }
-    }
-
-    // Summary
-    let total_errors: usize = error_counts.values().sum();
-    let total_warnings: usize = warn_counts.values().sum();
-    let total_info: usize = info_counts.values().sum();
-
-    result.push(format!("📊 Log Summary"));
-    result.push(format!(
-        "   ❌ {} errors ({} unique)",
-        total_errors,
-        error_counts.len()
-    ));
-    result.push(format!(
-        "   ⚠️  {} warnings ({} unique)",
-        total_warnings,
-        warn_counts.len()
-    ));
-    result.push(format!("   ℹ️  {} info messages", total_info));
-    result.push(String::new());
-
-    // Errors with counts
-    if !unique_errors.is_empty() {
-        result.push("❌ ERRORS:".to_string());
-
-        // Sort by count
-        let mut error_list: Vec<_> = error_counts.iter().collect();
-        error_list.sort_by(|a, b| b.1.cmp(a.1));
-
-        for (normalized, count) in error_list.iter().take(10) {
-            // Find original message
-            let original = unique_errors
-                .iter()
-                .find(|e| {
-                    &normalize_log_line(e, &timestamp_re, &uuid_re, &hex_re, &num_re, &path_re)
-                        == *normalized
-                })
-                .map(|s| s.as_str())
-                .unwrap_or(normalized);
-
-            let truncated = if original.len() > 100 {
-                let t: String = original.chars().take(97).collect();
-                format!("{}...", t)
-            } else {
-                original.to_string()
-            };
-
-            if **count > 1 {
-                result.push(format!("   [×{}] {}", count, truncated));
-            } else {
-                result.push(format!("   {}", truncated));
-            }
-        }
-
-        if error_list.len() > 10 {
-            result.push(format!(
-                "   ... +{} more unique errors",
-                error_list.len() - 10
-            ));
-        }
-        result.push(String::new());
-    }
-
-    // Warnings with counts
-    if !unique_warnings.is_empty() {
-        result.push("⚠️  WARNINGS:".to_string());
-
-        let mut warn_list: Vec<_> = warn_counts.iter().collect();
-        warn_list.sort_by(|a, b| b.1.cmp(a.1));
-
-        for (normalized, count) in warn_list.iter().take(5) {
-            let original = unique_warnings
-                .iter()
-                .find(|w| {
-                    &normalize_log_line(w, &timestamp_re, &uuid_re, &hex_re, &num_re, &path_re)
-                        == *normalized
-                })
-                .map(|s| s.as_str())
-                .unwrap_or(normalized);
-
-            let truncated = if original.len() > 100 {
-                let t: String = original.chars().take(97).collect();
-                format!("{}...", t)
-            } else {
-                original.to_string()
-            };
-
-            if **count > 1 {
-                result.push(format!("   [×{}] {}", count, truncated));
-            } else {
-                result.push(format!("   {}", truncated));
-            }
-        }
-
-        if warn_list.len() > 5 {
-            result.push(format!(
-                "   ... +{} more unique warnings",
-                warn_list.len() - 5
-            ));
-        }
-    }
-
-    result.join("\n")
-}
-
-fn normalize_log_line(
-    line: &str,
-    timestamp_re: &Regex,
-    uuid_re: &Regex,
-    hex_re: &Regex,
-    num_re: &Regex,
-    path_re: &Regex,
-) -> String {
-    let mut normalized = timestamp_re.replace_all(line, "").to_string();
-    normalized = uuid_re.replace_all(&normalized, "<UUID>").to_string();
-    normalized = hex_re.replace_all(&normalized, "<HEX>").to_string();
-    normalized = num_re.replace_all(&normalized, "<NUM>").to_string();
-    normalized = path_re.replace_all(&normalized, "<PATH>").to_string();
-    normalized.trim().to_string()
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-
-    #[test]
-    fn test_analyze_logs() {
-        let logs = r#"
-2024-01-01 10:00:00 ERROR: Connection failed to /api/server
-2024-01-01 10:00:01 ERROR: Connection failed to /api/server
-2024-01-01 10:00:02 ERROR: Connection failed to /api/server
-2024-01-01 10:00:03 WARN: Retrying connection
-2024-01-01 10:00:04 INFO: Connected
-"#;
-        let result = analyze_logs(logs);
-        assert!(result.contains("×3"));
-        assert!(result.contains("ERRORS"));
-    }
-
-    #[test]
-    fn test_analyze_logs_multibyte() {
-        let logs = format!(
-            "2024-01-01 10:00:00 ERROR: {} connection failed\n\
-             2024-01-01 10:00:01 WARN: {} retry attempt\n",
-            "ข้อผิดพลาด".repeat(15),
-            "คำเตือน".repeat(15)
-        );
-        let result = analyze_logs(&logs);
-        // Should not panic even with very long multi-byte messages
-        assert!(result.contains("ERRORS"));
-    }
-}