@hasna/terminal 2.3.0 → 2.3.2

package/temp/rtk/src/npm_cmd.rs

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

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

@@ -1,46 +0,0 @@
-/// 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(),
-        }
-    }
-}