pi-lens 3.8.72 → 3.8.74

package/dist/clients/dispatch/facts/tree-sitter-facts.js

@@ -2,15 +2,14 @@
  * Fact-provider-specific tree-sitter helper (#402).
  *
  * The generic node-walk utilities (`walk`, `childrenOfType`, `firstChildOfType`,
- * `parseTreeSitterRoot`, `TsNode`) live in `clients/tree-sitter-shared.ts` so both
+ * `withTreeSitterRoot`, `TsNode`) live in `clients/tree-sitter-shared.ts` so both
  * the fact extractors and the complexity client share them. This module re-exports
  * them for the extractors and adds the FactProvider-specific `extractFactsFromTree`
  * shell.
  */
-import { childrenOfType, firstChildOfType, parseTreeSitterRoot, walk, } from "../../tree-sitter-shared.js";
+import { childrenOfType, firstChildOfType, withTreeSitterRoot, walk, } from "../../tree-sitter-shared.js";
 export { childrenOfType, firstChildOfType, walk, };
-/** Parse `content` for `filePath` into a root node (or null). Alias of the shared helper. */
-export const parseFactTree = parseTreeSitterRoot;
+export const withFactTree = withTreeSitterRoot;
 /**
  * Provider shell for tree-sitter-backed fact extractors: read `file.content`,
  * parse via the shared client, and hand the root node to `extract`. On empty
@@ -27,8 +26,6 @@ export async function extractFactsFromTree(ctx, store, defaults, extract) {
     const content = store.getFileFact(ctx.filePath, "file.content");
     if (!content)
         return writeAll(defaults);
-    const root = await parseFactTree(ctx.filePath, content);
-    if (!root)
-        return writeAll(defaults);
-    writeAll(extract(root, content));
+    const parsed = await withFactTree(ctx.filePath, content, (root) => extract(root, content));
+    writeAll(parsed.parsed ? parsed.value : defaults);
 }

package/dist/clients/dispatch/facts/try-catch-facts.js

@@ -1,5 +1,16 @@
 import { extractFactsFromTree, firstChildOfType, walk, } from "./tree-sitter-facts.js";
 // --- Helpers ---
+/** Does `node`'s subtree contain an `assignment_expression` (`x = ...`, `x += ...`, …)? */
+function hasAssignmentExpression(node) {
+    if (!node)
+        return false;
+    let found = false;
+    walk(node, (n) => {
+        if (n.type === "assignment_expression")
+            found = true;
+    });
+    return found;
+}
 function isOnlyWhitespaceOrComments(text) {
     let stripped = text.replace(/\/\*[\s\S]*?\*\//g, "");
     stripped = stripped.replace(/\/\/[^\n]*/g, "");
@@ -74,6 +85,7 @@ export const tryCatchFactProvider = {
                 const catchReturnsDefault = DEFAULT_VALUE_PATTERN.test(bodyText);
                 const catchReturnsStructuredError = STRUCTURED_ERROR_PATTERN.test(bodyText);
                 const isDocumentedLocalFallback = EXPLAINING_COMMENT_PATTERN.test(bodyText);
+                const catchHasFallbackAssignment = hasAssignmentExpression(catchBody);
                 const catchLogsOnly = hasLogging &&
                     !hasRethrow &&
                     !catchReturnsDefault &&
@@ -95,6 +107,7 @@ export const tryCatchFactProvider = {
                     catchReturnsDefault,
                     catchReturnsStructuredError,
                     isDocumentedLocalFallback,
+                    catchHasFallbackAssignment,
                     tryResolvesLocalValues,
                     isFilesystemExistenceProbe,
                     boundaryCategory,

package/dist/clients/dispatch/integration.js

@@ -25,8 +25,8 @@ import { getServersForFileWithConfig } from "../lsp/config.js";
 import { getLSPService } from "../lsp/index.js";
 import { isExternalOrVendorFile, normalizeMapKey } from "../path-utils.js";
 import { getProjectIgnoreMatcher } from "../file-utils.js";
-import { clearReviewGraphWorkspaceCache, getLastGraphBuildInfo, } from "../review-graph/builder.js";
-import { buildReverseDependencyIndexFromGraph, getAffectedFilesFromIndex, writeReverseDependencyIndexToSnapshot, } from "../reverse-deps.js";
+import { clearReviewGraphWorkspaceCache, getGraphImportChanges, getLastGraphBuildInfo, } from "../review-graph/builder.js";
+import { buildReverseDependencyIndexFromGraph, getAffectedFilesFromIndex, patchReverseDependencyIndex, writeReverseDependencyIndexToSnapshot, } from "../reverse-deps.js";
 import { buildOrUpdateGraph, computeImpactCascade, computeTransitiveImpact, formatImpactCascade, } from "../review-graph/service.js";
 import { clearModuleGraphCache } from "../review-graph/workspace-modules.js";
 import { RUNTIME_CONFIG } from "../runtime-config.js";
@@ -498,17 +498,15 @@ export async function computeCascadeForFile(filePath, cwd, options = {}) {
     // `wordIndex`/`fileContent` doc comments for the cold/no-forward-index
     // no-op rules.
     //
-    // Deliberately keyed by `path.resolve(filePath)`, NOT `normalizedFile`
-    // (which is `normalizeMapKey`'d — realpath-canonicalized + lowercased on
-    // Windows). The word index's OWN keys come from `collectWordIndexDocs` →
-    // `collectSourceFilesAsync`'s file walk, which yields plain
-    // `path.resolve()`-joined paths (native separators, on-disk casing as
-    // reported by the walk, no realpath call). Keying this update with the
-    // cascade's normalized key would silently create a SECOND, orphaned entry
-    // next to the walker's original-cased entry instead of replacing it —
-    // exactly the kind of divergence the equivalence-property test is meant to
-    // catch, so the key shape here must match the build path's, not the
-    // cascade/graph's own (different) normalization scheme.
+    // Keyed by `path.resolve(filePath)` (native separators, tool-input casing).
+    // Since #1025 the word index's path maps are `PathKeyedMap`s that fold every
+    // key through `wordIndexKey` (`normalizeEphemeralMapKey` — slash-fold +
+    // win32-lowercase) INTERNALLY, so this per-edit key and the build path's own
+    // walk-derived key (`collectWordIndexDocs` → `collectSourceFilesAsync`)
+    // collapse to the same entry regardless of on-disk-vs-input casing/separator.
+    // The old hazard — this update silently orphaning a SECOND entry next to the
+    // walker's original-cased one — is now structurally impossible at the map
+    // layer, so this seam no longer has to hand-match the build path's key shape.
     updateWordIndexForCascade({
         wordIndex,
         filePath: nodePath.resolve(filePath),
@@ -544,15 +542,32 @@ export async function computeCascadeForFile(filePath, cwd, options = {}) {
         const graphBuildInfo = getLastGraphBuildInfo();
         const workspaceKey = normalizeMapKey(cwd);
         const cachedReverseDeps = reverseDepsIndexCache.get(workspaceKey);
+        const importDelta = getGraphImportChanges(graph);
+        // A one-step delta is only usable against an index cached at exactly the
+        // delta's predecessor generation. Builds minted elsewhere (mcp analyze,
+        // lens-map, session warm) advance generations whose import changes this
+        // delta does not cover — reusing/patching across that gap stamps a stale
+        // index as current, and generation equality then hides the loss forever
+        // (#939 review finding 1).
+        const deltaContiguous = importDelta !== undefined &&
+            importDelta.fromGeneration !== undefined &&
+            cachedReverseDeps !== undefined &&
+            cachedReverseDeps.generation === importDelta.fromGeneration;
+        const importChanges = deltaContiguous ? importDelta.changes : undefined;
+        const importsChanged = importChanges?.some((change) => change.existedBefore !== change.existsAfter ||
+            change.priorTargets.length !== change.newTargets.length ||
+            change.priorTargets.some((target, index) => target !== change.newTargets[index]));
         const canReuse = reverseDepsReuseEnabled() &&
             cachedReverseDeps !== undefined &&
-            graph.buildGeneration !== undefined &&
-            cachedReverseDeps.generation === graph.buildGeneration;
+            ((graph.buildGeneration !== undefined &&
+                cachedReverseDeps.generation === graph.buildGeneration) ||
+                (importChanges !== undefined && !importsChanged));
         let reverseDepsIndex;
         let reverseDepsSaved;
         if (canReuse && cachedReverseDeps) {
             reverseDepsIndex = cachedReverseDeps.index;
             reverseDepsSaved = cachedReverseDeps.savedToSnapshot;
+            cachedReverseDeps.generation = graph.buildGeneration;
             logCascade({
                 phase: "reverse_deps_cache",
                 filePath,
@@ -565,6 +580,29 @@ export async function computeCascadeForFile(filePath, cwd, options = {}) {
                 },
             });
         }
+        else if (cachedReverseDeps && importChanges && importsChanged) {
+            reverseDepsIndex = patchReverseDependencyIndex(cachedReverseDeps.index, importChanges);
+            reverseDepsSaved = writeReverseDependencyIndexToSnapshot({
+                cwd,
+                index: reverseDepsIndex,
+                dbg,
+            });
+            reverseDepsIndexCache.set(workspaceKey, {
+                index: reverseDepsIndex,
+                savedToSnapshot: reverseDepsSaved,
+                generation: graph.buildGeneration,
+            });
+            logCascade({
+                phase: "reverse_deps_cache",
+                filePath,
+                durationMs: Date.now() - graphStart,
+                metadata: {
+                    action: "patched_import_changes",
+                    changedFileCount: importChanges.length,
+                    savedToSnapshot: reverseDepsSaved,
+                },
+            });
+        }
         else {
             reverseDepsIndex = buildReverseDependencyIndexFromGraph({
                 cwd,
@@ -614,6 +652,29 @@ export async function computeCascadeForFile(filePath, cwd, options = {}) {
             },
         });
         impact = computeImpactCascade(graph, normalizedFile, cwd);
+        // #1023: buildOrUpdateGraph returns an EMPTY graph (seeded only with the
+        // changed file's own symbols) when the repo is over
+        // PI_LENS_REVIEW_GRAPH_MAX_FILES (`too_many_files`) or the root is unsafe
+        // (`unsafe_root`) — both stamp mode "skipped" on the already-read
+        // graphBuildInfo. Computing impact against that empty graph yields zero
+        // neighbors for EVERY edit, indistinguishable from a genuine clean leaf.
+        // Thread the ALREADY-KNOWN degraded state (never re-derived) onto the
+        // result so the turn-end seam surfaces an honest advisory instead of a
+        // silent all-clear (#533). Keyed strictly off the degraded build mode —
+        // NOT off `neighborFiles.length === 0` — so a healthy build with a real
+        // empty dependent set stays silent (no crying wolf).
+        if (graphBuildInfo.mode === "skipped" && !impact.indeterminate) {
+            impact.indeterminate = {
+                reason: "graph_degraded",
+                detail: graphBuildInfo.skipReason === "too_many_files"
+                    ? `review graph disabled — ${graphBuildInfo.sourceFileCount ?? "?"} files over the ${graphBuildInfo.maxFileCount ?? "?"} cap`
+                    : graphBuildInfo.skipReason === "unsafe_root"
+                        ? "review graph skipped — workspace root is at/above home dir"
+                        : `review graph unavailable (${graphBuildInfo.skipReason ?? "skipped"})`,
+                sourceFileCount: graphBuildInfo.sourceFileCount,
+                maxFileCount: graphBuildInfo.maxFileCount,
+            };
+        }
         const reverseDepNeighbors = getAffectedFilesFromIndex(reverseDepsIndex, normalizedFile, 1, MAX_FILES * 2);
         logCascade({
             phase: "reverse_deps_cache",
@@ -1117,6 +1178,20 @@ export async function computeCascadeForFile(filePath, cwd, options = {}) {
     cascadeSessionStats.diagnosticsSurfaced += diagCount;
     cascadeSessionStats.coldSnapshotTouches += coldSnapshotPaths.length;
     if (!formatted) {
+        // #1023: an indeterminate compute (degraded/cold/missing-node graph) must
+        // NOT collapse into "no_neighbors" — that is the exact silent all-clear the
+        // bug is about. Distinguish it by the marker threaded onto `impact`, never
+        // by `visibleNeighbors.length === 0` alone (a healthy leaf is also empty).
+        if (impact.indeterminate) {
+            return {
+                filePath,
+                result: undefined,
+                neighborCount: visibleNeighbors.length,
+                diagnosticCount: diagCount,
+                skipReason: "indeterminate",
+                indeterminate: impact.indeterminate,
+            };
+        }
         const skipReason = visibleNeighbors.length === 0 ? "no_neighbors" : "clean";
         return {
             filePath,
@@ -1132,6 +1207,10 @@ export async function computeCascadeForFile(filePath, cwd, options = {}) {
         result: { filePath, impact, neighbors: visibleNeighbors, formatted },
         neighborCount: visibleNeighbors.length,
         diagnosticCount: diagCount,
+        // #1023: even when some fallback neighbors surfaced, a degraded graph means
+        // the dependent set is INCOMPLETE — carry the marker so the turn-end seam
+        // still notes downstream impact was under-computed this turn.
+        ...(impact.indeterminate && { indeterminate: impact.indeterminate }),
     };
 }
 function diagnosticDeltaKey(diagnostic) {

package/dist/clients/dispatch/rules/async-noise.js

@@ -18,6 +18,7 @@ export const asyncNoiseRule = {
                 !fn.hasAwait &&
                 !fn.hasReturnAwaitCall &&
                 !fn.isPassThroughWrapper &&
+                !fn.hasExplicitPromiseReturnType &&
                 !ASYNC_INTERFACE_PATTERN.test(fn.name) &&
                 // Skip single-statement functions — likely interface stubs or thin wrappers
                 fn.statementCount > 1) {

package/dist/clients/dispatch/rules/unsafe-boundary.js

@@ -53,6 +53,13 @@ function hasCatchCoverage(fn, catches) {
         // Catch body contains a return statement → structured error result
         if (/\breturn\b/.test(c.bodyText))
             return true;
+        // Catch body falls back by mutating existing state (e.g. extending a
+        // validity window on refresh failure) instead of rethrowing/logging/
+        // returning. That's still a real handler — the exception doesn't
+        // escape uncaught — just expressed via assignment rather than one of
+        // the three shapes above (#969).
+        if (c.catchHasFallbackAssignment)
+            return true;
         return false;
     });
 }

package/dist/clients/dispatch/runners/ast-grep-napi.js

@@ -9,10 +9,14 @@
 import * as fs from "node:fs";
 import * as path from "node:path";
 import { loadAstGrepNapi, } from "../../deps/ast-grep-napi.js";
+import { minimatch } from "../../deps/minimatch.js";
 import { getAstGrepRuleSources, } from "../../sgconfig.js";
+import { logLatency } from "../../latency-logger.js";
 import { hasEslintConfig } from "../../tool-policy.js";
 import { enabledAuxiliaryLspServerIds } from "../auxiliary-lsp.js";
 import { classifyDefect } from "../diagnostic-taxonomy.js";
+import { isAuxiliaryLspAlive } from "../../lsp/index.js";
+import { resolveAstGrepNativeExe } from "../../lsp/wait-policy/index.js";
 import { PRIORITY } from "../priorities.js";
 import { calculateRuleComplexity, isOverlyBroadPattern, isStructuredRule, loadYamlRules, loadYamlRulesFresh, MAX_BLOCKING_RULE_COMPLEXITY, } from "./yaml-rule-parser.js";
 // Lazy load the napi package
@@ -117,28 +121,48 @@ function explicitRuleFixSuggestion(rule) {
 function normalizeRuleId(ruleId) {
     return ruleId.replace(/-js$/, "");
 }
+/**
+ * `filePath` relative to `root`, forward-slashed, for matching a rule's
+ * `ignores` globs (#965). Falls back to the absolute (slash-normalized) path
+ * when `filePath` isn't under `root` (e.g. an out-of-tree temp file), so a
+ * glob like `scripts/**` simply never matches rather than throwing.
+ */
+function relativeForIgnoreGlob(filePath, root) {
+    const rel = path.relative(root, filePath);
+    return (rel.startsWith("..") ? filePath : rel).split(path.sep).join("/");
+}
+function matchesRuleIgnores(filePath, root, patterns) {
+    if (!patterns || patterns.length === 0)
+        return false;
+    const rel = relativeForIgnoreGlob(filePath, root);
+    return patterns.some((pattern) => minimatch(rel, pattern, { dot: true }));
+}
 export function canHandle(filePath) {
     return SUPPORTED_EXTS.includes(path.extname(filePath).toLowerCase());
 }
 /**
  * The TypeScript grammar is a syntactic superset of JavaScript, so a
  * `JavaScript`-tagged rule using generic node kinds (`variable_declarator`,
- * `assignment_expression`, …) still matches against a parsed `.ts`/`.tsx`
- * root — and vice versa isn't an issue since JS files never parse
+ * `assignment_expression`, …) still matches against a parsed `.ts` root
+ * — and vice versa isn't an issue since JS files never parse
  * TS-only syntax, but a `TypeScript`-tagged rule with a plain-JS-compatible
  * body would equally double-fire alongside a `JavaScript` twin on a `.ts`
  * file. Without this, `language:` reads as a real filter but isn't one for
  * ts↔js pairs, so twin rules sharing a base name (e.g. `hardcoded-url` /
  * `hardcoded-url-js`) both match the same construct in the SAME runner
- * invocation (#657). Returns undefined for extensions this scoping doesn't
- * apply to (css/html), where no filtering is added.
+ * invocation (#657). TSX is deliberately its own grammar here: the primary
+ * ast-grep CLI/LSP also treats `tsx` as distinct from `typescript`, so a
+ * language-tagged rule only runs on the exact grammar it names. Returns
+ * undefined for extensions this scoping doesn't apply to (css/html), where
+ * no filtering is added.
  */
 export function ruleLanguageForFile(filePath) {
     const ext = path.extname(filePath).toLowerCase();
     switch (ext) {
         case ".ts":
-        case ".tsx":
             return "typescript";
+        case ".tsx":
+            return "tsx";
         case ".js":
         case ".jsx":
             return "javascript";
@@ -213,13 +237,36 @@ export function evaluateAstGrepRules(filePath, rootNode, cwd, kind, options = {}
     const maxTotalDiagnostics = options.maxTotalDiagnostics ?? MAX_TOTAL_DIAGNOSTICS;
     const blockingOnly = options.blockingOnly === true;
     const log = options.log;
+    const unsupportedLanguageLog = options.unsupportedLanguageLog ?? new Set();
     const diagnostics = [];
     const seenRuleIds = new Set();
     const suppressLinterOverlap = kind === "jsts" && hasEslintConfig(cwd);
     const fileLang = ruleLanguageForFile(filePath);
+    // Unsupported-language skips are expected in bulk (every non-jsts rule in the
+    // catalog, e.g. ~30 Python rules) — aggregate them into ONE latency-log entry
+    // per evaluation instead of per-rule terminal lines (#282 follow-up).
+    const newlyUnsupported = new Map();
+    const flushUnsupportedRuleSkips = () => {
+        if (newlyUnsupported.size === 0)
+            return;
+        logLatency({
+            type: "phase",
+            phase: "astgrep_napi_unsupported_rules_skipped",
+            filePath,
+            durationMs: 0,
+            metadata: {
+                skippedByLanguage: Object.fromEntries(Array.from(newlyUnsupported.entries(), ([language, ruleIds]) => [
+                    language,
+                    { count: ruleIds.length, ruleIds },
+                ])),
+            },
+        });
+        newlyUnsupported.clear();
+    };
     // Shared with the raw sgconfig materializer so both surfaces walk the same
     // workspace-rooted sources in the same precedence order.
-    const ruleSources = getAstGrepRuleSources(options.projectRoot ?? cwd);
+    const ignoreRoot = options.projectRoot ?? cwd;
+    const ruleSources = getAstGrepRuleSources(ignoreRoot);
     for (const source of ruleSources) {
         let rules;
         try {
@@ -233,6 +280,7 @@ export function evaluateAstGrepRules(filePath, rootNode, cwd, kind, options = {}
         }
         const duplicates = duplicateRuleIds(rules);
         if (appendDuplicateRuleDiagnostics(diagnostics, seenRuleIds, duplicates, source, filePath, maxTotalDiagnostics)) {
+            flushUnsupportedRuleSkips();
             return diagnostics;
         }
         const duplicateSet = new Set(duplicates);
@@ -245,6 +293,11 @@ export function evaluateAstGrepRules(filePath, rootNode, cwd, kind, options = {}
             seenRuleIds.add(rule.id);
             if (blockingOnly && rule.severity !== "error")
                 continue;
+            // Per-rule path carve-out (#965): a rule that's noise on CLI scripts or
+            // a project's own logging sink (e.g. no-console-except-error firing
+            // inside scripts/** or lib/logger.ts) opts out via `ignores`.
+            if (matchesRuleIgnores(filePath, ignoreRoot, rule.ignores))
+                continue;
             if (suppressLinterOverlap &&
                 LINTER_OVERLAP.has(normalizeRuleId(rule.id)) &&
                 !NON_SUPPRESSIBLE.has(normalizeRuleId(rule.id))) {
@@ -258,7 +311,16 @@ export function evaluateAstGrepRules(filePath, rootNode, cwd, kind, options = {}
                 continue;
             }
             const lang = rule.language?.toLowerCase();
-            if (lang && lang !== "typescript" && lang !== "javascript") {
+            if (lang &&
+                lang !== "typescript" &&
+                lang !== "tsx" &&
+                lang !== "javascript") {
+                if (!unsupportedLanguageLog.has(rule.id)) {
+                    unsupportedLanguageLog.add(rule.id);
+                    const ids = newlyUnsupported.get(lang) ?? [];
+                    ids.push(rule.id);
+                    newlyUnsupported.set(lang, ids);
+                }
                 continue;
             }
             // Scope TypeScript/JavaScript-tagged rules to the file's actual
@@ -338,6 +400,7 @@ export function evaluateAstGrepRules(filePath, rootNode, cwd, kind, options = {}
             }
         }
     }
+    flushUnsupportedRuleSkips();
     return diagnostics;
 }
 // --- Runner Definition ---
@@ -357,7 +420,20 @@ const astGrepNapiRunner = {
         // report against the LSP's `tool: ast-grep` diagnostics. Resume ONLY as the
         // fallback when the binary is absent / can't spawn (Gate B).
         const astGrepLspEnabled = enabledAuxiliaryLspServerIds((f) => ctx.pi?.getFlag?.(f)).includes("ast-grep");
-        if (astGrepLspEnabled && (await ctx.hasTool("ast-grep"))) {
+        // Gate B asks whether the LSP will handle this file, not whether a bare
+        // `ast-grep` command happens to be on PATH. The launcher first tries the
+        // platform-native package binary, then PATH; mirror that resolution here.
+        // A live client covers the already-warm case, while a resolvable binary
+        // covers the cold case before the LSP has spawned for this root.
+        const astGrepLspAlive = astGrepLspEnabled
+            ? await isAuxiliaryLspAlive("ast-grep", ctx.filePath)
+            : false;
+        let astGrepBinaryResolvable = false;
+        if (astGrepLspEnabled && !astGrepLspAlive) {
+            astGrepBinaryResolvable =
+                Boolean(resolveAstGrepNativeExe()) || (await ctx.hasTool("ast-grep"));
+        }
+        if (astGrepLspEnabled && (astGrepLspAlive || astGrepBinaryResolvable)) {
             return { status: "skipped", diagnostics: [], semantic: "none" };
         }
         const sgModule = await loadSg();

package/dist/clients/dispatch/runners/psscriptanalyzer.js

@@ -19,7 +19,16 @@ let psAnalyzerAvailable = undefined;
 const PS_TIMEOUT_MS = 30000;
 function spawnPs(cmd, args, timeoutMs = PS_TIMEOUT_MS) {
     return new Promise((resolve) => {
-        const child = spawn(cmd, args, { windowsHide: true, shell: false });
+        let child;
+        try {
+            child = spawn(cmd, args, { windowsHide: true, shell: false });
+        }
+        catch {
+            // SYNCHRONOUS spawn throw (Windows `spawn UNKNOWN`/EINVAL, the pidusage
+            // bug class, #533) — this best-effort runner must resolve, not reject.
+            resolve({ stdout: "", stderr: "", status: null });
+            return;
+        }
         let stdout = "";
         let stderr = "";
         let settled = false;