@hasna/terminal 2.0.5 → 2.3.0

package/temp/rtk/src/npm_cmd.rs

@@ -0,0 +1,236 @@
+use crate::tracking;
+use anyhow::{Context, Result};
+use std::process::Command;
+
+/// Known npm subcommands that should NOT get "run" injected.
+/// Shared between production code and tests to avoid drift.
+const NPM_SUBCOMMANDS: &[&str] = &[
+    "install",
+    "i",
+    "ci",
+    "uninstall",
+    "remove",
+    "rm",
+    "update",
+    "up",
+    "list",
+    "ls",
+    "outdated",
+    "init",
+    "create",
+    "publish",
+    "pack",
+    "link",
+    "audit",
+    "fund",
+    "exec",
+    "explain",
+    "why",
+    "search",
+    "view",
+    "info",
+    "show",
+    "config",
+    "set",
+    "get",
+    "cache",
+    "prune",
+    "dedupe",
+    "doctor",
+    "help",
+    "version",
+    "prefix",
+    "root",
+    "bin",
+    "bugs",
+    "docs",
+    "home",
+    "repo",
+    "ping",
+    "whoami",
+    "token",
+    "profile",
+    "team",
+    "access",
+    "owner",
+    "deprecate",
+    "dist-tag",
+    "star",
+    "stars",
+    "login",
+    "logout",
+    "adduser",
+    "unpublish",
+    "pkg",
+    "diff",
+    "rebuild",
+    "test",
+    "t",
+    "start",
+    "stop",
+    "restart",
+];
+
+pub fn run(args: &[String], verbose: u8, skip_env: bool) -> Result<()> {
+    let timer = tracking::TimedExecution::start();
+
+    let mut cmd = Command::new("npm");
+
+    // Determine if this is "npm run <script>" or another npm subcommand (install, list, etc.)
+    // Only inject "run" when args look like a script name, not a known npm subcommand.
+    let first_arg = args.first().map(|s| s.as_str());
+    let is_run_explicit = first_arg == Some("run");
+    let is_npm_subcommand = first_arg
+        .map(|a| NPM_SUBCOMMANDS.contains(&a) || a.starts_with('-'))
+        .unwrap_or(false);
+
+    let effective_args = if is_run_explicit {
+        // "rtk npm run build" → "npm run build"
+        cmd.arg("run");
+        &args[1..]
+    } else if is_npm_subcommand {
+        // "rtk npm install express" → "npm install express"
+        args
+    } else {
+        // "rtk npm build" → "npm run build" (assume script name)
+        cmd.arg("run");
+        args
+    };
+
+    for arg in effective_args {
+        cmd.arg(arg);
+    }
+
+    if skip_env {
+        cmd.env("SKIP_ENV_VALIDATION", "1");
+    }
+
+    if verbose > 0 {
+        eprintln!("Running: npm {}", args.join(" "));
+    }
+
+    let output = cmd.output().context("Failed to run npm")?;
+    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_npm_output(&raw);
+    println!("{}", filtered);
+
+    timer.track(
+        &format!("npm {}", args.join(" ")),
+        &format!("rtk npm {}", args.join(" ")),
+        &raw,
+        &filtered,
+    );
+
+    if !output.status.success() {
+        std::process::exit(output.status.code().unwrap_or(1));
+    }
+
+    Ok(())
+}
+
+/// Filter npm run output - strip boilerplate, progress bars, npm WARN
+fn filter_npm_output(output: &str) -> String {
+    let mut result = Vec::new();
+
+    for line in output.lines() {
+        // Skip npm boilerplate
+        if line.starts_with('>') && line.contains('@') {
+            continue;
+        }
+        // Skip npm lifecycle scripts
+        if line.trim_start().starts_with("npm WARN") {
+            continue;
+        }
+        if line.trim_start().starts_with("npm notice") {
+            continue;
+        }
+        // Skip progress indicators
+        if line.contains("⸩") || line.contains("⸨") || line.contains("...") && line.len() < 10 {
+            continue;
+        }
+        // Skip empty lines
+        if line.trim().is_empty() {
+            continue;
+        }
+
+        result.push(line.to_string());
+    }
+
+    if result.is_empty() {
+        "ok ✓".to_string()
+    } else {
+        result.join("\n")
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_filter_npm_output() {
+        let output = r#"
+> project@1.0.0 build
+> next build
+
+npm WARN deprecated inflight@1.0.6: This module is not supported
+npm notice
+
+   Creating an optimized production build...
+   ✓ Build completed
+"#;
+        let result = filter_npm_output(output);
+        assert!(!result.contains("npm WARN"));
+        assert!(!result.contains("npm notice"));
+        assert!(!result.contains("> project@"));
+        assert!(result.contains("Build completed"));
+    }
+
+    #[test]
+    fn test_npm_subcommand_routing() {
+        // Uses the shared NPM_SUBCOMMANDS constant — no drift between prod and test
+        fn needs_run_injection(args: &[&str]) -> bool {
+            let first = args.first().copied();
+            let is_run_explicit = first == Some("run");
+            let is_subcommand = first
+                .map(|a| NPM_SUBCOMMANDS.contains(&a) || a.starts_with('-'))
+                .unwrap_or(false);
+            !is_run_explicit && !is_subcommand
+        }
+
+        // Known subcommands should NOT get "run" injected
+        for subcmd in NPM_SUBCOMMANDS {
+            assert!(
+                !needs_run_injection(&[subcmd]),
+                "'npm {}' should NOT inject 'run'",
+                subcmd
+            );
+        }
+
+        // Script names SHOULD get "run" injected
+        for script in &["build", "dev", "lint", "typecheck", "deploy"] {
+            assert!(
+                needs_run_injection(&[script]),
+                "'npm {}' SHOULD inject 'run'",
+                script
+            );
+        }
+
+        // Flags should NOT get "run" injected
+        assert!(!needs_run_injection(&["--version"]));
+        assert!(!needs_run_injection(&["-h"]));
+
+        // Explicit "run" should NOT inject another "run"
+        assert!(!needs_run_injection(&["run", "build"]));
+    }
+
+    #[test]
+    fn test_filter_npm_output_empty() {
+        let output = "\n\n\n";
+        let result = filter_npm_output(output);
+        assert_eq!(result, "ok ✓");
+    }
+}

package/temp/rtk/src/parser/README.md

@@ -0,0 +1,267 @@
+# Parser Infrastructure
+
+## Overview
+
+The parser infrastructure provides a unified, three-tier parsing system for tool outputs with graceful degradation:
+
+- **Tier 1 (Full)**: Complete JSON parsing with all structured data
+- **Tier 2 (Degraded)**: Partial parsing with warnings (fallback regex)
+- **Tier 3 (Passthrough)**: Raw output truncation with error markers
+
+This ensures RTK **never returns false data silently** while maintaining maximum token efficiency.
+
+## Architecture
+
+```
+┌─────────────────────────────────────────────────────────┐
+│                    ToolCommand Builder                   │
+│  Command::new("vitest").arg("--reporter=json")          │
+└─────────────────────┬───────────────────────────────────┘
+                      │
+┌─────────────────────▼───────────────────────────────────┐
+│                   OutputParser<T> Trait                  │
+│  parse() → ParseResult<T>                               │
+│    ├─ Full(T)           - Tier 1: Complete JSON parse   │
+│    ├─ Degraded(T, warn) - Tier 2: Partial with warnings │
+│    └─ Passthrough(str)  - Tier 3: Truncated raw output  │
+└─────────────────────┬───────────────────────────────────┘
+                      │
+┌─────────────────────▼───────────────────────────────────┐
+│                  Canonical Types                         │
+│  TestResult, LintResult, DependencyState, BuildOutput   │
+└─────────────────────┬───────────────────────────────────┘
+                      │
+┌─────────────────────▼───────────────────────────────────┐
+│                  TokenFormatter Trait                    │
+│  format_compact() / format_verbose() / format_ultra()   │
+└─────────────────────────────────────────────────────────┘
+```
+
+## Usage Example
+
+### 1. Define Tool-Specific Parser
+
+```rust
+use crate::parser::{OutputParser, ParseResult, TestResult};
+
+struct VitestParser;
+
+impl OutputParser for VitestParser {
+    type Output = TestResult;
+
+    fn parse(input: &str) -> ParseResult<TestResult> {
+        // Tier 1: Try JSON parsing
+        match serde_json::from_str::<VitestJsonOutput>(input) {
+            Ok(json) => {
+                let result = TestResult {
+                    total: json.num_total_tests,
+                    passed: json.num_passed_tests,
+                    failed: json.num_failed_tests,
+                    // ... map fields
+                };
+                ParseResult::Full(result)
+            }
+            Err(e) => {
+                // Tier 2: Try regex extraction
+                if let Some(stats) = extract_stats_regex(input) {
+                    ParseResult::Degraded(
+                        stats,
+                        vec![format!("JSON parse failed: {}", e)]
+                    )
+                } else {
+                    // Tier 3: Passthrough
+                    ParseResult::Passthrough(truncate_output(input, 500))
+                }
+            }
+        }
+    }
+}
+```
+
+### 2. Use Parser in Command Module
+
+```rust
+use crate::parser::{OutputParser, TokenFormatter, FormatMode};
+
+pub fn run_vitest(args: &[String], verbose: u8) -> Result<()> {
+    let mut cmd = Command::new("pnpm");
+    cmd.arg("vitest").arg("--reporter=json");
+    // ... add args
+
+    let output = cmd.output()?;
+    let stdout = String::from_utf8_lossy(&output.stdout);
+
+    // Parse output
+    let result = VitestParser::parse(&stdout);
+
+    // Format based on verbosity
+    let mode = FormatMode::from_verbosity(verbose);
+    let formatted = match result {
+        ParseResult::Full(data) => data.format(mode),
+        ParseResult::Degraded(data, warnings) => {
+            if verbose > 0 {
+                for warn in warnings {
+                    eprintln!("[RTK:DEGRADED] {}", warn);
+                }
+            }
+            data.format(mode)
+        }
+        ParseResult::Passthrough(raw) => {
+            eprintln!("[RTK:PASSTHROUGH] Parser failed, showing truncated output");
+            raw
+        }
+    };
+
+    println!("{}", formatted);
+    Ok(())
+}
+```
+
+## Canonical Types
+
+### TestResult
+For test runners (vitest, playwright, jest, etc.)
+- Fields: `total`, `passed`, `failed`, `skipped`, `duration_ms`, `failures`
+- Formatter: Shows summary + failure details (compact: top 5, verbose: all)
+
+### LintResult
+For linters (eslint, biome, tsc, etc.)
+- Fields: `total_files`, `files_with_issues`, `total_issues`, `errors`, `warnings`, `issues`
+- Formatter: Groups by rule_id, shows top violations
+
+### DependencyState
+For package managers (pnpm, npm, cargo, etc.)
+- Fields: `total_packages`, `outdated_count`, `dependencies`
+- Formatter: Shows upgrade paths (current → latest)
+
+### BuildOutput
+For build tools (next, webpack, vite, cargo, etc.)
+- Fields: `success`, `duration_ms`, `bundles`, `routes`, `warnings`, `errors`
+- Formatter: Shows bundle sizes, route metrics
+
+## Format Modes
+
+### Compact (default, verbosity=0)
+- Summary only
+- Top 5-10 items
+- Token-optimized
+
+### Verbose (verbosity=1)
+- Full details
+- All items (up to 20)
+- Human-readable
+
+### Ultra (verbosity=2+)
+- Symbols: ✓✗⚠📦⬆️
+- Ultra-compressed
+- 30-50% token reduction
+
+## Error Handling
+
+### ParseError Types
+- `JsonError`: Line/column context for debugging
+- `PatternMismatch`: Regex pattern failed
+- `PartialParse`: Some fields missing
+- `InvalidFormat`: Unexpected structure
+- `MissingField`: Required field absent
+- `VersionMismatch`: Tool version incompatible
+- `EmptyOutput`: No data to parse
+
+### Degradation Warnings
+
+```
+[RTK:DEGRADED] vitest parser: JSON parse failed at line 42, using regex fallback
+[RTK:PASSTHROUGH] playwright parser: Pattern mismatch, showing truncated output
+```
+
+## Migration Guide
+
+### Existing Module → Parser Trait
+
+**Before:**
+```rust
+fn run_vitest(args: &[String]) -> Result<()> {
+    let output = Command::new("vitest").output()?;
+    let filtered = filter_vitest_output(&output.stdout);
+    println!("{}", filtered);
+    Ok(())
+}
+```
+
+**After:**
+```rust
+fn run_vitest(args: &[String], verbose: u8) -> Result<()> {
+    let output = Command::new("vitest")
+        .arg("--reporter=json")
+        .output()?;
+
+    let result = VitestParser::parse(&output.stdout);
+    let mode = FormatMode::from_verbosity(verbose);
+
+    match result {
+        ParseResult::Full(data) | ParseResult::Degraded(data, _) => {
+            println!("{}", data.format(mode));
+        }
+        ParseResult::Passthrough(raw) => {
+            println!("{}", raw);
+        }
+    }
+    Ok(())
+}
+```
+
+## Testing
+
+### Unit Tests
+```bash
+cargo test parser::tests
+```
+
+### Integration Tests
+```bash
+# Test with real tool outputs
+echo '{"testResults": [...]}' | cargo run -- vitest parse
+```
+
+### Tier Validation
+```rust
+#[test]
+fn test_vitest_json_parsing() {
+    let json = include_str!("fixtures/vitest-v1.json");
+    let result = VitestParser::parse(json);
+    assert_eq!(result.tier(), 1); // Full parse
+    assert!(result.is_ok());
+}
+
+#[test]
+fn test_vitest_regex_fallback() {
+    let text = "Test Files  2 passed (2)\n Tests  13 passed (13)";
+    let result = VitestParser::parse(text);
+    assert_eq!(result.tier(), 2); // Degraded
+    assert!(!result.warnings().is_empty());
+}
+```
+
+## Benefits
+
+1. **Maintenance**: Tool version changes break gracefully (Tier 2/3 fallback)
+2. **Reliability**: Never silent failures or false data
+3. **Observability**: Clear degradation markers in verbose mode
+4. **Token Efficiency**: Structured data enables better compression
+5. **Consistency**: Unified interface across all tool types
+6. **Testing**: Fixture-based regression tests for multiple versions
+
+## Roadmap
+
+### Phase 4: Module Migration
+- [ ] vitest_cmd.rs → VitestParser
+- [ ] playwright_cmd.rs → PlaywrightParser
+- [ ] pnpm_cmd.rs → PnpmParser (list, outdated)
+- [ ] lint_cmd.rs → EslintParser
+- [ ] tsc_cmd.rs → TscParser
+- [ ] gh_cmd.rs → GhParser
+
+### Phase 5: Observability
+- [ ] Extend tracking.db: `parse_tier`, `format_mode`
+- [ ] `rtk parse-health` command
+- [ ] Alert if degradation > 10%

package/temp/rtk/src/parser/error.rs

@@ -0,0 +1,46 @@
+/// Parser error types for structured output parsing
+use thiserror::Error;
+
+#[derive(Error, Debug)]
+pub enum ParseError {
+    #[error("JSON parse failed at line {line}, column {col}: {msg}")]
+    JsonError {
+        line: usize,
+        col: usize,
+        msg: String,
+    },
+
+    #[error("Pattern mismatch: expected {expected}")]
+    PatternMismatch { expected: &'static str },
+
+    #[error("Partial parse: got {found}, missing fields: {missing:?}")]
+    PartialParse {
+        found: String,
+        missing: Vec<&'static str>,
+    },
+
+    #[error("Invalid format: {0}")]
+    InvalidFormat(String),
+
+    #[error("Missing required field: {0}")]
+    MissingField(&'static str),
+
+    #[error("Version mismatch: got {got}, expected {expected}")]
+    VersionMismatch { got: String, expected: String },
+
+    #[error("Empty output")]
+    EmptyOutput,
+
+    #[error(transparent)]
+    Other(#[from] anyhow::Error),
+}
+
+impl From<serde_json::Error> for ParseError {
+    fn from(err: serde_json::Error) -> Self {
+        ParseError::JsonError {
+            line: err.line(),
+            col: err.column(),
+            msg: err.to_string(),
+        }
+    }
+}