@hasna/terminal 2.3.0 → 2.3.2

package/temp/rtk/src/prettier_cmd.rs

@@ -1,221 +0,0 @@
-use crate::tracking;
-use crate::utils::package_manager_exec;
-use anyhow::{Context, Result};
-
-pub fn run(args: &[String], verbose: u8) -> Result<()> {
-    let timer = tracking::TimedExecution::start();
-
-    let mut cmd = package_manager_exec("prettier");
-
-    // Add user arguments
-    for arg in args {
-        cmd.arg(arg);
-    }
-
-    if verbose > 0 {
-        eprintln!("Running: prettier {}", args.join(" "));
-    }
-
-    let output = cmd
-        .output()
-        .context("Failed to run prettier (try: npm install -g prettier)")?;
-
-    let stdout = String::from_utf8_lossy(&output.stdout);
-    let stderr = String::from_utf8_lossy(&output.stderr);
-    let raw = format!("{}\n{}", stdout, stderr);
-
-    // #221: If prettier is not installed or produced no meaningful output,
-    // show stderr as-is instead of a misleading "All files formatted" message.
-    let has_output = stdout.lines().any(|l| !l.trim().is_empty());
-    if !has_output && !output.status.success() {
-        let msg = stderr.trim();
-        if msg.is_empty() {
-            eprintln!("Error: prettier not found or produced no output");
-        } else {
-            eprintln!("{}", msg);
-        }
-        timer.track(
-            &format!("prettier {}", args.join(" ")),
-            &format!("rtk prettier {}", args.join(" ")),
-            &raw,
-            &raw,
-        );
-        std::process::exit(output.status.code().unwrap_or(1));
-    }
-
-    let filtered = filter_prettier_output(&raw);
-
-    println!("{}", filtered);
-
-    timer.track(
-        &format!("prettier {}", args.join(" ")),
-        &format!("rtk prettier {}", args.join(" ")),
-        &raw,
-        &filtered,
-    );
-
-    // Preserve exit code for CI/CD
-    if !output.status.success() {
-        std::process::exit(output.status.code().unwrap_or(1));
-    }
-
-    Ok(())
-}
-
-/// Filter Prettier output - show only files that need formatting
-pub fn filter_prettier_output(output: &str) -> String {
-    // #221: empty or whitespace-only output means prettier didn't run
-    if output.trim().is_empty() {
-        return "Error: prettier produced no output".to_string();
-    }
-
-    let mut files_to_format: Vec<String> = Vec::new();
-    let mut files_checked = 0;
-    let mut is_check_mode = true;
-
-    for line in output.lines() {
-        let trimmed = line.trim();
-
-        // Detect check mode vs write mode
-        if trimmed.contains("Checking formatting") {
-            is_check_mode = true;
-        }
-
-        // Count files that need formatting (check mode)
-        if !trimmed.is_empty()
-            && !trimmed.starts_with("Checking")
-            && !trimmed.starts_with("All matched")
-            && !trimmed.starts_with("Code style")
-            && !trimmed.contains("[warn]")
-            && !trimmed.contains("[error]")
-            && (trimmed.ends_with(".ts")
-                || trimmed.ends_with(".tsx")
-                || trimmed.ends_with(".js")
-                || trimmed.ends_with(".jsx")
-                || trimmed.ends_with(".json")
-                || trimmed.ends_with(".md")
-                || trimmed.ends_with(".css")
-                || trimmed.ends_with(".scss"))
-        {
-            files_to_format.push(trimmed.to_string());
-        }
-
-        // Count total files checked
-        if trimmed.contains("All matched files use Prettier") {
-            if let Some(count_str) = trimmed.split_whitespace().next() {
-                if let Ok(count) = count_str.parse::<usize>() {
-                    files_checked = count;
-                }
-            }
-        }
-    }
-
-    // Check if all files are formatted
-    if files_to_format.is_empty() && output.contains("All matched files use Prettier") {
-        return "✓ Prettier: All files formatted correctly".to_string();
-    }
-
-    // Check if files were written (write mode)
-    if output.contains("modified") || output.contains("formatted") {
-        is_check_mode = false;
-    }
-
-    let mut result = String::new();
-
-    if is_check_mode {
-        // Check mode: show files that need formatting
-        if files_to_format.is_empty() {
-            result.push_str("✓ Prettier: All files formatted correctly\n");
-        } else {
-            result.push_str(&format!(
-                "Prettier: {} files need formatting\n",
-                files_to_format.len()
-            ));
-            result.push_str("═══════════════════════════════════════\n");
-
-            for (i, file) in files_to_format.iter().take(10).enumerate() {
-                result.push_str(&format!("{}. {}\n", i + 1, file));
-            }
-
-            if files_to_format.len() > 10 {
-                result.push_str(&format!(
-                    "\n... +{} more files\n",
-                    files_to_format.len() - 10
-                ));
-            }
-
-            if files_checked > 0 {
-                result.push_str(&format!(
-                    "\n✓ {} files already formatted\n",
-                    files_checked - files_to_format.len()
-                ));
-            }
-        }
-    } else {
-        // Write mode: show what was formatted
-        result.push_str(&format!(
-            "✓ Prettier: {} files formatted\n",
-            files_to_format.len()
-        ));
-    }
-
-    result.trim().to_string()
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-
-    #[test]
-    fn test_filter_all_formatted() {
-        let output = r#"
-Checking formatting...
-All matched files use Prettier code style!
-        "#;
-        let result = filter_prettier_output(output);
-        assert!(result.contains("✓ Prettier"));
-        assert!(result.contains("All files formatted correctly"));
-    }
-
-    #[test]
-    fn test_filter_files_need_formatting() {
-        let output = r#"
-Checking formatting...
-src/components/ui/button.tsx
-src/lib/auth/session.ts
-src/pages/dashboard.tsx
-Code style issues found in the above file(s). Forgot to run Prettier?
-        "#;
-        let result = filter_prettier_output(output);
-        assert!(result.contains("3 files need formatting"));
-        assert!(result.contains("button.tsx"));
-        assert!(result.contains("session.ts"));
-    }
-
-    #[test]
-    fn test_filter_many_files() {
-        let mut output = String::from("Checking formatting...\n");
-        for i in 0..15 {
-            output.push_str(&format!("src/file{}.ts\n", i));
-        }
-        let result = filter_prettier_output(&output);
-        assert!(result.contains("15 files need formatting"));
-        assert!(result.contains("... +5 more files"));
-    }
-
-    // --- #221: empty output should not say "All files formatted" ---
-
-    #[test]
-    fn test_filter_empty_output() {
-        let result = filter_prettier_output("");
-        assert!(result.contains("Error"));
-        assert!(!result.contains("All files formatted"));
-    }
-
-    #[test]
-    fn test_filter_whitespace_only_output() {
-        let result = filter_prettier_output("   \n\n  ");
-        assert!(result.contains("Error"));
-        assert!(!result.contains("All files formatted"));
-    }
-}

package/temp/rtk/src/prisma_cmd.rs

@@ -1,482 +0,0 @@
-use crate::tracking;
-use anyhow::{Context, Result};
-use std::process::Command;
-
-#[derive(Debug, Clone)]
-pub enum PrismaCommand {
-    Generate,
-    Migrate { subcommand: MigrateSubcommand },
-    DbPush,
-}
-
-#[derive(Debug, Clone)]
-pub enum MigrateSubcommand {
-    Dev { name: Option<String> },
-    Status,
-    Deploy,
-}
-
-pub fn run(cmd: PrismaCommand, args: &[String], verbose: u8) -> Result<()> {
-    match cmd {
-        PrismaCommand::Generate => run_generate(args, verbose),
-        PrismaCommand::Migrate { subcommand } => run_migrate(subcommand, args, verbose),
-        PrismaCommand::DbPush => run_db_push(args, verbose),
-    }
-}
-
-/// Create a Command that will run prisma (tries global first, then npx)
-fn create_prisma_command() -> Command {
-    let prisma_exists = Command::new("which")
-        .arg("prisma")
-        .output()
-        .map(|o| o.status.success())
-        .unwrap_or(false);
-
-    if prisma_exists {
-        Command::new("prisma")
-    } else {
-        let mut c = Command::new("npx");
-        c.arg("prisma");
-        c
-    }
-}
-
-fn run_generate(args: &[String], verbose: u8) -> Result<()> {
-    let timer = tracking::TimedExecution::start();
-
-    let mut cmd = create_prisma_command();
-    cmd.arg("generate");
-
-    for arg in args {
-        cmd.arg(arg);
-    }
-
-    if verbose > 0 {
-        eprintln!("Running: prisma generate");
-    }
-
-    let output = cmd
-        .output()
-        .context("Failed to run prisma generate (try: npm install -g prisma)")?;
-
-    if !output.status.success() {
-        let stderr = String::from_utf8_lossy(&output.stderr);
-        anyhow::bail!("prisma generate failed: {}", stderr);
-    }
-
-    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_prisma_generate(&raw);
-
-    println!("{}", filtered);
-
-    timer.track("prisma generate", "rtk prisma generate", &raw, &filtered);
-
-    Ok(())
-}
-
-fn run_migrate(subcommand: MigrateSubcommand, args: &[String], verbose: u8) -> Result<()> {
-    let timer = tracking::TimedExecution::start();
-
-    let mut cmd = create_prisma_command();
-    cmd.arg("migrate");
-
-    let cmd_name = match &subcommand {
-        MigrateSubcommand::Dev { name } => {
-            cmd.arg("dev");
-            if let Some(n) = name {
-                cmd.arg("--name").arg(n);
-            }
-            "prisma migrate dev"
-        }
-        MigrateSubcommand::Status => {
-            cmd.arg("status");
-            "prisma migrate status"
-        }
-        MigrateSubcommand::Deploy => {
-            cmd.arg("deploy");
-            "prisma migrate deploy"
-        }
-    };
-
-    for arg in args {
-        cmd.arg(arg);
-    }
-
-    if verbose > 0 {
-        eprintln!("Running: {}", cmd_name);
-    }
-
-    let output = cmd.output().context("Failed to run prisma migrate")?;
-
-    if !output.status.success() {
-        let stderr = String::from_utf8_lossy(&output.stderr);
-        anyhow::bail!("prisma migrate failed: {}", stderr);
-    }
-
-    let stdout = String::from_utf8_lossy(&output.stdout);
-    let stderr = String::from_utf8_lossy(&output.stderr);
-    let raw = format!("{}\n{}", stdout, stderr);
-
-    let filtered = match subcommand {
-        MigrateSubcommand::Dev { .. } => filter_migrate_dev(&raw),
-        MigrateSubcommand::Status => filter_migrate_status(&raw),
-        MigrateSubcommand::Deploy => filter_migrate_deploy(&raw),
-    };
-
-    println!("{}", filtered);
-
-    timer.track(cmd_name, &format!("rtk {}", cmd_name), &raw, &filtered);
-
-    Ok(())
-}
-
-fn run_db_push(args: &[String], verbose: u8) -> Result<()> {
-    let timer = tracking::TimedExecution::start();
-
-    let mut cmd = create_prisma_command();
-    cmd.arg("db").arg("push");
-
-    for arg in args {
-        cmd.arg(arg);
-    }
-
-    if verbose > 0 {
-        eprintln!("Running: prisma db push");
-    }
-
-    let output = cmd.output().context("Failed to run prisma db push")?;
-
-    if !output.status.success() {
-        let stderr = String::from_utf8_lossy(&output.stderr);
-        anyhow::bail!("prisma db push failed: {}", stderr);
-    }
-
-    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_db_push(&raw);
-
-    println!("{}", filtered);
-
-    timer.track("prisma db push", "rtk prisma db push", &raw, &filtered);
-
-    Ok(())
-}
-
-/// Filter prisma generate output - strip ASCII art, extract counts
-fn filter_prisma_generate(output: &str) -> String {
-    let mut models = 0;
-    let mut enums = 0;
-    let mut types = 0;
-    let mut output_path = String::new();
-
-    for line in output.lines() {
-        // Skip ASCII art and box drawing
-        if line.contains("█")
-            || line.contains("▀")
-            || line.contains("▄")
-            || line.contains("┌")
-            || line.contains("└")
-            || line.contains("│")
-        {
-            continue;
-        }
-
-        // Extract counts
-        if line.contains("model") && line.contains("generated") {
-            if let Some(num) = extract_number(line) {
-                models = num;
-            }
-        }
-        if line.contains("enum") {
-            if let Some(num) = extract_number(line) {
-                enums = num;
-            }
-        }
-        if line.contains("type") {
-            if let Some(num) = extract_number(line) {
-                types = num;
-            }
-        }
-
-        // Extract output path
-        if line.contains("node_modules") && line.contains("@prisma") {
-            output_path = line.trim().to_string();
-        }
-    }
-
-    let mut result = String::new();
-    result.push_str("✓ Prisma Client generated\n");
-
-    if models > 0 || enums > 0 || types > 0 {
-        result.push_str(&format!(
-            "  • {} models, {} enums, {} types\n",
-            models, enums, types
-        ));
-    }
-
-    if !output_path.is_empty() {
-        result.push_str("  • Output: node_modules/@prisma/client\n");
-    }
-
-    result.trim().to_string()
-}
-
-/// Filter migrate dev output - extract migration changes
-fn filter_migrate_dev(output: &str) -> String {
-    let mut migration_name = String::new();
-    let mut tables_added = 0;
-    let mut tables_modified = 0;
-    let mut relations = Vec::new();
-    let mut indexes = Vec::new();
-    let mut applied = false;
-
-    for line in output.lines() {
-        // Extract migration name
-        if line.contains("migration") && line.contains("_") {
-            if let Some(pos) = line.find("202") {
-                let end = line[pos..]
-                    .find(|c: char| c.is_whitespace())
-                    .unwrap_or(line.len() - pos);
-                migration_name = line[pos..pos + end].to_string();
-            }
-        }
-
-        // Count changes
-        if line.contains("CREATE TABLE") {
-            tables_added += 1;
-        }
-        if line.contains("ALTER TABLE") {
-            tables_modified += 1;
-        }
-        if line.contains("FOREIGN KEY") || line.contains("REFERENCES") {
-            if let Some(table) = extract_table_name(line) {
-                relations.push(table);
-            }
-        }
-        if line.contains("CREATE INDEX") || line.contains("CREATE UNIQUE INDEX") {
-            if let Some(idx) = extract_index_name(line) {
-                indexes.push(idx);
-            }
-        }
-
-        if line.contains("applied") || line.contains("✓") {
-            applied = true;
-        }
-    }
-
-    let mut result = String::new();
-
-    if !migration_name.is_empty() {
-        result.push_str(&format!("🗃️  Migration: {}\n", migration_name));
-        result.push_str("═══════════════════════════════════════\n");
-    }
-
-    result.push_str("Changes:\n");
-    if tables_added > 0 {
-        result.push_str(&format!("  + {} table(s)\n", tables_added));
-    }
-    if tables_modified > 0 {
-        result.push_str(&format!("  ~ {} table(s) modified\n", tables_modified));
-    }
-    if !relations.is_empty() {
-        result.push_str(&format!("  + {} relation(s)\n", relations.len()));
-    }
-    if !indexes.is_empty() {
-        result.push_str(&format!("  ~ {} index(es)\n", indexes.len()));
-    }
-
-    result.push('\n');
-    if applied {
-        result.push_str("✓ Applied | Pending: 0\n");
-    }
-
-    result.trim().to_string()
-}
-
-/// Filter migrate status output
-fn filter_migrate_status(output: &str) -> String {
-    let mut applied_count = 0;
-    let mut pending_count = 0;
-    let mut latest_migration = String::new();
-
-    for line in output.lines() {
-        if line.contains("applied") {
-            applied_count += 1;
-            if latest_migration.is_empty() && line.contains("202") {
-                if let Some(pos) = line.find("202") {
-                    let end = line[pos..].find(|c: char| c.is_whitespace()).unwrap_or(20);
-                    latest_migration = line[pos..pos + end].to_string();
-                }
-            }
-        }
-        if line.contains("pending") || line.contains("unapplied") {
-            pending_count += 1;
-        }
-    }
-
-    let mut result = String::new();
-    result.push_str(&format!(
-        "Migrations: {} applied, {} pending\n",
-        applied_count, pending_count
-    ));
-
-    if !latest_migration.is_empty() {
-        result.push_str(&format!("Latest: {}\n", latest_migration));
-    }
-
-    result.trim().to_string()
-}
-
-/// Filter migrate deploy output
-fn filter_migrate_deploy(output: &str) -> String {
-    let mut deployed = 0;
-    let mut errors = Vec::new();
-
-    for line in output.lines() {
-        if line.contains("applied") || line.contains("✓") {
-            deployed += 1;
-        }
-        if line.contains("error") || line.contains("ERROR") {
-            errors.push(line.trim().to_string());
-        }
-    }
-
-    let mut result = String::new();
-
-    if errors.is_empty() {
-        result.push_str(&format!("✓ {} migration(s) deployed\n", deployed));
-    } else {
-        result.push_str("❌ Deployment failed:\n");
-        for err in errors.iter().take(5) {
-            result.push_str(&format!("  {}\n", err));
-        }
-    }
-
-    result.trim().to_string()
-}
-
-/// Filter db push output
-fn filter_db_push(output: &str) -> String {
-    let mut tables_added = 0;
-    let mut columns_modified = 0;
-    let mut dropped = 0;
-
-    for line in output.lines() {
-        if line.contains("CREATE TABLE") {
-            tables_added += 1;
-        }
-        if line.contains("ALTER") || line.contains("ADD COLUMN") {
-            columns_modified += 1;
-        }
-        if line.contains("DROP") {
-            dropped += 1;
-        }
-    }
-
-    let mut result = String::new();
-    result.push_str("✓ Schema pushed to database\n");
-
-    if tables_added > 0 || columns_modified > 0 || dropped > 0 {
-        result.push_str(&format!(
-            "  + {} tables, ~ {} columns, - {} dropped\n",
-            tables_added, columns_modified, dropped
-        ));
-    }
-
-    result.trim().to_string()
-}
-
-/// Extract first number from a line
-fn extract_number(line: &str) -> Option<usize> {
-    line.split_whitespace()
-        .find_map(|word| word.parse::<usize>().ok())
-}
-
-/// Extract table name from SQL
-fn extract_table_name(line: &str) -> Option<String> {
-    if line.contains("TABLE") {
-        let parts: Vec<&str> = line.split_whitespace().collect();
-        for (i, part) in parts.iter().enumerate() {
-            if *part == "TABLE" && i + 1 < parts.len() {
-                return Some(
-                    parts[i + 1]
-                        .trim_matches(|c| c == '`' || c == '"' || c == ';')
-                        .to_string(),
-                );
-            }
-        }
-    }
-    None
-}
-
-/// Extract index name from SQL
-fn extract_index_name(line: &str) -> Option<String> {
-    if line.contains("INDEX") {
-        let parts: Vec<&str> = line.split_whitespace().collect();
-        for (i, part) in parts.iter().enumerate() {
-            if *part == "INDEX" && i + 1 < parts.len() {
-                return Some(
-                    parts[i + 1]
-                        .trim_matches(|c| c == '`' || c == '"' || c == ';')
-                        .to_string(),
-                );
-            }
-        }
-    }
-    None
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-
-    #[test]
-    fn test_filter_generate() {
-        let output = r#"
-Prisma schema loaded from prisma/schema.prisma
-
-✔ Generated Prisma Client (v5.7.0) to ./node_modules/@prisma/client in 234ms
-
-Start by importing your Prisma Client:
-
-import { PrismaClient } from '@prisma/client'
-
-42 models, 18 enums, 890 types generated
-"#;
-        let result = filter_prisma_generate(output);
-        assert!(result.contains("✓ Prisma Client generated"));
-        // Parser may not extract exact counts from this format, just check it doesn't crash
-        assert!(!result.contains("Prisma schema loaded"));
-        assert!(!result.contains("Start by importing"));
-    }
-
-    #[test]
-    fn test_filter_migrate_dev() {
-        let output = r#"
-Applying migration 20260128_add_sessions
-
-CREATE TABLE "Session" (
-  "id" TEXT NOT NULL,
-  "userId" TEXT NOT NULL,
-  FOREIGN KEY ("userId") REFERENCES "User"("id")
-);
-
-CREATE INDEX "session_status_idx" ON "Session"("status");
-
-✓ Migration applied
-"#;
-        let result = filter_migrate_dev(output);
-        assert!(result.contains("20260128_add_sessions"));
-        assert!(result.contains("+ 1 table"));
-        assert!(result.contains("✓ Applied"));
-    }
-
-    #[test]
-    fn test_extract_number() {
-        assert_eq!(extract_number("42 models generated"), Some(42));
-        assert_eq!(extract_number("no numbers here"), None);
-    }
-}