@hasna/terminal 2.2.0 → 2.3.0

package/temp/rtk/src/local_llm.rs

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

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