@herbertgao/pi-extensions 2026.9.0 → 2026.9.2

package/node_modules/pi-lens/dist/clients/project-diagnostics/fresh-fetch.js

@@ -415,9 +415,10 @@ export async function fetchFreshProjectDiagnostics(cacheManager, cwd, clients, s
         // Deliberately never calls `writeCache`: there is nothing fresher to write
         // back, only what turn_end already produced.
         //
-        // No double-count / honesty gap (#533): `consumeTestFindings`
-        // (`runtime-context.ts`) reads-and-clears this SAME cache key once, to
-        // inject a one-shot "fix before continuing" message into the NEXT turn.
+        // No double-count / honesty gap (#533): explicit `pilens_turn_end`
+        // delivery may call `consumeTestFindings` (`runtime-context.ts`) to
+        // read-and-clear this SAME cache key once. Automatic Pi delivery uses a
+        // non-context custom entry and never consumes this pull-diagnostics cache.
         // This task only ever reads (never clears) it, so it can't race that
         // consumption into re-delivering a message twice — at most it surfaces
         // the same underlying failures a second time, through a different

package/node_modules/pi-lens/dist/clients/project-diagnostics/runner-adapters/jscpd.js

@@ -8,7 +8,7 @@ function resolveClonePath(cwd, file) {
  * BOTH ends so the duplication surfaces on whichever file the agent is looking
  * at, each one naming the other end.
  */
-export function jscpdCloneToProjectDiagnostics(cwd, clone) {
+function jscpdCloneToProjectDiagnostics(cwd, clone) {
     const a = resolveClonePath(cwd, clone.fileA);
     const b = resolveClonePath(cwd, clone.fileB);
     const make = (filePath, line, otherFile, otherLine) => ({

package/node_modules/pi-lens/dist/clients/project-diagnostics/runner-adapters/knip.js

@@ -27,7 +27,7 @@ function knipIssueMessage(issue) {
     }
     return `${issue.type}: ${issue.name}`;
 }
-export function knipIssueToProjectDiagnostic(cwd, issue) {
+function knipIssueToProjectDiagnostic(cwd, issue) {
     const blocking = issue.type === "unlisted" || issue.type === "bin";
     return {
         filePath: knipIssueFile(cwd, issue),

package/node_modules/pi-lens/dist/clients/project-diagnostics/runner-adapters/madge.js

@@ -12,7 +12,7 @@ function cycleMembers(dep) {
  * single-point knip finding. Emit a diagnostic on EACH file in the cycle so it
  * surfaces wherever the agent is looking, each one rendering the whole cycle.
  */
-export function circularDepToProjectDiagnostics(cwd, dep) {
+function circularDepToProjectDiagnostics(cwd, dep) {
     const members = cycleMembers(dep);
     const rendered = `${members.map((f) => path.basename(f)).join(" → ")} → ${path.basename(members[0] ?? "")}`;
     return members.map((file) => ({

package/node_modules/pi-lens/dist/clients/project-diagnostics/runner-adapters/opengrep.js

@@ -15,7 +15,7 @@ function severityFor(raw) {
             return { severity: "warning", blocking: false };
     }
 }
-export function opengrepFindingToProjectDiagnostic(cwd, finding) {
+function opengrepFindingToProjectDiagnostic(cwd, finding) {
     const { severity, blocking } = severityFor(finding.severity);
     const cweSuffix = finding.cwe?.length ? ` (${finding.cwe[0]})` : "";
     return {

package/node_modules/pi-lens/dist/clients/project-diagnostics/runner-adapters/runner-findings.js

@@ -1,3 +1,4 @@
+import { isRunnerErrorResult, } from "../../test-runner-client.js";
 import * as fs from "node:fs";
 import * as path from "node:path";
 import { advisoryPathKey, validateAdvisoryProvenance, } from "../../advisory-provenance.js";
@@ -42,7 +43,7 @@ function parseLocation(location) {
  * caller deserves the same "this may already be superseded" honesty the
  * per-edit path already gives.
  */
-export function testResultToProjectDiagnostics(result, stale = false) {
+function testResultToProjectDiagnostics(result, stale = false) {
     if (result.failed === 0 && !result.error)
         return [];
     const stalePrefix = stale ? "[stale — from a prior turn] " : "";
@@ -59,6 +60,31 @@ export function testResultToProjectDiagnostics(result, stale = false) {
             source: "project-scan",
         }));
     }
+    // #2532: a RUNNER error (timeout, missing provider/binary, a config
+    // failure — the suite itself never produced a verdict) is not a finding
+    // the agent introduced, exactly like the turn-end delivery framing
+    // (#2522) already treats it. `isRunnerErrorResult` is the single seam
+    // both surfaces read so the identical `TestResult` cannot classify
+    // differently here than it does in the turn-end message.
+    if (isRunnerErrorResult(result)) {
+        return [
+            {
+                filePath: result.file,
+                severity: "info",
+                semantic: "none",
+                tool: "test-runner",
+                runner: result.runner,
+                rule: `test:${result.runner}`,
+                message: `${stalePrefix}Test run error: ${result.error}`,
+                source: "project-scan",
+            },
+        ];
+    }
+    // #2532 review S3: a counted failure stays blocking even when `error` is
+    // ALSO set (pytest exit 2 "Interrupted" after `2 failed, 1 passed` — see
+    // `isRunnerErrorResult`'s doc). The pre-fix message mentioned `error`
+    // here via a ternary this PR's first version dropped; restored so the
+    // interruption is not silently lost from a still-blocking finding.
     return [
         {
             filePath: result.file,
@@ -67,9 +93,7 @@ export function testResultToProjectDiagnostics(result, stale = false) {
             tool: "test-runner",
             runner: result.runner,
             rule: `test:${result.runner}`,
-            message: `${stalePrefix}${result.error
-                ? `Test run error: ${result.error}`
-                : `${result.failed} test(s) failed`}`,
+            message: `${stalePrefix}${result.failed} test(s) failed${result.error ? ` (runner also reported: ${result.error})` : ""}`,
             source: "project-scan",
         },
     ];

package/node_modules/pi-lens/dist/clients/project-diagnostics/scanner.js

@@ -33,27 +33,30 @@ const FACT_RULE_EXTENSIONS = new Set([
     ".mjs",
     ".cjs",
 ]);
-// Which languages the scan runs tree-sitter rules for: every language that has
-// (a loadable grammar) AND (a non-disabled rules/tree-sitter-queries/<lang>/ dir).
+// Which languages the scan runs tree-sitter rules for. Identical to the shared
+// per-edit resolver (EXT_TO_LANG), which since #2424 is itself a projection of
+// the canonical language registry — so the scan and the per-edit path cannot
+// disagree about `.tsx`→tsx / `.jsx`→javascript / the c-vs-cpp header split.
+// (`.tsx` resolves to the tsx grammar, not typescript: the typescript grammar
+// ERRORs on JSX; typescript RULES still apply because `queriesForLanguage(...)`
+// below merges the typescript rule set onto tsx.)
 //
-// The base is the shared per-edit resolver (EXT_TO_LANG — the single
-// ext→grammar-id authority), so c/cpp/csharp/php/css and the .tsx→tsx /
-// .jsx→javascript nuances can never drift from the per-edit path. `.tsx` resolves
-// to the tsx grammar (not typescript: the typescript grammar ERRORs on JSX); // spellchecker:disable-line
-// typescript RULES still apply because `queriesForLanguage(...)` below merges the
-// typescript rule set onto tsx.
+// java + kotlin used to be layered on here because EXT_TO_LANG lacked them:
+// they have loadable grammars and rule dirs (java: 24 rules, kotlin: 1) but no
+// per-edit runner `appliesTo` entry, so only this broad project scan runs them.
+// The registry now owns their extensions, so the spread is gone and this is a
+// plain alias. scanner.test.ts asserts this map covers every non-disabled rule
+// dir whose grammar is loadable, so adding a language dir fails a test until
+// its extension is registered in the registry.
 //
-// java + kotlin are layered on here: they have loadable grammars and rule dirs
-// (java: 24 rules, kotlin: 1) but no per-edit runner `appliesTo` entry, so only
-// this broad project scan runs them. scanner.test.ts asserts this map covers
-// every non-disabled rule dir whose grammar is loadable, so adding a language dir
-// fails a test until its extension is registered here (or in EXT_TO_LANG).
-export const TREE_SITTER_EXT_TO_LANG = {
-    ...EXT_TO_LANG,
-    ".java": "java",
-    ".kt": "kotlin",
-    ".kts": "kotlin",
-};
+// This map is the scan's language RESOLVER, not its eligibility gate: it now
+// answers for grammars with no rule dir too (bash/dart/elixir/lua/ocaml/swift/
+// zig), and the pass gates each file on `hasTreeSitterRules` so a grammar
+// without rules costs no read (#2424 review, F2).
+// `Readonly` because the projection is `Object.freeze`d at the source (#2424
+// review, S4) — the mutable `Record` type is what let the pre-#2424 spread
+// layer java/kotlin on by hand in the first place.
+export const TREE_SITTER_EXT_TO_LANG = EXT_TO_LANG;
 function normalizeSeverity(severity) {
     if (severity === "error" || severity === "warning" || severity === "hint") {
         return severity;
@@ -116,6 +119,29 @@ async function scanFileMajorRules(cwd, files, signal) {
     // file out, so the caller can report a truncated filesScanned honestly.
     let filesScanned = 0;
     let wasmAborted = isTreeSitterWasmAborted();
+    /**
+     * Does this project actually have ENABLED tree-sitter rules for `langId`?
+     *
+     * The gate below used to read "does the extension have a grammar", which was
+     * the same question only because the ext -> grammar map hand-listed exactly
+     * the twelve grammars that also ship a `rules/tree-sitter-queries/<lang>/`
+     * dir. #2424 projected that map from the registry's full grammar column, so
+     * bash/dart/elixir/lua/ocaml/swift/zig arrived WITHOUT rules and every such
+     * file started being read, walked and counted for a rule set that is empty
+     * (#2424 review, F2). Memoized per language: `queriesForLanguage` rebuilds
+     * and filters its array on every call, and the scan asks once per file.
+     */
+    const ruleCoverage = new Map();
+    const hasTreeSitterRules = (langId) => {
+        if (!queryMap || !client)
+            return false;
+        const memo = ruleCoverage.get(langId);
+        if (memo !== undefined)
+            return memo;
+        const covered = queriesForLanguage(queryMap, langId).length > 0;
+        ruleCoverage.set(langId, covered);
+        return covered;
+    };
     const scanTreeSitterFile = async (filePath, langId, content) => {
         if (!queryMap || !langId || !client || content === null)
             return;
@@ -166,6 +192,8 @@ async function scanFileMajorRules(cwd, files, signal) {
             const fileDiagnostics = evaluateAstGrepRules(filePath, rootNode, cwd, detectFileKind(filePath), {
                 maxMatchesPerRule: AST_GREP_SCAN_MAX_MATCHES_PER_RULE,
                 maxTotalDiagnostics: AST_GREP_SCAN_MAX_DIAGNOSTICS_PER_FILE,
+                content,
+                sgModule,
             });
             for (const diagnostic of fileDiagnostics) {
                 astGrep.push(fromDispatchDiagnostic(diagnostic, "ast-grep-napi"));
@@ -190,7 +218,10 @@ async function scanFileMajorRules(cwd, files, signal) {
             if (isTestFile(filePath))
                 continue;
             const ext = path.extname(filePath);
-            const langId = TREE_SITTER_EXT_TO_LANG[ext];
+            // A grammar is not a consumer: only a language this project has
+            // ENABLED rules for can turn this file's bytes into a finding.
+            const grammarId = TREE_SITTER_EXT_TO_LANG[ext];
+            const langId = grammarId && hasTreeSitterRules(grammarId) ? grammarId : undefined;
             const factEligible = FACT_RULE_EXTENSIONS.has(ext);
             let astGrepLang;
             if (sgModule && astGrepCanHandle(filePath)) {