@hasna/terminal 2.2.0 → 2.3.0

package/temp/rtk/src/mypy_cmd.rs

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

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