@hasna/terminal 2.3.0 → 2.3.2

package/temp/rtk/src/mypy_cmd.rs

@@ -1,389 +0,0 @@
-use crate::tracking;
-use crate::utils::{strip_ansi, truncate};
-use anyhow::{Context, Result};
-use regex::Regex;
-use std::collections::HashMap;
-use std::process::Command;
-
-pub fn run(args: &[String], verbose: u8) -> Result<()> {
-    let timer = tracking::TimedExecution::start();
-
-    let mut cmd = if which_command("mypy").is_some() {
-        Command::new("mypy")
-    } else {
-        let mut c = Command::new("python3");
-        c.arg("-m").arg("mypy");
-        c
-    };
-
-    for arg in args {
-        cmd.arg(arg);
-    }
-
-    if verbose > 0 {
-        eprintln!("Running: mypy {}", args.join(" "));
-    }
-
-    let output = cmd
-        .output()
-        .context("Failed to run mypy. Is it installed? Try: pip install mypy")?;
-
-    let stdout = String::from_utf8_lossy(&output.stdout);
-    let stderr = String::from_utf8_lossy(&output.stderr);
-    let raw = format!("{}\n{}", stdout, stderr);
-    let clean = strip_ansi(&raw);
-
-    let filtered = filter_mypy_output(&clean);
-
-    println!("{}", filtered);
-
-    timer.track(
-        &format!("mypy {}", args.join(" ")),
-        &format!("rtk mypy {}", args.join(" ")),
-        &raw,
-        &filtered,
-    );
-
-    std::process::exit(output.status.code().unwrap_or(1));
-}
-
-fn which_command(cmd: &str) -> Option<String> {
-    Command::new("which")
-        .arg(cmd)
-        .output()
-        .ok()
-        .filter(|o| o.status.success())
-        .and_then(|o| String::from_utf8(o.stdout).ok())
-        .map(|s| s.trim().to_string())
-        .filter(|s| !s.is_empty())
-}
-
-struct MypyError {
-    file: String,
-    line: usize,
-    code: String,
-    message: String,
-    context_lines: Vec<String>,
-}
-
-pub fn filter_mypy_output(output: &str) -> String {
-    lazy_static::lazy_static! {
-        // file.py:12: error: Message [error-code]
-        // file.py:12:5: error: Message [error-code]
-        static ref MYPY_DIAG: Regex = Regex::new(
-            r"^(.+?):(\d+)(?::\d+)?: (error|warning|note): (.+?)(?:\s+\[(.+)\])?$"
-        ).unwrap();
-    }
-
-    let lines: Vec<&str> = output.lines().collect();
-    let mut errors: Vec<MypyError> = Vec::new();
-    let mut fileless_lines: Vec<String> = Vec::new();
-    let mut i = 0;
-
-    while i < lines.len() {
-        let line = lines[i];
-
-        // Skip mypy's own summary line
-        if line.starts_with("Found ") && line.contains(" error") {
-            i += 1;
-            continue;
-        }
-        // Skip "Success: no issues found"
-        if line.starts_with("Success:") {
-            i += 1;
-            continue;
-        }
-
-        if let Some(caps) = MYPY_DIAG.captures(line) {
-            let severity = &caps[3];
-            let file = caps[1].to_string();
-            let line_num: usize = caps[2].parse().unwrap_or(0);
-            let message = caps[4].to_string();
-            let code = caps
-                .get(5)
-                .map(|m| m.as_str().to_string())
-                .unwrap_or_default();
-
-            if severity == "note" {
-                // Attach note to preceding error if same file and line
-                if let Some(last) = errors.last_mut() {
-                    if last.file == file {
-                        last.context_lines.push(message);
-                        i += 1;
-                        continue;
-                    }
-                }
-                // Standalone note with no parent -- display as fileless
-                fileless_lines.push(line.to_string());
-                i += 1;
-                continue;
-            }
-
-            let mut err = MypyError {
-                file,
-                line: line_num,
-                code,
-                message,
-                context_lines: Vec::new(),
-            };
-
-            // Capture continuation note lines
-            i += 1;
-            while i < lines.len() {
-                if let Some(next_caps) = MYPY_DIAG.captures(lines[i]) {
-                    if &next_caps[3] == "note" && next_caps[1] == err.file {
-                        let note_msg = next_caps[4].to_string();
-                        err.context_lines.push(note_msg);
-                        i += 1;
-                        continue;
-                    }
-                }
-                break;
-            }
-
-            errors.push(err);
-        } else if line.contains("error:") && !line.trim().is_empty() {
-            // File-less error (config errors, import errors)
-            fileless_lines.push(line.to_string());
-            i += 1;
-        } else {
-            i += 1;
-        }
-    }
-
-    // No errors at all
-    if errors.is_empty() && fileless_lines.is_empty() {
-        if output.contains("Success: no issues found") || output.contains("no issues found") {
-            return "mypy: No issues found".to_string();
-        }
-        return "mypy: No issues found".to_string();
-    }
-
-    // Group by file
-    let mut by_file: HashMap<String, Vec<&MypyError>> = HashMap::new();
-    for err in &errors {
-        by_file.entry(err.file.clone()).or_default().push(err);
-    }
-
-    // Count by error code
-    let mut by_code: HashMap<String, usize> = HashMap::new();
-    for err in &errors {
-        if !err.code.is_empty() {
-            *by_code.entry(err.code.clone()).or_insert(0) += 1;
-        }
-    }
-
-    let mut result = String::new();
-
-    // File-less errors first
-    for line in &fileless_lines {
-        result.push_str(line);
-        result.push('\n');
-    }
-    if !fileless_lines.is_empty() && !errors.is_empty() {
-        result.push('\n');
-    }
-
-    if !errors.is_empty() {
-        result.push_str(&format!(
-            "mypy: {} errors in {} files\n",
-            errors.len(),
-            by_file.len()
-        ));
-        result.push_str("═══════════════════════════════════════\n");
-
-        // Top error codes summary (only when 2+ distinct codes)
-        let mut code_counts: Vec<_> = by_code.iter().collect();
-        code_counts.sort_by(|a, b| b.1.cmp(a.1));
-
-        if code_counts.len() > 1 {
-            let codes_str: Vec<String> = code_counts
-                .iter()
-                .take(5)
-                .map(|(code, count)| format!("{} ({}x)", code, count))
-                .collect();
-            result.push_str(&format!("Top codes: {}\n\n", codes_str.join(", ")));
-        }
-
-        // Files sorted by error count (most errors first)
-        let mut files_sorted: Vec<_> = by_file.iter().collect();
-        files_sorted.sort_by(|a, b| b.1.len().cmp(&a.1.len()));
-
-        for (file, file_errors) in &files_sorted {
-            result.push_str(&format!("{} ({} errors)\n", file, file_errors.len()));
-
-            for err in *file_errors {
-                if err.code.is_empty() {
-                    result.push_str(&format!(
-                        "  L{}: {}\n",
-                        err.line,
-                        truncate(&err.message, 120)
-                    ));
-                } else {
-                    result.push_str(&format!(
-                        "  L{}: [{}] {}\n",
-                        err.line,
-                        err.code,
-                        truncate(&err.message, 120)
-                    ));
-                }
-                for ctx in &err.context_lines {
-                    result.push_str(&format!("    {}\n", truncate(ctx, 120)));
-                }
-            }
-            result.push('\n');
-        }
-    }
-
-    result.trim().to_string()
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-
-    #[test]
-    fn test_filter_mypy_errors_grouped_by_file() {
-        let output = "\
-src/server/auth.py:12: error: Incompatible return value type (got \"str\", expected \"int\")  [return-value]
-src/server/auth.py:15: error: Argument 1 has incompatible type \"int\"; expected \"str\"  [arg-type]
-src/models/user.py:8: error: Name \"foo\" is not defined  [name-defined]
-src/models/user.py:10: error: Incompatible types in assignment  [assignment]
-src/models/user.py:20: error: Missing return statement  [return]
-Found 5 errors in 2 files (checked 10 source files)
-";
-        let result = filter_mypy_output(output);
-        assert!(result.contains("mypy: 5 errors in 2 files"));
-        // user.py has 3 errors, auth.py has 2 -- user.py should come first
-        let user_pos = result.find("user.py").unwrap();
-        let auth_pos = result.find("auth.py").unwrap();
-        assert!(
-            user_pos < auth_pos,
-            "user.py (3 errors) should appear before auth.py (2 errors)"
-        );
-        assert!(result.contains("user.py (3 errors)"));
-        assert!(result.contains("auth.py (2 errors)"));
-    }
-
-    #[test]
-    fn test_filter_mypy_with_column_numbers() {
-        let output = "\
-src/api.py:10:5: error: Incompatible return value type  [return-value]
-";
-        let result = filter_mypy_output(output);
-        assert!(result.contains("L10:"));
-        assert!(result.contains("[return-value]"));
-        assert!(result.contains("Incompatible return value type"));
-    }
-
-    #[test]
-    fn test_filter_mypy_top_codes_summary() {
-        let output = "\
-a.py:1: error: Error one  [return-value]
-a.py:2: error: Error two  [return-value]
-a.py:3: error: Error three  [return-value]
-b.py:1: error: Error four  [name-defined]
-c.py:1: error: Error five  [arg-type]
-Found 5 errors in 3 files
-";
-        let result = filter_mypy_output(output);
-        assert!(result.contains("Top codes:"));
-        assert!(result.contains("return-value (3x)"));
-        assert!(result.contains("name-defined (1x)"));
-        assert!(result.contains("arg-type (1x)"));
-    }
-
-    #[test]
-    fn test_filter_mypy_single_code_no_summary() {
-        let output = "\
-a.py:1: error: Error one  [return-value]
-a.py:2: error: Error two  [return-value]
-b.py:1: error: Error three  [return-value]
-Found 3 errors in 2 files
-";
-        let result = filter_mypy_output(output);
-        assert!(
-            !result.contains("Top codes:"),
-            "Top codes should not appear with only one distinct code"
-        );
-    }
-
-    #[test]
-    fn test_filter_mypy_every_error_shown() {
-        let output = "\
-src/api.py:10: error: Type \"str\" not assignable to \"int\"  [assignment]
-src/api.py:20: error: Missing return statement  [return]
-src/api.py:30: error: Name \"bar\" is not defined  [name-defined]
-";
-        let result = filter_mypy_output(output);
-        assert!(result.contains("Type \"str\" not assignable to \"int\""));
-        assert!(result.contains("Missing return statement"));
-        assert!(result.contains("Name \"bar\" is not defined"));
-        assert!(result.contains("L10:"));
-        assert!(result.contains("L20:"));
-        assert!(result.contains("L30:"));
-    }
-
-    #[test]
-    fn test_filter_mypy_note_continuation() {
-        let output = "\
-src/app.py:10: error: Incompatible types in assignment  [assignment]
-src/app.py:10: note: Expected type \"int\"
-src/app.py:10: note: Got type \"str\"
-src/app.py:20: error: Missing return statement  [return]
-";
-        let result = filter_mypy_output(output);
-        assert!(result.contains("Incompatible types in assignment"));
-        assert!(result.contains("Expected type \"int\""));
-        assert!(result.contains("Got type \"str\""));
-        assert!(result.contains("L10:"));
-        assert!(result.contains("L20:"));
-    }
-
-    #[test]
-    fn test_filter_mypy_fileless_errors() {
-        let output = "\
-mypy: error: No module named 'nonexistent'
-src/api.py:10: error: Name \"foo\" is not defined  [name-defined]
-Found 1 error in 1 file
-";
-        let result = filter_mypy_output(output);
-        // File-less error should appear verbatim before grouped output
-        assert!(result.contains("mypy: error: No module named 'nonexistent'"));
-        assert!(result.contains("api.py (1 error"));
-        let fileless_pos = result.find("No module named").unwrap();
-        let grouped_pos = result.find("api.py").unwrap();
-        assert!(
-            fileless_pos < grouped_pos,
-            "File-less errors should appear before grouped file errors"
-        );
-    }
-
-    #[test]
-    fn test_filter_mypy_no_errors() {
-        let output = "Success: no issues found in 5 source files\n";
-        let result = filter_mypy_output(output);
-        assert_eq!(result, "mypy: No issues found");
-    }
-
-    #[test]
-    fn test_filter_mypy_no_file_limit() {
-        let mut output = String::new();
-        for i in 1..=15 {
-            output.push_str(&format!(
-                "src/file{}.py:{}: error: Error in file {}.  [assignment]\n",
-                i, i, i
-            ));
-        }
-        output.push_str("Found 15 errors in 15 files\n");
-        let result = filter_mypy_output(&output);
-        assert!(result.contains("15 errors in 15 files"));
-        for i in 1..=15 {
-            assert!(
-                result.contains(&format!("file{}.py", i)),
-                "file{}.py missing from output",
-                i
-            );
-        }
-    }
-}

package/temp/rtk/src/next_cmd.rs

@@ -1,241 +0,0 @@
-use crate::tracking;
-use crate::utils::{strip_ansi, truncate};
-use anyhow::{Context, Result};
-use regex::Regex;
-use std::process::Command;
-
-pub fn run(args: &[String], verbose: u8) -> Result<()> {
-    let timer = tracking::TimedExecution::start();
-
-    // Try next directly first, fallback to npx if not found
-    let next_exists = Command::new("which")
-        .arg("next")
-        .output()
-        .map(|o| o.status.success())
-        .unwrap_or(false);
-
-    let mut cmd = if next_exists {
-        Command::new("next")
-    } else {
-        let mut c = Command::new("npx");
-        c.arg("next");
-        c
-    };
-
-    cmd.arg("build");
-
-    for arg in args {
-        cmd.arg(arg);
-    }
-
-    if verbose > 0 {
-        let tool = if next_exists { "next" } else { "npx next" };
-        eprintln!("Running: {} build", tool);
-    }
-
-    let output = cmd
-        .output()
-        .context("Failed to run next build (try: npm install -g next)")?;
-    let stdout = String::from_utf8_lossy(&output.stdout);
-    let stderr = String::from_utf8_lossy(&output.stderr);
-    let raw = format!("{}\n{}", stdout, stderr);
-
-    let filtered = filter_next_build(&raw);
-
-    println!("{}", filtered);
-
-    timer.track("next build", "rtk next build", &raw, &filtered);
-
-    // Preserve exit code for CI/CD
-    if !output.status.success() {
-        std::process::exit(output.status.code().unwrap_or(1));
-    }
-
-    Ok(())
-}
-
-/// Filter Next.js build output - extract routes, bundles, warnings
-fn filter_next_build(output: &str) -> String {
-    lazy_static::lazy_static! {
-        // Route line pattern: ○ /dashboard    1.2 kB  132 kB
-        static ref ROUTE_PATTERN: Regex = Regex::new(
-            r"^[○●◐λ✓]\s+(/[^\s]*)\s+(\d+(?:\.\d+)?)\s*(kB|B)"
-        ).unwrap();
-
-        // Bundle size pattern
-        static ref BUNDLE_PATTERN: Regex = Regex::new(
-            r"^[○●◐λ✓]\s+([\w/\-\.]+)\s+(\d+(?:\.\d+)?)\s*(kB|B)\s+(\d+(?:\.\d+)?)\s*(kB|B)"
-        ).unwrap();
-    }
-
-    let mut routes_static = 0;
-    let mut routes_dynamic = 0;
-    let mut routes_total = 0;
-    let mut bundles: Vec<(String, f64, Option<f64>)> = Vec::new();
-    let mut warnings = 0;
-    let mut errors = 0;
-    let mut build_time = String::new();
-
-    // Strip ANSI codes
-    let clean_output = strip_ansi(output);
-
-    for line in clean_output.lines() {
-        // Count route types by symbol
-        if line.starts_with("○") {
-            routes_static += 1;
-            routes_total += 1;
-        } else if line.starts_with("●") || line.starts_with("◐") {
-            routes_dynamic += 1;
-            routes_total += 1;
-        } else if line.starts_with("λ") {
-            routes_total += 1;
-        }
-
-        // Extract bundle information (route + size + total size)
-        if let Some(caps) = BUNDLE_PATTERN.captures(line) {
-            let route = caps[1].to_string();
-            let size: f64 = caps[2].parse().unwrap_or(0.0);
-            let total: f64 = caps[4].parse().unwrap_or(0.0);
-
-            // Calculate percentage increase if both sizes present
-            let pct_change = if total > 0.0 {
-                Some(((total - size) / size) * 100.0)
-            } else {
-                None
-            };
-
-            bundles.push((route, total, pct_change));
-        }
-
-        // Count warnings and errors
-        if line.to_lowercase().contains("warning") {
-            warnings += 1;
-        }
-        if line.to_lowercase().contains("error") && !line.contains("0 error") {
-            errors += 1;
-        }
-
-        // Extract build time
-        if line.contains("Compiled") || line.contains("in") {
-            if let Some(time_match) = extract_time(line) {
-                build_time = time_match;
-            }
-        }
-    }
-
-    // Detect if build was skipped (already built)
-    let already_built = clean_output.contains("already optimized")
-        || clean_output.contains("Cache")
-        || (routes_total == 0 && clean_output.contains("Ready"));
-
-    // Build filtered output
-    let mut result = String::new();
-    result.push_str("⚡ Next.js Build\n");
-    result.push_str("═══════════════════════════════════════\n");
-
-    if already_built && routes_total == 0 {
-        result.push_str("✓ Already built (using cache)\n\n");
-    } else if routes_total > 0 {
-        result.push_str(&format!(
-            "✓ {} routes ({} static, {} dynamic)\n\n",
-            routes_total, routes_static, routes_dynamic
-        ));
-    }
-
-    if !bundles.is_empty() {
-        result.push_str("Bundles:\n");
-
-        // Sort by size (descending) and show top 10
-        bundles.sort_by(|a, b| b.1.partial_cmp(&a.1).unwrap_or(std::cmp::Ordering::Equal));
-
-        for (route, size, pct_change) in bundles.iter().take(10) {
-            let warning_marker = if let Some(pct) = pct_change {
-                if *pct > 10.0 {
-                    format!(" ⚠️ (+{:.0}%)", pct)
-                } else {
-                    String::new()
-                }
-            } else {
-                String::new()
-            };
-
-            result.push_str(&format!(
-                "  {:<30} {:>6.0} kB{}\n",
-                truncate(route, 30),
-                size,
-                warning_marker
-            ));
-        }
-
-        if bundles.len() > 10 {
-            result.push_str(&format!("\n  ... +{} more routes\n", bundles.len() - 10));
-        }
-
-        result.push('\n');
-    }
-
-    // Show build time and status
-    if !build_time.is_empty() {
-        result.push_str(&format!("Time: {} | ", build_time));
-    }
-
-    result.push_str(&format!("Errors: {} | Warnings: {}\n", errors, warnings));
-
-    result.trim().to_string()
-}
-
-/// Extract time from build output (e.g., "Compiled in 34.2s")
-fn extract_time(line: &str) -> Option<String> {
-    lazy_static::lazy_static! {
-        static ref TIME_RE: Regex = Regex::new(r"(\d+(?:\.\d+)?)\s*(s|ms)").unwrap();
-    }
-
-    TIME_RE
-        .captures(line)
-        .map(|caps| format!("{}{}", &caps[1], &caps[2]))
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-
-    #[test]
-    fn test_filter_next_build() {
-        let output = r#"
-   ▲ Next.js 15.2.0
-
-   Creating an optimized production build ...
-✓ Compiled successfully
-✓ Linting and checking validity of types
-✓ Collecting page data
-○ /                            1.2 kB        132 kB
-● /dashboard                   2.5 kB        156 kB
-○ /api/auth                    0.5 kB         89 kB
-
-Route (app)                    Size     First Load JS
-┌ ○ /                          1.2 kB        132 kB
-├ ● /dashboard                 2.5 kB        156 kB
-└ ○ /api/auth                  0.5 kB         89 kB
-
-○  (Static)  prerendered as static content
-●  (SSG)     prerendered as static HTML
-λ  (Server)  server-side renders at runtime
-
-✓ Built in 34.2s
-"#;
-        let result = filter_next_build(output);
-        assert!(result.contains("⚡ Next.js Build"));
-        assert!(result.contains("routes"));
-        assert!(!result.contains("Creating an optimized")); // Should filter verbose logs
-    }
-
-    #[test]
-    fn test_extract_time() {
-        assert_eq!(extract_time("Built in 34.2s"), Some("34.2s".to_string()));
-        assert_eq!(
-            extract_time("Compiled in 1250ms"),
-            Some("1250ms".to_string())
-        );
-        assert_eq!(extract_time("No time here"), None);
-    }
-}