feat: npm/npx routing, pnpm build/typecheck, --skip-env flag

src/json_cmd.rs

@@ -1,8 +1,8 @@
+use crate::tracking;
 use anyhow::{Context, Result};
 use serde_json::Value;
 use std::fs;
 use std::path::Path;
-use crate::tracking;
 
 /// Show JSON structure without values
 pub fn run(file: &Path, max_depth: usize, verbose: u8) -> Result<()> {
@@ -13,15 +13,24 @@ pub fn run(file: &Path, max_depth: usize, verbose: u8) -> Result<()> {
     let content = fs::read_to_string(file)
         .with_context(|| format!("Failed to read file: {}", file.display()))?;
 
-    let value: Value = serde_json::from_str(&content)
-        .with_context(|| format!("Failed to parse JSON: {}", file.display()))?;
-
-    let schema = extract_schema(&value, 0, max_depth);
+    let schema = filter_json_string(&content, max_depth)?;
     println!("{}", schema);
-    tracking::track(&format!("cat {}", file.display()), "rtk json", &content, &schema);
+    tracking::track(
+        &format!("cat {}", file.display()),
+        "rtk json",
+        &content,
+        &schema,
+    );
     Ok(())
 }
 
+/// Parse a JSON string and return its schema representation.
+/// Useful for piping JSON from other commands (e.g., `gh api`, `curl`).
+pub fn filter_json_string(json_str: &str, max_depth: usize) -> Result<String> {
+    let value: Value = serde_json::from_str(json_str).context("Failed to parse JSON")?;
+    Ok(extract_schema(&value, 0, max_depth))
+}
+
 fn extract_schema(value: &Value, depth: usize, max_depth: usize) -> String {
     let indent = "  ".repeat(depth);
 
@@ -82,7 +91,10 @@ fn extract_schema(value: &Value, depth: usize, max_depth: usize) -> String {
                     let val_trimmed = val_schema.trim();
 
                     // Inline simple types
-                    let is_simple = matches!(val, Value::Null | Value::Bool(_) | Value::Number(_) | Value::String(_));
+                    let is_simple = matches!(
+                        val,
+                        Value::Null | Value::Bool(_) | Value::Number(_) | Value::String(_)
+                    );
 
                     if is_simple {
                         if i < keys.len() - 1 {

src/main.rs

@@ -1,3 +1,4 @@
+mod cargo_cmd;
 mod cc_economics;
 mod ccusage;
 mod config;
@@ -19,6 +20,7 @@ mod local_llm;
 mod log_cmd;
 mod ls;
 mod next_cmd;
+mod npm_cmd;
 mod playwright_cmd;
 mod pnpm_cmd;
 mod prettier_cmd;
@@ -32,7 +34,7 @@ mod utils;
 mod vitest_cmd;
 mod wget_cmd;
 
-use anyhow::Result;
+use anyhow::{Context, Result};
 use clap::{Parser, Subcommand};
 use std::path::PathBuf;
 
@@ -54,6 +56,10 @@ struct Cli {
     /// Ultra-compact mode: ASCII icons, inline format (Level 2 optimizations)
     #[arg(short = 'u', long, global = true)]
     ultra_compact: bool,
+
+    /// Set SKIP_ENV_VALIDATION=1 for child processes (Next.js, tsc, lint, prisma)
+    #[arg(long = "skip-env", global = true)]
+    skip_env: bool,
 }
 
 #[derive(Subcommand)]
@@ -357,6 +363,26 @@ enum Commands {
         #[arg(trailing_var_arg = true, allow_hyphen_values = true)]
         args: Vec<String>,
     },
+
+    /// Cargo commands with compact output
+    Cargo {
+        #[command(subcommand)]
+        command: CargoCommands,
+    },
+
+    /// npm run with filtered output (strip boilerplate)
+    Npm {
+        /// npm run arguments (script name + options)
+        #[arg(trailing_var_arg = true, allow_hyphen_values = true)]
+        args: Vec<String>,
+    },
+
+    /// npx with intelligent routing (tsc, eslint, prisma -> specialized filters)
+    Npx {
+        /// npx arguments (command + options)
+        #[arg(trailing_var_arg = true, allow_hyphen_values = true)]
+        args: Vec<String>,
+    },
 }
 
 #[derive(Subcommand)]
@@ -391,6 +417,32 @@ enum GitCommands {
     Push,
     /// Pull → "ok ✓ <stats>"
     Pull,
+    /// Compact branch listing (current/local/remote)
+    Branch {
+        /// Git branch arguments (supports -d, -D, -m, etc.)
+        #[arg(trailing_var_arg = true, allow_hyphen_values = true)]
+        args: Vec<String>,
+    },
+    /// Fetch → "ok fetched (N new refs)"
+    Fetch {
+        /// Git fetch arguments
+        #[arg(trailing_var_arg = true, allow_hyphen_values = true)]
+        args: Vec<String>,
+    },
+    /// Stash management (list, show, pop, apply, drop)
+    Stash {
+        /// Subcommand: list, show, pop, apply, drop, push
+        subcommand: Option<String>,
+        /// Additional arguments
+        #[arg(trailing_var_arg = true, allow_hyphen_values = true)]
+        args: Vec<String>,
+    },
+    /// Compact worktree listing
+    Worktree {
+        /// Git worktree arguments (add, remove, prune, or empty for list)
+        #[arg(trailing_var_arg = true, allow_hyphen_values = true)]
+        args: Vec<String>,
+    },
 }
 
 #[derive(Subcommand)]
@@ -418,6 +470,18 @@ enum PnpmCommands {
         #[arg(trailing_var_arg = true, allow_hyphen_values = true)]
         args: Vec<String>,
     },
+    /// Build (delegates to next build filter)
+    Build {
+        /// Additional build arguments
+        #[arg(trailing_var_arg = true, allow_hyphen_values = true)]
+        args: Vec<String>,
+    },
+    /// Typecheck (delegates to tsc filter)
+    Typecheck {
+        /// Additional typecheck arguments
+        #[arg(trailing_var_arg = true, allow_hyphen_values = true)]
+        args: Vec<String>,
+    },
 }
 
 #[derive(Subcommand)]
@@ -512,6 +576,28 @@ enum PrismaMigrateCommands {
     },
 }
 
+#[derive(Subcommand)]
+enum CargoCommands {
+    /// Build with compact output (strip Compiling lines, keep errors)
+    Build {
+        /// Additional cargo build arguments
+        #[arg(trailing_var_arg = true, allow_hyphen_values = true)]
+        args: Vec<String>,
+    },
+    /// Test with failures-only output
+    Test {
+        /// Additional cargo test arguments
+        #[arg(trailing_var_arg = true, allow_hyphen_values = true)]
+        args: Vec<String>,
+    },
+    /// Clippy with warnings grouped by lint rule
+    Clippy {
+        /// Additional cargo clippy arguments
+        #[arg(trailing_var_arg = true, allow_hyphen_values = true)]
+        args: Vec<String>,
+    },
+}
+
 fn main() -> Result<()> {
     let cli = Cli::parse();
 
@@ -564,6 +650,23 @@ fn main() -> Result<()> {
             GitCommands::Pull => {
                 git::run(git::GitCommand::Pull, &[], None, cli.verbose)?;
             }
+            GitCommands::Branch { args } => {
+                git::run(git::GitCommand::Branch, &args, None, cli.verbose)?;
+            }
+            GitCommands::Fetch { args } => {
+                git::run(git::GitCommand::Fetch, &args, None, cli.verbose)?;
+            }
+            GitCommands::Stash { subcommand, args } => {
+                git::run(
+                    git::GitCommand::Stash { subcommand },
+                    &args,
+                    None,
+                    cli.verbose,
+                )?;
+            }
+            GitCommands::Worktree { args } => {
+                git::run(git::GitCommand::Worktree, &args, None, cli.verbose)?;
+            }
         },
 
         Commands::Gh { subcommand, args } => {
@@ -584,6 +687,12 @@ fn main() -> Result<()> {
                     cli.verbose,
                 )?;
             }
+            PnpmCommands::Build { args } => {
+                next_cmd::run(&args, cli.verbose)?;
+            }
+            PnpmCommands::Typecheck { args } => {
+                tsc_cmd::run(&args, cli.verbose)?;
+            }
         },
 
         Commands::Err { command } => {
@@ -823,6 +932,88 @@ fn main() -> Result<()> {
         Commands::Playwright { args } => {
             playwright_cmd::run(&args, cli.verbose)?;
         }
+
+        Commands::Cargo { command } => match command {
+            CargoCommands::Build { args } => {
+                cargo_cmd::run(cargo_cmd::CargoCommand::Build, &args, cli.verbose)?;
+            }
+            CargoCommands::Test { args } => {
+                cargo_cmd::run(cargo_cmd::CargoCommand::Test, &args, cli.verbose)?;
+            }
+            CargoCommands::Clippy { args } => {
+                cargo_cmd::run(cargo_cmd::CargoCommand::Clippy, &args, cli.verbose)?;
+            }
+        },
+
+        Commands::Npm { args } => {
+            npm_cmd::run(&args, cli.verbose, cli.skip_env)?;
+        }
+
+        Commands::Npx { args } => {
+            if args.is_empty() {
+                anyhow::bail!("npx requires a command argument");
+            }
+
+            // Intelligent routing: delegate to specialized filters
+            match args[0].as_str() {
+                "tsc" | "typescript" => {
+                    tsc_cmd::run(&args[1..], cli.verbose)?;
+                }
+                "eslint" => {
+                    lint_cmd::run(&args[1..], cli.verbose)?;
+                }
+                "prisma" => {
+                    // Route to prisma_cmd based on subcommand
+                    if args.len() > 1 {
+                        let prisma_args: Vec<String> = args[2..].to_vec();
+                        match args[1].as_str() {
+                            "generate" => {
+                                prisma_cmd::run(
+                                    prisma_cmd::PrismaCommand::Generate,
+                                    &prisma_args,
+                                    cli.verbose,
+                                )?;
+                            }
+                            "db" if args.len() > 2 && args[2] == "push" => {
+                                prisma_cmd::run(
+                                    prisma_cmd::PrismaCommand::DbPush,
+                                    &args[3..],
+                                    cli.verbose,
+                                )?;
+                            }
+                            _ => {
+                                // Passthrough other prisma subcommands
+                                let mut cmd = std::process::Command::new("npx");
+                                for arg in &args {
+                                    cmd.arg(arg);
+                                }
+                                let status = cmd.status().context("Failed to run npx prisma")?;
+                                std::process::exit(status.code().unwrap_or(1));
+                            }
+                        }
+                    } else {
+                        let status = std::process::Command::new("npx")
+                            .arg("prisma")
+                            .status()
+                            .context("Failed to run npx prisma")?;
+                        std::process::exit(status.code().unwrap_or(1));
+                    }
+                }
+                "next" => {
+                    next_cmd::run(&args[1..], cli.verbose)?;
+                }
+                "prettier" => {
+                    prettier_cmd::run(&args[1..], cli.verbose)?;
+                }
+                "playwright" => {
+                    playwright_cmd::run(&args[1..], cli.verbose)?;
+                }
+                _ => {
+                    // Generic passthrough with npm boilerplate filter
+                    npm_cmd::run(&args, cli.verbose, cli.skip_env)?;
+                }
+            }
+        }
     }
 
     Ok(())