feat(pnpm): add rtk pnpm [run] <script> with smart filter routing

[denneulin]

Summary

• Add rtk pnpm run <script> and rtk pnpm <script> shorthand with smart routing to specialized filters
• Strip pnpm boilerplate (lifecycle headers, script echo, "Done in Xs", ELIFECYCLE errors, progress bars)
• Two-tier script routing: static name matching (test, lint, typecheck, vitest, prettier, format) +
  package.json auto-detection for custom scripts (e.g., test:e2e → detects playwright test →
  PlaywrightParser)
• Promote filter_tsc_output, filter_generic_lint, extract_test_summary to pub(crate) for cross-module
  reuse

Token Savings

Script	Route	Expected Savings
pnpm [run] test (vitest)	VitestParser	90%+
pnpm [run] typecheck (tsc)	filter_tsc_output	80%+
pnpm [run] lint (eslint)	filter_generic_lint	80%+
pnpm [run] prettier --check	filter_prettier_output	70%+
pnpm [run] test:e2e (playwright)	PlaywrightParser	80%+
pnpm [run] build (unrouted)	Boilerplate strip only	30-50%

How It Works

• rtk pnpm run test → PnpmCommands::Run → run_script("test") → boilerplate strip → TestRunner filter
• rtk pnpm test → PnpmCommands::Other → is_pnpm_script("test") → run_script("test")
• rtk pnpm test:e2e → reads package.json → detects playwright test → PlaywrightParser
• rtk pnpm store prune → is_pnpm_script("store") = false → passthrough

Test plan

• 25 new unit tests (boilerplate filtering, static routing, prefix matching, prefix exclusions,
  apply_filter labels, integration, is_pnpm_script)
• 4 Clap parsing tests (basic, with args, colon script, shorthand falls to Other)
• cargo fmt --all && cargo clippy --all-targets && cargo test --all — 437 tests pass
• Manual test with real pnpm project: rtk pnpm run test, rtk pnpm test, rtk pnpm run lint

[pszymkowiak]

Review: PR #232

Thanks for this PR — great initiative! The two-tier routing design (static name matching + package.json detection) is clean and the FilterRoute enum is well-structured. I checked out the branch, built the release binary, and tested against a real pnpm project. Here are the findings.

Local test results (14 commands)

Test	Result	Bug?
rtk pnpm run test (vitest, all pass)	📊 OUTPUT (last 5 lines): + raw vitest output	Yes — vitest filter never applied
rtk pnpm test (shorthand)	Same raw output	Yes — same bug
rtk pnpm run test (with failure)	100% raw output + ANSI codes	Yes — no filtering at all
rtk pnpm run lint (no errors)	✓ Lint: No issues found	OK
rtk pnpm run lint (with errors)	Correctly filtered	OK
rtk pnpm run build	Clean output	OK
rtk pnpm run dev	Clean output	OK
rtk pnpm list / outdated	Working (existing)	OK
rtk pnpm install	ok ✓	OK
rtk pnpm store prune	Passthrough OK	OK
rtk pnpm dlx cowsay hello	Passthrough OK	OK
rtk pnpm exec vitest --version	Runs "exec" script instead of pnpm exec	Yes — native subcommand intercepted
rtk pnpm audit	Runs "audit" script instead of pnpm audit	Yes — native subcommand intercepted
rtk pnpm run test (outside node project)	ok ✓ with exit code 1	Yes — misleading success message on failure

Comparison — rtk vitest run (existing filter) vs rtk pnpm run test (this PR):

$ rtk vitest run          → PASS (2) FAIL (0)          # ✅ compact
$ rtk pnpm run test       → 📊 OUTPUT (last 5 lines):  # ❌ raw fallback
                              ✓ src/index.test.ts (2 tests) 2ms
                              Test Files  1 passed (1)
                              ...

The main selling point of this PR (smart routing to vitest/playwright filters) doesn't work in practice.

Bugs to fix

1. Vitest/Playwright filter routing is broken

rtk pnpm run test falls through to the generic "last N lines" fallback instead of routing through VitestParser. This is likely caused by stdout/stderr concatenation (format!("{}\n{}", stdout, stderr)) — pnpm writes boilerplate to stderr, vitest writes JSON to stdout. Concatenating them before passing to VitestParser::parse() breaks JSON extraction.

Fix: Apply filter_pnpm_run_output() to stderr only, pass stdout separately to the specialized filter.

2. is_pnpm_script() intercepts native pnpm subcommands

Reproduced: added "exec": "echo exec script" and "audit": "echo audit script" to package.json. Then:

• rtk pnpm exec vitest --version → runs the "exec" script instead of pnpm exec
• rtk pnpm audit → runs the "audit" script instead of pnpm audit

Fix: Add a denylist of known pnpm native subcommands (exec, dlx, create, patch, audit, why, link, unlink, rebuild, store, setup, init, publish, pack, config, doctor) in is_pnpm_script() before checking package.json.

3. ok ✓ with exit 1 outside a node project

rtk pnpm run test from a directory without package.json shows ok ✓ but exits 1. The boilerplate filter strips pnpm's error message, leaving a misleading success indicator for a failed command.

Fix: On non-zero exit, don't apply the boilerplate filter — show the raw error output.

Other items

• catch_unwind in apply_filter(): Replace with Result-based fallback — catch_unwind is for FFI/thread isolation, not application error handling
• Double package.json read: is_pnpm_script() reads it at dispatch time, then detect_tool_from_package_json() reads it again. Consolidate into one read.
• Token savings test at 40%: Project standard is 60% minimum
• extract_test_summary(output, "npm test") hardcodes wrong label: Will always trigger Jest-style parsing regardless of actual runner
• lazy_static! inside function: Move to module level to match RTK conventions

What works well

• Lint routing works correctly (tested with real ESLint errors)
• Build/dev script routing works
• Existing pnpm commands (list, outdated, install) are not broken
• Native pnpm subcommands (store prune, dlx, add) correctly passthrough
• pub(crate) promotions are minimal and appropriate
• Exit code preservation works on the filtered paths
• 437 tests pass, build compiles

Thanks for the solid work — keep it up! Happy to re-review once the vitest routing and subcommand interception are fixed.

[denneulin]

thanks for the review @pszymkowiak
I have made some changes.

for the denylist, I have made what you asked but what do you think of inverting the logic ?
I mean, instead of "is this a native command?", check "is this a known script?" by reading package.json scripts.
If it's in scripts, it's a script. If not, pass through to pnpm directly. This is future-proof since it doesn't depend on knowing pnpm's command set.

[pszymkowiak]

Re-reviewed after your updates — all 3 critical bugs from the original review are fixed. Code is solid, 493 tests pass, manual testing OK. LGTM on the code side.

Regarding your question about inverting the logic: you're right, approach 2 is better. Checking "is this in package.json scripts?" is more future-proof than maintaining a denylist of
native pnpm commands. If pnpm adds new commands in future versions, the denylist would need updating, whereas reading package.json always works. Feel free to refactor to that approach if
you want — but it's not a blocker.

Blocker: there's a merge conflict that needs resolving before we can merge. Please rebase on master. Once the conflict is fixed, this is good to go.

[denneulin]

Thanks @pszymkowiak! Merge conflict is resolved.

I've refactored to the allowlist approach: is_pnpm_script() now reads package.json scripts instead of maintaining a denylist of native pnpm commands.

On top of that, package.json resolution now walks parent directories to mirror pnpm's own behavior.

Ready for merge when you are.

[FlorianBruniaux]

Hi @denneulin, the three-tier routing in PackageScripts is a genuinely good design, and apply_filter degrading gracefully through all levels is exactly right. Three issues:

1. The hook file isn't included in this PR's diff. The existing hook routes pnpm test and pnpm lint directly to rtk vitest run and rtk lint, bypassing the new smart routing entirely. A user typing pnpm run test in Claude Code will never hit rtk pnpm run test. Please update the hook to route pnpm run <script> to rtk pnpm run <script>.

2. In run_script, .context(format!(...)) allocates a String on every call. The project standard is .with_context(|| format!(...)) so the allocation only happens when there's actually an error.

3. Please add insta::assert_snapshot!() tests for filter_pnpm_run_output and strip_pnpm_stderr. The boilerplate stripping logic will drift silently as pnpm updates its output format without snapshot coverage.

Also: both this PR and your #226 touch yarn_cmd.rs. Please coordinate merge order to avoid a conflict.

[CLAassistant]

Thank you for your submission! We really appreciate it. Like many open source projects, we ask that you sign our Contributor License Agreement before we can accept your contribution.
_{You have signed the CLA already but the status is still pending? Let us recheck it.}

[pszymkowiak]

Hi! Two things needed before we can review:

1. Retarget to develop — this PR targets master, but all PRs should target develop. You can change the base branch in the PR settings (right sidebar).
2. Sign the CLA — if not already done, please sign at https://cla-assistant.io/rtk-ai/rtk

Thanks!

[aeppling]

Hey

We are cleaning up the codebase and improving the project structure for better onboarding. As part of this effort, PR #826 reorganizes src/ from a flat layout into subfolders.

No logic changes — only file moves and import path updates.

What you need to do

Rebase your branch on develop when receiving this comment:

git fetch origin && git rebase origin/develop

Git detects renames automatically. If you get import conflicts, update the paths:

use crate::git;        // now: use crate::cmds::git::git;
use crate::tracking;   // now: use crate::core::tracking;
use crate::config;     // now: use crate::core::config;
use crate::init;       // now: use crate::hooks::init;
use crate::gain;       // now: use crate::analytics::gain;

Need help rebasing? Tag @aeppling

[pszymkowiak]

Hi @denneulin — closing as stale + superseded by active work.

Update on what's happened since my "LGTM on the code side" comment in
March:

• pnpm is now in rtk via src/cmds/js/pnpm_cmd.rs, covering
  list, outdated, install (PR feat: add pnpm support + fix git argument parsing for modern stacks #6 ancestrally, then KuSh's
  follow-ups: feat(pnpm): Add filter argument support #270 filter args, fix(pnpm): install don't take a list of packages #1009 install package list, fix(pnpm): list command not working #1239
  list fix).
• The pnpm run <script> smart routing that this PR was adding is
  not yet in main, but it's being actively worked on in:
  • feat: infer pnpm bare scripts through run #1540 by @artile — "feat: infer pnpm bare scripts through
    run" (267 lines, focused, last push 2026-05-21)
  • feat(pnpm): hook-based script rewrite with vitest streaming #1873 by @ben-w-smith — "feat(pnpm): hook-based script
    rewrite with vitest streaming" (1568 lines, broader, last push
    2026-05-13)

Both target develop and align with the current architecture
(post-#826 layout, #1998 CAPS).

On this PR specifically, three blockers persist 84 days after the
last push:

• target = master (should be develop)
• CLA still unsigned (https://cla-assistant.io/rtk-ai/rtk)
• touches src/pnpm_cmd.rs / src/runner.rs at the pre-feat(refacto-codebase-onboarding): partie 1 - folders and technical docs #826 layout
  — would need a full rewrite

Your three-tier routing in PackageScripts was a clean design and
informed the broader direction. If you'd like to contribute to the
ongoing pnpm work, the active threads are #1540 and #1873.

Closing as superseded by #1540 / #1873.