@herbertgao/pi-extensions 2026.10.1 → 2026.10.2

package/node_modules/pi-lens/dist/clients/dispatch/facts/try-catch-facts.js

@@ -1,119 +0,0 @@
-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, "");
-    return stripped.trim().length === 0;
-}
-const DEFAULT_VALUE_PATTERN = /\breturn\s+(null|undefined|false|true|0|""|''|``|\[\]|\{\}|new\s+\w+\(\))/;
-const STRUCTURED_ERROR_PATTERN = /\breturn\s+\{[^}]*(?:success\s*:\s*false|error\s*:)/;
-// Any non-trivial comment (≥ 4 non-space chars) counts as documented intent.
-// This covers patterns like: // continue, /* not found */, // best-effort, etc.
-const EXPLAINING_COMMENT_PATTERN = /(?:\/\/\s*\S.{3,}|\/\*\s*\S[\s\S]{3,}?\*\/)/;
-const FS_PROBE_PATTERN = /\b(?:existsSync|statSync|lstatSync|readFileSync|accessSync)\b/;
-const DB_PATTERN = /\b(?:query|execute|findOne|findMany|findById|insert|update|delete|select|prisma\.|knex\.|sequelize\.)/;
-const NETWORK_PATTERN = /\b(?:fetch|axios|http\.|https\.|request\.|got\.|undici\.)/;
-const FS_PATTERN = /\b(?:readFileSync?|writeFileSync?|appendFileSync?|readdirSync?|mkdirSync?|statSync?|unlinkSync?|existsSync|accessSync?|copyFileSync?|renameSync?)\b/;
-const PROCESS_PATTERN = /\b(?:spawn|exec|execSync|spawnSync|child_process\.)\b/;
-function detectBoundaryCategory(tryText) {
-    if (DB_PATTERN.test(tryText))
-        return "db";
-    if (NETWORK_PATTERN.test(tryText))
-        return "network";
-    if (FS_PATTERN.test(tryText))
-        return "fs";
-    if (PROCESS_PATTERN.test(tryText))
-        return "process";
-    return "none";
-}
-function detectTryResolvesLocalValues(tryText) {
-    // Heuristic: no await, no IO calls, no mutations via known side-effectful APIs
-    const hasAwait = /\bawait\b/.test(tryText);
-    const hasIO = DB_PATTERN.test(tryText) ||
-        NETWORK_PATTERN.test(tryText) ||
-        FS_PATTERN.test(tryText) ||
-        PROCESS_PATTERN.test(tryText);
-    return !hasAwait && !hasIO;
-}
-// --- Provider ---
-export const tryCatchFactProvider = {
-    id: "tryCatchFacts",
-    provides: ["file.tryCatchSummaries"],
-    requires: ["file.content"],
-    appliesTo(ctx) {
-        return /\.tsx?$/.test(ctx.filePath);
-    },
-    async run(ctx, store) {
-        await extractFactsFromTree(ctx, store, { "file.tryCatchSummaries": [] }, (root) => {
-            const summaries = [];
-            walk(root, (node) => {
-                if (node.type !== "try_statement")
-                    return;
-                // The direct `statement_block` child is the try body; the catch/finally
-                // blocks are nested inside their own clauses (not direct children).
-                const tryBlock = firstChildOfType(node, "statement_block");
-                const catchClause = firstChildOfType(node, "catch_clause");
-                if (!tryBlock || !catchClause)
-                    return;
-                const tryText = tryBlock.text;
-                const tryResolvesLocalValues = detectTryResolvesLocalValues(tryText);
-                const boundaryCategory = detectBoundaryCategory(tryText);
-                // Catch binding: `catch (e)` → identifier param; `catch {}` or a destructuring
-                // pattern → null (matching the old `ts.isIdentifier` gate).
-                const paramNode = firstChildOfType(catchClause, "identifier");
-                const catchParam = paramNode ? paramNode.text : null;
-                const catchBody = firstChildOfType(catchClause, "statement_block");
-                const bodyText = catchBody
-                    ? catchBody.text.replace(/^\{/, "").replace(/\}$/, "").trim()
-                    : "";
-                const isEmpty = isOnlyWhitespaceOrComments(bodyText);
-                const hasRethrow = /\bthrow\b/.test(bodyText);
-                const hasLogging = /\bconsole\.(log|warn|error)\b/.test(bodyText) ||
-                    /\blogger\./.test(bodyText);
-                // Derived enrichment fields
-                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 &&
-                    !catchReturnsStructuredError &&
-                    !/\b(?:set|update|notify|emit|dispatch|resolve|reject)\b/.test(bodyText);
-                // Filesystem existence probe: try reads a file/path, catch returns a default
-                const isFilesystemExistenceProbe = boundaryCategory === "fs" &&
-                    FS_PROBE_PATTERN.test(tryText) &&
-                    catchReturnsDefault;
-                summaries.push({
-                    line: catchClause.startPosition.row + 1,
-                    column: catchClause.startPosition.column + 1,
-                    catchParam,
-                    bodyText,
-                    isEmpty,
-                    hasRethrow,
-                    hasLogging,
-                    catchLogsOnly,
-                    catchReturnsDefault,
-                    catchReturnsStructuredError,
-                    isDocumentedLocalFallback,
-                    catchHasFallbackAssignment,
-                    tryResolvesLocalValues,
-                    isFilesystemExistenceProbe,
-                    boundaryCategory,
-                });
-            });
-            return { "file.tryCatchSummaries": summaries };
-        });
-    },
-};

package/node_modules/pi-lens/dist/clients/dispatch/finding-policy.js

@@ -1,339 +0,0 @@
-/**
- * The ONE filter stack a findings surface applies before a diagnostic reaches
- * the agent: inline `pi-lens-ignore` comments (#442), stored dispositions
- * (#690 — false-positive/suppress/defer), and the project's `.pi-lens.json`
- * `rules.<id>.disable`/`select` policy, in that order.
- *
- * The order is load-bearing and is the one the per-edit dispatcher established:
- * inline suppression first (the user's in-file intent), then the stored marks,
- * then the project policy — so the policy filter sees the same set the per-edit
- * path produces, with no double counting and no policy-rejected leftovers.
- *
- * #3088: these were three separate calls open-coded in `lens-diagnostics.ts`'s
- * `mode=full` merge and nothing at all on the `lens_diagnostics source=lsp` /
- * `lsp_diagnostics` probe lane — so a finding an agent had marked
- * `false-positive` was hidden in `mode=delta`/`mode=full` and re-reported on
- * the lane `skills/pi-lens-lsp-navigation` steers agents to as PRIMARY. Both
- * lanes call this module now: `applyFindingPolicy` for surfaces that already
- * hold dispatch `Diagnostic`s, `applyLspFindingPolicy` for the probe lane,
- * which holds raw `LSPDiagnostic`s.
- */
-import { applyDispositions, applyDispositionsMultiFile, hasAnyDispositionMarks, } from "../diagnostic-dispositions.js";
-import { loadPiLensProjectConfig } from "../project-lens-config.js";
-import { retagAuxiliaryDiagnostics } from "./auxiliary-lsp.js";
-import { applyInlineSuppressions } from "./inline-suppressions.js";
-import { applyRulePolicy, rulePolicyMapFromConfig } from "./rule-policy.js";
-import { convertLspDiagnostics } from "./utils/lsp-diagnostics.js";
-/**
- * Inline suppression → stored dispositions → project rule policy, over
- * diagnostics that already carry dispatch identity (`tool`/`rule`/`line`).
- */
-export function applyFindingPolicy(diagnostics, options) {
-    const inlineKept = applyInlineSuppressions(diagnostics, options.content);
-    const disposed = filterDisposed(inlineKept, options);
-    return { kept: applyRulePolicy(disposed, options.policyMap), inlineKept };
-}
-/** The project's `.pi-lens.json` `rules.<id>.disable`/`select` policy map.
- * One derivation for every surface that filters by it — `loadPiLensProjectConfig`
- * is mtime-cached, so repeated calls in one sweep cost one stat. */
-export function loadProjectRulePolicyMap(cwd) {
-    return rulePolicyMapFromConfig(loadPiLensProjectConfig(cwd).rules);
-}
-/**
- * Disposition filter over the candidate identities a mark can carry.
- *
- * With no `identities` provider this is `applyDispositions` on the diagnostics
- * themselves — one anchor pair per diagnostic, the behavior every existing
- * caller has. With one, the SAME `applyDispositions` runs over the flattened
- * candidate list — no second strict/weak implementation to drift away from it
- * (#1617's single-source rule) — and a diagnostic drops when ANY of its
- * candidate identities was disposed.
- */
-function filterDisposed(diagnostics, options) {
-    const identities = options.identities;
-    if (!identities) {
-        return applyDispositions(diagnostics, options.cwd, options.filePath, options.content);
-    }
-    // Same zero-I/O hoist the cache-only modes use (#1625 F2): with no marks at
-    // all there is nothing a candidate expansion could match, so the probe lane
-    // pays no per-finding allocation for the overwhelmingly common empty store.
-    if (!diagnostics.length || !hasAnyDispositionMarks(options.cwd)) {
-        return diagnostics;
-    }
-    const expanded = diagnostics.flatMap((diagnostic) => identities(diagnostic).map((identity) => ({
-        diagnostic,
-        candidate: {
-            ...identity,
-            message: diagnostic.message,
-            ...(diagnostic.line !== undefined && { line: diagnostic.line }),
-            ...(diagnostic.semantic !== undefined && {
-                semantic: diagnostic.semantic,
-            }),
-        },
-    })));
-    const survivors = new Set(applyDispositions(expanded.map((entry) => entry.candidate), options.cwd, options.filePath, options.content));
-    const disposed = new Set();
-    for (const entry of expanded) {
-        if (!survivors.has(entry.candidate))
-            disposed.add(entry.diagnostic);
-    }
-    return disposed.size === 0
-        ? diagnostics
-        : diagnostics.filter((diagnostic) => !disposed.has(diagnostic));
-}
-/**
- * #3088 / AGENTS.md shape 26: the identity spellings a mark against a probe
- * finding can carry, derived from the surfaces that RENDER it rather than
- * guessed:
- *
- *  - `convertLspDiagnostics` + `retagAuxiliaryDiagnostics` — the canonical
- *    dispatch identity (`tool: "lsp"`, or the auxiliary's own id, and
- *    `rule: "<source>:<code>"`). This is what the widget footer, `mode=delta`
- *    and `mode=full` render, so it is the spelling of a mark made anywhere
- *    else in the session.
- *  - `formatDiag` in `tools/lsp-diagnostics.ts` — the probe's OWN text render
- *    is `[<source>] (<code>)`, so a mark made from THIS lane's output carries
- *    `tool: "<source>"`, `rule: "<code>"`.
- *
- * plus, for each, the form with `tool` omitted: `lens_diagnostic_mark`'s
- * `tool` parameter is optional and #3088's own reproduction omits it. A
- * single-spelling filter honors a mark made on one surface while re-reporting
- * the same finding when the mark was made on the other, which is exactly the
- * non-convergence #3088 reported.
- */
-function probeIdentities(canonical, raw) {
-    const rendered = [
-        [canonical.tool, canonical.rule],
-    ];
-    if (raw !== undefined &&
-        (raw.source !== undefined || raw.code !== undefined)) {
-        rendered.push([
-            raw.source,
-            raw.code === undefined ? undefined : String(raw.code),
-        ]);
-    }
-    return expandRenderedIdentities(rendered);
-}
-/**
- * #3102: the identity spellings a mark against a surface that renders a
- * finding's RULE but never its TOOL can carry — the turn-end late-auxiliary
- * advisory (`<file>:<line>:<col> [<rule>] <message>`) and the cold-neighbour
- * cascade run (`line N, col M rule=<rule>: <message>`). Both print the
- * canonical dispatch `rule`, so a mark made ELSEWHERE (the widget, `mode=full`)
- * carries the full `(tool, rule)` pair while a mark made from the surface's own
- * output has no tool to pass on — and `lens_diagnostic_mark`'s `tool` parameter
- * is optional. Honoring only one of the two spellings is exactly the
- * non-convergence #3088 reported, so both go through the SAME expansion
- * `probeIdentities` uses.
- */
-export function renderedRuleIdentities(diagnostic) {
-    return expandRenderedIdentities([[diagnostic.tool, diagnostic.rule]]);
-}
-/**
- * #3246: the identity spellings a mark against a surface that renders NEITHER
- * the tool NOR the rule can carry — the turn-end unresolved-inline-blocker
- * body, whose every line is `formatDiagnostics`' `  L<n>: <message>` (plus an
- * optional fix hint). An agent marking from that text has only the message and
- * the line to give `lens_diagnostic_mark`, whose `tool` AND `rule` parameters
- * are both optional, so the mark's anchor carries neither; a mark made from the
- * widget or `mode=full` carries the full canonical pair for the same finding.
- * Honoring one spelling and not the other is exactly the non-convergence #3088
- * reported, so both go through the SAME expansion `probeIdentities` uses. The
- * bare spelling stays safe for this STOP-tier surface because a `"blocking"`
- * diagnostic can only ever be dropped by the STRICT, content-bound
- * false-positive anchor (`applyDispositions`' F1 rule), which still binds the
- * normalized message and the flagged line's content hash.
- */
-export function inlineBlockerIdentities(diagnostic) {
-    return expandRenderedIdentities([
-        [diagnostic.tool, diagnostic.rule],
-        [undefined, undefined],
-    ]);
-}
-/**
- * The whole stack for a turn-end PUSH surface that renders dispatch
- * diagnostics for ONE file — the late-auxiliary drain (#3102) and the
- * late-runner drain (#3248), which are the same shape: a post-freshness-gate
- * `Diagnostic[]`, a `<file>:<line>:<col> [<rule>] <message>` rendering that
- * prints the rule but never the tool, and a suppressed count the caller
- * surfaces once per delivery (#1616).
- *
- * It exists so those two lanes cannot drift apart: this used to be open-coded
- * at the late-auxiliary site, and #3248 would have made a second copy of the
- * identical four arguments — the single-source rule's exact failure shape. The
- * caller still owns its own content read, because the two lanes read on
- * different schedules (the auxiliary drain reads once per FILE across several
- * server pairs; the runner drain reads once per pending runner).
- *
- * `content` is `undefined` when the file could not be read: it becomes `""`,
- * `FindingPolicyOptions.content`'s documented fail-open input, so the STRICT
- * anchor cannot match and nothing is hidden over an I/O error (shape 48).
- */
-export function applyPushedFindingPolicy(findings, options) {
-    const { kept } = applyFindingPolicy(findings, {
-        cwd: options.cwd,
-        filePath: options.filePath,
-        content: options.content ?? "",
-        // mtime-cached, so several files in one drain cost one stat.
-        policyMap: loadProjectRulePolicyMap(options.cwd),
-        identities: renderedRuleIdentities,
-    });
-    return { kept, suppressed: findings.length - kept.length };
-}
-/** Every rendered `(tool, rule)` spelling plus the `tool`-omitted form of
- * each, de-duplicated, in order. One derivation for both callers. */
-function expandRenderedIdentities(rendered) {
-    const out = [];
-    const seen = new Set();
-    for (const [tool, rule] of rendered) {
-        // Both spellings also in the `tool`-omitted form the mark tool admits.
-        for (const candidateTool of [tool, undefined]) {
-            const key = `${candidateTool ?? ""}\u0000${rule ?? ""}`;
-            if (seen.has(key))
-                continue;
-            seen.add(key);
-            out.push({
-                ...(candidateTool !== undefined && { tool: candidateTool }),
-                ...(rule !== undefined && { rule }),
-            });
-        }
-    }
-    return out;
-}
-/* No drop COUNT is returned here on purpose (round 2 F1): the number an agent
- * is shown has to be scoped to that caller's severity threshold, and this
- * module must not learn about a threshold its other caller (`mode=full`) does
- * not have. `kept` versus the input is all a caller needs to derive its own. */
-/**
- * The probe lane's entry point: the same stack, over RAW LSP diagnostics.
- *
- * Identity comes from the two shared converters the widget footer already runs
- * on this very path (`convertLspDiagnostics` + `retagAuxiliaryDiagnostics`),
- * never a third derivation — a second copy of the conversion giving the same
- * finding a different `rule`, and orphaning every mark against it, is the #692
- * defect itself.
- *
- * `retagAuxiliaryDiagnostics` is used for its in-place re-tag only; its own
- * drop set (native aux comments, `skipTestFiles`) is deliberately ignored here
- * because `applyAuxiliarySuppressions` already applied exactly that filter to
- * these diagnostics at collection time — re-dropping would double-apply a
- * filter this route owns upstream.
- */
-export function applyLspFindingPolicy(diagnostics, options) {
-    if (!diagnostics.length)
-        return { kept: diagnostics, inlineKept: diagnostics };
-    const content = options.content ?? "";
-    // `convertLspDiagnostics` drops entries with no start line, which would
-    // break the 1:1 index alignment `retagAuxiliaryDiagnostics` and the map-back
-    // below depend on. Partition first so the converted array IS aligned with
-    // `anchored`; a line-less entry passes straight through (it carries no line
-    // for an anchor to bind to, and dropping it would silently lose a finding
-    // this filter has no claim over).
-    const anchored = [];
-    for (const diagnostic of diagnostics) {
-        if (diagnostic.range?.start?.line !== undefined)
-            anchored.push(diagnostic);
-    }
-    if (!anchored.length)
-        return { kept: diagnostics, inlineKept: diagnostics };
-    const converted = convertLspDiagnostics(anchored, options.filePath);
-    retagAuxiliaryDiagnostics(converted, anchored, content, {
-        cwd: options.cwd,
-        fileRole: options.fileRole,
-    });
-    // `convertLspDiagnostics` maps its (pre-filtered) input 1:1, so `converted[i]`
-    // belongs to `anchored[i]`. Pair them up front and work from the pairing: a
-    // converted entry with no counterpart is simply never paired, so it can never
-    // be dropped — fail open, never hide a finding this filter could not identify.
-    const rawByConverted = new Map();
-    for (const [index, diagnostic] of converted.entries()) {
-        const raw = anchored[index];
-        if (raw !== undefined)
-            rawByConverted.set(diagnostic, raw);
-    }
-    const { kept, inlineKept } = applyFindingPolicy(converted, {
-        cwd: options.cwd,
-        filePath: options.filePath,
-        content,
-        policyMap: options.policyMap,
-        identities: (diagnostic) => probeIdentities(diagnostic, rawByConverted.get(diagnostic)),
-    });
-    const survivorsOf = (survivors) => {
-        if (survivors.length === converted.length)
-            return diagnostics;
-        const keptConverted = new Set(survivors);
-        const dropped = new Set();
-        for (const [diagnostic, raw] of rawByConverted) {
-            if (!keptConverted.has(diagnostic))
-                dropped.add(raw);
-        }
-        return diagnostics.filter((d) => !dropped.has(d));
-    };
-    return { kept: survivorsOf(kept), inlineKept: survivorsOf(inlineKept) };
-}
-/**
- * #1617: turn_end reads gitleaks/govulncheck/trivy straight from their
- * session-scan caches and formats them into advisory/blocker text — a
- * reporting lane parallel to (and, before this fix, entirely bypassing)
- * `dispatcher.ts:924`'s `applyDispositions` filter. An agent-marked
- * false-positive/won't-fix on one of these findings never suppressed it
- * here, so it re-reported on every turn.
- *
- * Filters `findings` through the SAME anchor derivation the dispatch path
- * and `lens_diagnostics mode=full` use (`applyDispositionsMultiFile` in
- * `diagnostic-dispositions.ts`), keyed off each lane's own canonical
- * `ProjectDiagnostic` adapter (`toDiagnostic`) — the exact tool/rule/message
- * identity `lens_diagnostics` already surfaces and `lens_diagnostic_mark`
- * already anchors a mark against, not a second, cloned identity that would
- * silently diverge from what the agent actually marked.
- *
- * Returns the surviving findings plus how many were dropped, so a caller can
- * still surface a "suppressed by disposition: N" trace (the #1616
- * suppressed-bucket rule — a security finding must never vanish with no
- * trace, even when the disposition that dropped it is working as intended).
- */
-export function filterFindingsByDisposition(findings, cwd, toDiagnostic) {
-    if (findings.length === 0)
-        return { kept: findings, suppressed: 0 };
-    // #3248: every `(tool, rule)` spelling a mark against these findings can
-    // carry, not just the canonical one. NONE of these turn-end surfaces prints
-    // a tool — knip renders `<file>:<line> — <type>: <name>`, dead-code
-    // `unused <kind> <name>`, the security lanes `Potential secret: <rule>` —
-    // so an agent marking from what it was SHOWN has no tool to pass, and
-    // `lens_diagnostic_mark`'s `tool` parameter is optional. Honouring only the
-    // spelling `lens_diagnostics` happens to show is the #3088 non-convergence,
-    // and it is fixed HERE, once, for every caller of this helper rather than
-    // per lane. Widening is safe for the blocking members because a
-    // `semantic: "blocking"` finding can still only be dropped by the STRICT,
-    // content-bound false-positive anchor, which keeps binding the normalized
-    // message and the flagged line's content.
-    // The expanded candidate is a `DispositionCandidate` with a path, NOT a
-    // `ProjectDiagnostic`: the tool-omitted spelling has no `tool`, which that
-    // type requires. Only the anchor derivation reads it.
-    const candidates = findings.flatMap((finding) => {
-        const diagnostic = toDiagnostic(finding);
-        return renderedRuleIdentities(diagnostic).map((identity) => ({
-            finding,
-            candidate: {
-                filePath: diagnostic.filePath,
-                message: diagnostic.message,
-                ...(diagnostic.line !== undefined && { line: diagnostic.line }),
-                ...(diagnostic.semantic !== undefined && {
-                    semantic: diagnostic.semantic,
-                }),
-                ...(identity.tool !== undefined && { tool: identity.tool }),
-                ...(identity.rule !== undefined && { rule: identity.rule }),
-            },
-        }));
-    });
-    const survivors = new Set(applyDispositionsMultiFile(candidates.map((c) => c.candidate), cwd, (d) => d.filePath));
-    const disposed = new Set();
-    for (const candidate of candidates) {
-        if (!survivors.has(candidate.candidate))
-            disposed.add(candidate.finding);
-    }
-    const kept = disposed.size === 0
-        ? findings
-        : findings.filter((finding) => !disposed.has(finding));
-    return { kept, suppressed: findings.length - kept.length };
-}