From 5f42886e71d82678f6ec3deb6436e8b91b0b5045 Mon Sep 17 00:00:00 2001
From: guyoron1 <guyoron1@users.noreply.github.com>
Date: Sun, 27 Sep 2026 06:43:24 +0300
Subject: [PATCH 1/2] fix(lint): remove `lint` script name from lint rewrite
 rule
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

`pnpm lint` and `npm run lint` were rewritten to `rtk lint`, discarding
the package.json script's own flags, chains, and exit code. Direct
linter invocations (`eslint`, `biome`) continue to route through rtk
lint; only the bare script-name variants are dropped from the rule.

Fixes #2094

Split out of a larger commit that also removed NPM_SUBCOMMANDS from
npm_cmd.rs (fixes #2663) — that half is dropped here since #2663 was
independently closed by 56519c49 (extending the allowlist instead of
removing it), and unconditionally deleting the allowlist would also
regress the "assume script name" convenience 56519c49's approach kept.
---
 src/discover/registry.rs | 75 ++++++++++++++++++++++++++++------------
 src/discover/rules.rs    | 13 +------
 2 files changed, 54 insertions(+), 34 deletions(-)

diff --git a/src/discover/registry.rs b/src/discover/registry.rs
index 6c59b9946e..8cc8390d67 100644
--- a/src/discover/registry.rs
+++ b/src/discover/registry.rs
@@ -5482,16 +5482,12 @@ mod tests {
             "npm exec eslint",
             "npm rum biome",
             "npm rum eslint",
-            "npm rum lint",
             "npm run biome",
             "npm run eslint",
-            "npm run lint",
             "npm run-script biome",
             "npm run-script eslint",
-            "npm run-script lint",
             "npm urn biome",
             "npm urn eslint",
-            "npm urn lint",
             "npm x biome",
             "npm x eslint",
             "pnpm dlx biome",
@@ -5500,25 +5496,18 @@ mod tests {
             "pnpm exec eslint",
             "pnpm run biome",
             "pnpm run eslint",
-            "pnpm run lint",
             "pnpm run-script biome",
             "pnpm run-script eslint",
-            "pnpm run-script lint",
             "npm biome",
             "npm eslint",
-            "npm lint",
             "npx biome",
             "npx eslint",
-            "npx lint",
             "pnpm biome",
             "pnpm eslint",
-            "pnpm lint",
             "pnpx biome",
             "pnpx eslint",
-            "pnpx lint",
             "biome",
             "eslint",
-            "lint",
         ];
         for command in commands {
             assert!(
@@ -5535,6 +5524,36 @@ mod tests {
         }
     }
 
+    #[test]
+    fn test_classify_lint_scripts_not_rewritten() {
+        let script_commands = vec![
+            "lint",
+            "npm lint",
+            "npm run lint",
+            "npm rum lint",
+            "npm urn lint",
+            "npm run-script lint",
+            "npx lint",
+            "pnpm lint",
+            "pnpm run lint",
+            "pnpm run-script lint",
+            "pnpx lint",
+        ];
+        for command in script_commands {
+            assert!(
+                !matches!(
+                    classify_command(command),
+                    Classification::Supported {
+                        rtk_equivalent: "rtk lint",
+                        ..
+                    }
+                ),
+                "'{}' should NOT classify as rtk lint (it's a script, not a linter binary)",
+                command
+            );
+        }
+    }
+
     #[test]
     fn test_rewrite_lint() {
         let commands = vec![
@@ -5542,16 +5561,12 @@ mod tests {
             "npm exec eslint",
             "npm rum biome",
             "npm rum eslint",
-            "npm rum lint",
             "npm run biome",
             "npm run eslint",
-            "npm run lint",
             "npm run-script biome",
             "npm run-script eslint",
-            "npm run-script lint",
             "npm urn biome",
             "npm urn eslint",
-            "npm urn lint",
             "npm x biome",
             "npm x eslint",
             "pnpm dlx biome",
@@ -5560,25 +5575,18 @@ mod tests {
             "pnpm exec eslint",
             "pnpm run biome",
             "pnpm run eslint",
-            "pnpm run lint",
             "pnpm run-script biome",
             "pnpm run-script eslint",
-            "pnpm run-script lint",
             "npm biome",
             "npm eslint",
-            "npm lint",
             "npx biome",
             "npx eslint",
-            "npx lint",
             "pnpm biome",
             "pnpm eslint",
-            "pnpm lint",
             "pnpx biome",
             "pnpx eslint",
-            "pnpx lint",
             "biome",
             "eslint",
-            "lint",
         ];
         for command in commands {
             assert_eq!(
@@ -5590,6 +5598,29 @@ mod tests {
         }
     }
 
+    #[test]
+    fn test_rewrite_lint_scripts_not_rewritten_to_rtk_lint() {
+        let script_commands = vec![
+            "lint",
+            "npm lint",
+            "npm run lint",
+            "pnpm lint",
+            "pnpm run lint",
+            "npx lint",
+            "pnpx lint",
+        ];
+        for command in script_commands {
+            let result = rewrite_command_no_prefixes(command, &[]);
+            assert_ne!(
+                result,
+                Some("rtk lint".into()),
+                "'{}' should NOT be rewritten to rtk lint (got {:?})",
+                command,
+                result
+            );
+        }
+    }
+
     #[test]
     fn test_classify_jest() {
         let commands = vec![
diff --git a/src/discover/rules.rs b/src/discover/rules.rs
index 1f4025af60..d07a911cb1 100644
--- a/src/discover/rules.rs
+++ b/src/discover/rules.rs
@@ -206,51 +206,40 @@ pub const RULES: &[RtkRule] = &[
         ..RtkRule::DEFAULT
     },
     RtkRule {
-        pattern: r"^((p?np(m|x)|p?npm\s+(exec|run|run-script)|npm\s+(rum|urn|x)|pnpm\s+dlx)\s+)?(biome|eslint|lint)(\s|$)",
+        pattern: r"^((p?np(m|x)|p?npm\s+(exec|run|run-script)|npm\s+(rum|urn|x)|pnpm\s+dlx)\s+)?(biome|eslint)(\s|$)",
         rtk_cmd: "rtk lint",
         pipeline_safety: PipelineSafety::ProducerOnly,
         rewrite_prefixes: &[
             "biome",
             "eslint",
-            "lint",
             "npm biome",
             "npm eslint",
             "npm exec biome",
             "npm exec eslint",
-            "npm lint",
             "npm rum biome",
             "npm rum eslint",
-            "npm rum lint",
             "npm run biome",
             "npm run eslint",
-            "npm run lint",
             "npm run-script biome",
             "npm run-script eslint",
-            "npm run-script lint",
             "npm urn biome",
             "npm urn eslint",
-            "npm urn lint",
             "npm x biome",
             "npm x eslint",
             "npx biome",
             "npx eslint",
-            "npx lint",
             "pnpm biome",
             "pnpm dlx biome",
             "pnpm dlx eslint",
             "pnpm eslint",
             "pnpm exec biome",
             "pnpm exec eslint",
-            "pnpm lint",
             "pnpm run biome",
             "pnpm run eslint",
-            "pnpm run lint",
             "pnpm run-script biome",
             "pnpm run-script eslint",
-            "pnpm run-script lint",
             "pnpx biome",
             "pnpx eslint",
-            "pnpx lint",
         ],
         category: "Build",
         savings_pct: 84.0,

From 8a38ae4af5de418e3d6b0621390850171f63eae2 Mon Sep 17 00:00:00 2001
From: guyoron1 <guyoron1@users.noreply.github.com>
Date: Mon, 13 Jul 2026 15:41:24 +0300
Subject: [PATCH 2/2] fix(pnpm): add generic script routing so bare pnpm
 <script> keeps its rewrite
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Dropping the script names from the lint rule leaves `pnpm lint` matching
no rule at all, so it loses its rewrite entirely instead of just losing
the substitution. Broaden the pnpm rule from a fixed subcommand list to
any bare `pnpm <word>`, so every package.json script routes through
`rtk pnpm` and runs verbatim — real flags, real chain, real exit code.
Enumerating script names would only trade one list for another.

The first token must not start with `-`: a global flag is not a
subcommand, and `rtk pnpm --filter @app` or `rtk pnpm -x install` would
die at clap. Flag-first forms still reach the rule through
strip_pnpm_global_opts, whose fixed set is unchanged (#3275).

Specific tool rules (eslint, biome, vitest, tsc, ...) keep priority via
RegexSet last-match semantics.
---
 src/discover/registry.rs | 89 +++++++++++++++++++++++++++++++++++-----
 src/discover/rules.rs    |  9 +++-
 2 files changed, 87 insertions(+), 11 deletions(-)

diff --git a/src/discover/registry.rs b/src/discover/registry.rs
index 8cc8390d67..61de180268 100644
--- a/src/discover/registry.rs
+++ b/src/discover/registry.rs
@@ -3108,12 +3108,18 @@ mod tests {
         );
     }
 
-    // Bare `pnpm build` is still NOT rewritten: it would only hit the passthrough
-    // (no output parser), so rewriting it would add false-positive surface for zero
-    // savings. Stripping global opts must not change this.
+    // Bare `pnpm <script>` now routes to `rtk pnpm`, which runs the script
+    // verbatim through the passthrough. #3275 left it unrouted because the
+    // passthrough parses nothing, but dropping the script names from the lint
+    // rule (this change) means `pnpm lint` would otherwise match no rule at all
+    // and lose its rewrite. Routing the whole bare form keeps the script's real
+    // flags, chain and exit code, and the output filter is the follow-up.
     #[test]
-    fn test_rewrite_pnpm_bare_build_none() {
-        assert_eq!(rewrite_command_no_prefixes("pnpm build", &[]), None);
+    fn test_rewrite_pnpm_bare_build_routes_to_pnpm() {
+        assert_eq!(
+            rewrite_command_no_prefixes("pnpm build", &[]),
+            Some("rtk pnpm build".into())
+        );
     }
 
     // False-positive guards.
@@ -3135,10 +3141,16 @@ mod tests {
     }
 
     #[test]
-    fn test_rewrite_pnpm_recursive_lint_safe_noop() {
-        // `pnpm lint` classifies as Supported, but the ORIGINAL `pnpm -r lint`
-        // matches no lint rewrite-prefix → safe no-op (never a malformed rewrite).
-        assert_eq!(rewrite_command_no_prefixes("pnpm -r lint", &[]), None);
+    fn test_rewrite_pnpm_recursive_lint_routes_to_pnpm() {
+        // `pnpm -r lint` used to be a safe no-op: it classified through the lint
+        // rule, whose rewrite prefixes never matched the flag-first spelling.
+        // With `lint` off that rule it classifies as `rtk pnpm` (via the global
+        // -opt strip) and the `pnpm` rewrite prefix does match, so `-r` is
+        // forwarded as the global flag `rtk pnpm` already accepts.
+        assert_eq!(
+            rewrite_command_no_prefixes("pnpm -r lint", &[]),
+            Some("rtk pnpm -r lint".into())
+        );
     }
 
     #[test]
@@ -3148,8 +3160,10 @@ mod tests {
         // original flag-first text and never fires, so a Supported verdict would
         // advertise savings `rtk discover`/`rtk session` can never deliver. These
         // must classify exactly as on develop: Unsupported(pnpm).
+        // (`pnpm -r lint` left this list when `lint` left the lint rule — it now
+        // routes to `rtk pnpm`, and its rewrite does fire. See
+        // `test_rewrite_pnpm_recursive_lint_routes_to_pnpm`.)
         for cmd in [
-            "pnpm -r lint",
             "pnpm -r exec eslint .",
             "pnpm --filter @app exec vitest run",
             "pnpm -F web exec playwright test",
@@ -5621,6 +5635,61 @@ mod tests {
         }
     }
 
+    #[test]
+    fn test_pnpm_scripts_route_through_rtk_pnpm() {
+        let script_commands = vec![
+            ("pnpm lint", "rtk pnpm lint"),
+            ("pnpm build", "rtk pnpm build"),
+            ("pnpm dev", "rtk pnpm dev"),
+            ("pnpm test", "rtk pnpm test"),
+            ("pnpm typecheck", "rtk pnpm typecheck"),
+            ("pnpm run lint", "rtk pnpm run lint"),
+            ("pnpm run build", "rtk pnpm run build"),
+        ];
+        for (command, expected) in script_commands {
+            assert_eq!(
+                classify_command(command),
+                Classification::Supported {
+                    rtk_equivalent: "rtk pnpm",
+                    category: "PackageManager",
+                    estimated_savings_pct: 80.0,
+                    status: RtkStatus::Existing,
+                },
+                "'{}' should classify as rtk pnpm",
+                command
+            );
+            assert_eq!(
+                rewrite_command_no_prefixes(command, &[]),
+                Some(expected.into()),
+                "'{}' should rewrite to '{}'",
+                command,
+                expected
+            );
+        }
+    }
+
+    #[test]
+    fn test_pnpm_specific_tools_still_override_generic() {
+        let specific_commands = vec![
+            ("pnpm eslint", "rtk lint"),
+            ("pnpm biome", "rtk lint"),
+            ("pnpm vitest", "rtk vitest"),
+            ("pnpm jest", "rtk jest"),
+            ("pnpm tsc", "rtk tsc"),
+            ("pnpm prettier", "rtk prettier"),
+            ("pnpm playwright", "rtk playwright"),
+        ];
+        for (command, expected_rtk) in specific_commands {
+            assert_eq!(
+                rewrite_command_no_prefixes(command, &[]),
+                Some(expected_rtk.into()),
+                "'{}' should route to specific '{}', not generic rtk pnpm",
+                command,
+                expected_rtk
+            );
+        }
+    }
+
     #[test]
     fn test_classify_jest() {
         let commands = vec![
diff --git a/src/discover/rules.rs b/src/discover/rules.rs
index d07a911cb1..2ecd1604ad 100644
--- a/src/discover/rules.rs
+++ b/src/discover/rules.rs
@@ -101,7 +101,14 @@ pub const RULES: &[RtkRule] = &[
         subcmd_status: &[("fmt", RtkStatus::Passthrough)],
     },
     RtkRule {
-        pattern: r"^pnpm\s+(exec|i|install|list|ls|outdated|run|run-script)",
+        // Any bare `pnpm <word>` routes here, so a package.json script keeps its
+        // real flags, chain and exit code instead of being re-spelled as a tool
+        // invocation. Enumerating script names would just be another list to
+        // chase. The first token must not start with `-`: a global flag is not a
+        // subcommand, and `rtk pnpm --filter @app` / `rtk pnpm -x install` would
+        // die at clap. Flag-first forms keep reaching this rule through
+        // `strip_pnpm_global_opts` (#3275), which only strips the fixed set.
+        pattern: r"^pnpm\s+[^-\s]\S*",
         rtk_cmd: "rtk pnpm",
         rewrite_prefixes: &["pnpm"],
         category: "PackageManager",