pi-lens 3.8.70 → 3.8.72

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

@@ -16,8 +16,10 @@ import { RUNTIME_CONFIG } from "../../runtime-config.js";
 import { PRIORITY } from "../priorities.js";
 import { resolveRunnerPath } from "../runner-context.js";
 import { convertLspDiagnostics } from "../utils/lsp-diagnostics.js";
-import { enabledAuxiliaryLspServerIds, findAuxiliaryProfileForSource, isAuxiliaryDiagnosticSuppressed, } from "../auxiliary-lsp.js";
+import { enabledAuxiliaryLspServerIds, retagAuxiliaryDiagnostics, } from "../auxiliary-lsp.js";
 import { readFileContent } from "./utils.js";
+import { tryWarmAttachedCodeActions, tryWarmAttachedDiagnostics, } from "../../warm-attach.js";
+import { contentHash, WARM_CODE_ACTION_LOOKUP_LIMIT, } from "../../mcp/ipc.js";
 const LSP_MAX_FILE_BYTES = RUNTIME_CONFIG.pipeline.lspMaxFileBytes;
 const LSP_MAX_FILE_LINES = RUNTIME_CONFIG.pipeline.lspMaxFileLines;
 const LSP_SPAWN_BUDGET_MS = RUNTIME_CONFIG.pipeline.lspSpawnBudgetMs;
@@ -27,7 +29,6 @@ const LSP_SPAWN_BUDGET_MS = RUNTIME_CONFIG.pipeline.lspSpawnBudgetMs;
 // after the cap still land in the client's cache and surface on the
 // next edit. Overridable via PI_LENS_LSP_DIAGNOSTICS_MAX_WAIT_MS.
 const LSP_DIAGNOSTICS_WAIT_MS = 2500;
-const MAX_CODE_ACTION_LOOKUPS = 6;
 const MAX_CODE_ACTION_TITLES = 3;
 function normalizeActionTitle(title) {
     return title.replace(/\s+/g, " ").trim();
@@ -109,6 +110,7 @@ const lspRunner = {
         // one spawned server) — an empty `lspDiags` in that case is NOT a
         // confirmed clean result and must not be reported as one (#570).
         let diagnosticsInconclusive = false;
+        let usedWarmAttach = false;
         let failureReason = "";
         const content = readFileContent(ctx.filePath);
         if (!content) {
@@ -124,21 +126,27 @@ const lspRunner = {
         // path so their warm diagnostics merge into this same result.
         const auxiliaryServerIds = enabledAuxiliaryLspServerIds((f) => ctx.pi.getFlag(f));
         try {
-            const touched = await lspService.touchFile(ctx.filePath, content, {
-                diagnostics: "document",
-                collectDiagnostics: true,
-                clientScope: auxiliaryServerIds.length > 0 ? "with-auxiliary" : "primary",
-                auxiliaryServerIds,
-                maxClientWaitMs: LSP_SPAWN_BUDGET_MS,
-                maxDiagnosticsWaitMs: LSP_DIAGNOSTICS_WAIT_MS,
-                source: "dispatch-lsp-runner",
-            });
+            const attached = await tryWarmAttachedDiagnostics(ctx.filePath, content, Math.max(LSP_SPAWN_BUDGET_MS, LSP_DIAGNOSTICS_WAIT_MS));
+            usedWarmAttach = attached?.available === true;
+            const touched = attached?.available
+                ? attached.response.diagnostics
+                : await lspService.touchFile(ctx.filePath, content, {
+                    diagnostics: "document",
+                    collectDiagnostics: true,
+                    clientScope: auxiliaryServerIds.length > 0 ? "with-auxiliary" : "primary",
+                    auxiliaryServerIds,
+                    maxClientWaitMs: LSP_SPAWN_BUDGET_MS,
+                    maxDiagnosticsWaitMs: LSP_DIAGNOSTICS_WAIT_MS,
+                    source: "dispatch-lsp-runner",
+                });
             if (touched === undefined) {
                 lspClientReady = false;
             }
             else {
                 lspDiags = touched;
-                diagnosticsInconclusive = touched.inconclusive === true;
+                diagnosticsInconclusive =
+                    touched
+                        .inconclusive === true;
             }
         }
         catch (err) {
@@ -206,56 +214,50 @@ const lspRunner = {
         const blockingDiagIndexes = validLspDiags
             .map((d, idx) => ({ d, idx }))
             .filter(({ d }) => d.severity === 1)
-            .slice(0, MAX_CODE_ACTION_LOOKUPS);
-        await Promise.all(blockingDiagIndexes.map(async ({ d, idx }) => {
-            try {
-                const start = d.range.start;
-                const end = d.range.end ?? d.range.start;
-                const actions = await lspService.codeAction(ctx.filePath, start.line, start.character, end.line, end.character);
-                const suggestion = buildCodeActionSuggestion(actions);
-                if (suggestion) {
-                    fixSuggestionByIndex.set(idx, suggestion);
-                }
-            }
-            catch {
-                // Best-effort enrichment only; base diagnostics remain authoritative.
+            .slice(0, WARM_CODE_ACTION_LOOKUP_LIMIT);
+        if (usedWarmAttach) {
+            // Diagnostics have already succeeded. Code actions are optional
+            // enrichment, so ANY IPC failure degrades to today's skip without
+            // promoting the attached session to a local LSP fleet.
+            const ranges = blockingDiagIndexes.map(({ d }) => ({
+                start: d.range.start,
+                end: d.range.end ?? d.range.start,
+            }));
+            const result = await tryWarmAttachedCodeActions(ctx.filePath, contentHash(content), ranges, LSP_DIAGNOSTICS_WAIT_MS);
+            if (result?.available) {
+                result.response.actions.forEach((actions, responseIndex) => {
+                    const diagnosticIndex = blockingDiagIndexes[responseIndex]?.idx;
+                    const suggestion = buildCodeActionSuggestion(actions);
+                    if (diagnosticIndex !== undefined && suggestion) {
+                        fixSuggestionByIndex.set(diagnosticIndex, suggestion);
+                    }
+                });
             }
-        }));
+        }
+        else {
+            await Promise.all(blockingDiagIndexes.map(async ({ d, idx }) => {
+                try {
+                    const start = d.range.start;
+                    const end = d.range.end ?? d.range.start;
+                    const actions = await lspService.codeAction(ctx.filePath, start.line, start.character, end.line, end.character);
+                    const suggestion = buildCodeActionSuggestion(actions);
+                    if (suggestion) {
+                        fixSuggestionByIndex.set(idx, suggestion);
+                    }
+                }
+                catch {
+                    // Best-effort enrichment only; base diagnostics remain authoritative.
+                }
+            }));
+        }
         const diagnostics = convertLspDiagnostics(validLspDiags, diagnosticPath, { fixSuggestionByIndex });
         // convertLspDiagnostics maps validLspDiags 1:1, so re-tag any
         // auxiliary-sourced diagnostics (opengrep emits source "Semgrep", …) with
         // their tool id + semantic policy — language-server diagnostics keep "lsp".
-        // blockingAllowed is per-workspace (e.g. curated repo rules), computed once.
-        const blockingAllowedByProfile = new Map();
-        // Diagnostics dropped by the tool's NATIVE inline suppression (e.g. opengrep
-        // `# nosemgrep`, #441). Reuses `content` from the sync read above.
-        const suppressedIndices = new Set();
-        for (let i = 0; i < diagnostics.length; i++) {
-            const profile = findAuxiliaryProfileForSource(validLspDiags[i]?.source);
-            if (!profile)
-                continue;
-            if (isAuxiliaryDiagnosticSuppressed(validLspDiags[i], content)) {
-                suppressedIndices.add(i);
-                continue;
-            }
-            let blockingAllowed = blockingAllowedByProfile.get(profile);
-            if (blockingAllowed === undefined) {
-                blockingAllowed = profile.allowBlocking?.(ctx.cwd) ?? false;
-                blockingAllowedByProfile.set(profile, blockingAllowed);
-            }
-            const d = diagnostics[i];
-            d.tool = profile.tool;
-            d.semantic = profile.semantic(validLspDiags[i], { blockingAllowed });
-            if (d.semantic !== "blocking" && d.severity === "error") {
-                d.severity = "warning";
-            }
-            const defectClass = profile.defectClass?.(validLspDiags[i]);
-            if (defectClass)
-                d.defectClass = defectClass;
-        }
-        const keptDiagnostics = suppressedIndices.size
-            ? diagnostics.filter((_, i) => !suppressedIndices.has(i))
-            : diagnostics;
+        // #692: shared with the scan/sweep reconcile paths (`retagAuxiliaryDiagnostics`
+        // in `../auxiliary-lsp.js`) so a scan-reconciled aux finding gets identical
+        // tool/semantic/defectClass tagging instead of keeping tool "lsp".
+        const keptDiagnostics = retagAuxiliaryDiagnostics(diagnostics, validLspDiags, content, { cwd: ctx.cwd, fileRole: ctx.fileRole });
         const hasErrors = keptDiagnostics.some((d) => d.semantic === "blocking");
         const resultSemantic = hasErrors
             ? "blocking"

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

@@ -1,3 +1,4 @@
+import { resolvePackagePath } from "../../package-root.js";
 import { safeSpawnAsync } from "../../safe-spawn.js";
 import { getLinterPolicyForCwd, hasMarkdownlintConfig, } from "../../tool-policy.js";
 import { PRIORITY } from "../priorities.js";
@@ -93,9 +94,6 @@ const markdownlintRunner = {
             return { status: "skipped", diagnostics: [], semantic: "none" };
         }
         const hasConfig = hasMarkdownlintConfig(cwd);
-        if (!hasConfig) {
-            // Run with sensible defaults even without explicit config
-        }
         let cmd = null;
         if (await (markdownlint.isAvailableAsync(cwd))) {
             cmd = markdownlint.getCommand(cwd);
@@ -105,7 +103,12 @@ const markdownlintRunner = {
         }
         if (!cmd)
             return { status: "skipped", diagnostics: [], semantic: "none" };
-        const configArgs = hasConfig ? [] : ["--disable", "MD013"];
+        const configArgs = hasConfig
+            ? []
+            : [
+                "--config",
+                resolvePackagePath(import.meta.url, "config/markdownlint/core.json"),
+            ];
         const result = await safeSpawnAsync(cmd, [...configArgs, ctx.filePath], {
             timeout: 15000,
             cwd,

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

@@ -44,7 +44,7 @@ const oxlintRunner = {
     appliesTo: ["jsts"],
     priority: PRIORITY.LINT_SECONDARY,
     enabledByDefault: true,
-    skipTestFiles: true,
+    skipTestFiles: false,
     async run(ctx) {
         const cwd = ctx.cwd || process.cwd();
         const policy = getJstsLintPolicyForCwd(cwd);

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

@@ -82,6 +82,7 @@ const pyrightRunner = {
                         ? "warning"
                         : "none",
             };
+            // pi-lens-ignore: missing-error-propagation
         }
         catch {
             console.error(`[runner:pyright] JSON parse failed for ${ctx.filePath} — raw output: ${output.slice(0, 200)}`);

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

@@ -23,7 +23,7 @@ function runBlastRadiusInBackground(cwd, filePath, languageId, facts) {
     void (async () => {
         try {
             const graph = await buildOrUpdateGraph(cwd, [filePath], facts);
-            const impact = computeImpactCascade(graph, filePath);
+            const impact = computeImpactCascade(graph, filePath, cwd);
             logTreeSitter({
                 phase: "blast_radius",
                 filePath,

package/dist/clients/dispatch/suppress-writer.js

@@ -0,0 +1,68 @@
+/**
+ * Writes the `pi-lens-ignore` suppression comment that inline-suppressions.ts
+ * already knows how to read (#690's `suppress` disposition). The reader
+ * accepts either `//` or `#` on any line regardless of language, but the
+ * WRITER must pick the syntactically valid comment character for the target
+ * file — an errant `#` line breaks parsing in a `//`-comment language and
+ * vice versa.
+ */
+import * as path from "node:path";
+const HASH_COMMENT_EXTENSIONS = new Set([
+    ".py",
+    ".rb",
+    ".sh",
+    ".bash",
+    ".zsh",
+    ".yml",
+    ".yaml",
+    ".toml",
+    ".r",
+    ".pl",
+    ".pm",
+    ".ex",
+    ".exs",
+    ".elixir",
+    ".dockerfile",
+    ".gitignore",
+    ".conf",
+    ".cfg",
+    ".ini",
+]);
+function commentPrefixFor(filePath) {
+    const ext = path.extname(filePath).toLowerCase();
+    return HASH_COMMENT_EXTENSIONS.has(ext) ? "#" : "//";
+}
+/**
+ * Insert a `pi-lens-ignore: <rule>` comment on the line immediately above
+ * `line` (1-based), matching inline-suppressions.ts's "same line or line
+ * above" read semantics. If the line above already carries a pi-lens-ignore
+ * comment, the rule is appended to its list instead of adding a duplicate
+ * comment line. Returns the updated content; throws if `line` is out of range.
+ */
+export function insertSuppressComment(content, filePath, line, rule) {
+    const lines = content.split(/\r?\n/);
+    if (line < 1 || line > lines.length) {
+        throw new Error(`line ${line} is out of range (file has ${lines.length} lines)`);
+    }
+    const prefix = commentPrefixFor(filePath);
+    const aboveIdx = line - 2; // 0-based index of the line immediately above
+    const existingAbove = aboveIdx >= 0 ? lines[aboveIdx] : undefined;
+    const suppressRe = /((?:\/\/|#)\s*pi-lens-ignore:\s*)(.+)$/;
+    const match = existingAbove !== undefined ? suppressRe.exec(existingAbove) : null;
+    if (match && existingAbove !== undefined) {
+        const rules = match[2]
+            .split(",")
+            .map((r) => r.trim())
+            .filter(Boolean);
+        if (!rules.includes(rule))
+            rules.push(rule);
+        lines[aboveIdx] = existingAbove.slice(0, match.index) + match[1] + rules.join(", ");
+        return lines.join("\n");
+    }
+    // Match the indentation of the flagged line so the inserted comment lines
+    // up rather than sitting at column 0.
+    const targetLine = lines[line - 1] ?? "";
+    const indent = /^\s*/.exec(targetLine)?.[0] ?? "";
+    lines.splice(line - 1, 0, `${indent}${prefix} pi-lens-ignore: ${rule}`);
+    return lines.join("\n");
+}

package/dist/clients/dispatch/utils/lsp-diagnostics.js

@@ -7,7 +7,9 @@ export function convertLspDiagnostics(diags, filePath, options = {}) {
         const severity = severityMap[d.severity] ?? "info";
         const semantic = d.severity === 1 ? "blocking" : (d.severity === 2 ? "warning" : "none");
         const code = String(d.code ?? "unknown");
-        const source = options.source ?? d.source ?? tool;
+        // #692: identity ALWAYS derives from the diagnostic's own source — never
+        // from a caller-supplied scan label (see `scanOrigin`'s doc comment above).
+        const source = d.source ?? tool;
         const hasSuggestion = options.fixSuggestionByIndex?.has(idx) ?? false;
         return {
             id: `${tool}:${code}:${d.range.start.line}`,
@@ -23,6 +25,7 @@ export function convertLspDiagnostics(diags, filePath, options = {}) {
             autoFixAvailable: false,
             fixKind: hasSuggestion ? "suggestion" : undefined,
             fixSuggestion: options.fixSuggestionByIndex?.get(idx),
+            scanOrigin: options.scanOrigin,
         };
     });
 }

package/dist/clients/disposition-logger.js

@@ -0,0 +1,39 @@
+/**
+ * NDJSON telemetry log for diagnostic disposition marks (#690). Same shape as
+ * clients/actionable-warnings-logger.ts: machine-global (getGlobalPiLensDir),
+ * size-capped with a single `.log.1` backup, isTestMode no-op.
+ *
+ * Why a log at all: #181 identified false-positive marks flowing to telemetry
+ * as THE highest-value rule-tuning signal — which shipped rules misfire, on
+ * what tools, how often — and this is that hookup. The disposition store
+ * itself is not enough: it keeps only the LATEST entry per anchor (a re-mark
+ * overwrites), and `defer` marks never touch the store at all (in-memory by
+ * design), so this log is the only durable trace of both re-mark history and
+ * defer activity.
+ */
+import * as path from "node:path";
+import { isTestMode } from "./env-utils.js";
+import { getGlobalPiLensDir } from "./file-utils.js";
+import { createNdjsonLogger } from "./ndjson-logger.js";
+const DISPOSITION_LOG_DIR = getGlobalPiLensDir();
+const DISPOSITION_LOG_FILE = path.join(DISPOSITION_LOG_DIR, "dispositions.log");
+const DISPOSITION_LOG_BACKUP_FILE = path.join(DISPOSITION_LOG_DIR, "dispositions.log.1");
+const MAX_LOG_BYTES = Math.max(128 * 1024, Number.parseInt(process.env.PI_LENS_DISPOSITION_LOG_MAX_BYTES ?? "1048576", 10) || 1048576);
+const writer = createNdjsonLogger({
+    filePath: DISPOSITION_LOG_FILE,
+    maxBytes: MAX_LOG_BYTES,
+    backupPath: DISPOSITION_LOG_BACKUP_FILE,
+});
+export function logDispositionEvent(entry) {
+    if (isTestMode()) {
+        return;
+    }
+    writer.log({ ts: new Date().toISOString(), ...entry });
+}
+export function getDispositionLogPath() {
+    return DISPOSITION_LOG_FILE;
+}
+/** Resolve once all enqueued disposition writes are on disk. */
+export function flushDispositionLog() {
+    return writer.flush();
+}

package/dist/clients/disposition-publish.js

@@ -0,0 +1,109 @@
+/**
+ * Publishes `pilens:diagnostic:disposition` on pi's shared `pi.events` bus
+ * (#690).
+ *
+ * Sibling to `clients/diagnostics-publish.ts` (#502) rather than a new export
+ * inside it, per the "owns nothing in common" rule spelled out in
+ * format-events-publish.ts's header: the event is diagnostic-DOMAIN, but it
+ * shares none of diagnostics-publish's module state or contract —
+ * dispositions are point-in-time FACTS ("a mark just happened"), not
+ * full-replace state snapshots, so the seq counter, the
+ * previously-reported-dirty set, and the whole staleness/replace consumer
+ * contract over there simply don't apply here. Only the emit plumbing shape
+ * and the `PI_LENS_BUS_PUBLISH` kill switch (`isBusPublishEnabled`, imported
+ * from bus-publish.ts) are shared, same as every other producer sibling.
+ *
+ * Fire-and-forget: publishing must never affect the mark path's success or
+ * latency. Any failure is swallowed; `dbg` fires at most once per process on
+ * first failure so a wired caller can log it without spamming.
+ *
+ * Versioning policy: frozen-additive, same discipline as #482/#502. New
+ * optional fields may be added under `v: 1`; a breaking change to an existing
+ * field's meaning must bump `v`.
+ */
+import { logBusEvent } from "./bus-events-logger.js";
+import { isBusPublishEnabled } from "./bus-publish.js";
+import { normalizeFilePath } from "./path-utils.js";
+export const BUS_DISPOSITION_EVENT = "pilens:diagnostic:disposition";
+export const BUS_DISPOSITION_VERSION = 1;
+let busEmit;
+let hasLoggedFailure = false;
+let hasLoggedUnwired = false;
+let hasLoggedDisabled = false;
+/**
+ * Wire the emit function from pi's `pi.events` bus. Called once at extension
+ * factory time from index.ts, same call as `wireDiagnosticsBusEmitter` (#502)
+ * — both producers share the identical `pi.events.emit` binding. Never called
+ * ⇒ `publishDisposition` no-ops, which is exactly the state unit tests and
+ * the MCP server path run in (no pi host, no `pi.events`).
+ */
+export function wireDispositionBusEmitter(emitFn) {
+    busEmit = emitFn;
+}
+/** Test-only: reset module state between test files. */
+export function _resetDispositionPublishForTests() {
+    busEmit = undefined;
+    hasLoggedFailure = false;
+    hasLoggedUnwired = false;
+    hasLoggedDisabled = false;
+}
+/**
+ * Publish one `pilens:diagnostic:disposition` event for a mark (one event per
+ * markDisposition call). Fire-and-forget: never throws, never awaited.
+ */
+export function publishDisposition(args) {
+    if (!isBusPublishEnabled()) {
+        if (!hasLoggedDisabled) {
+            hasLoggedDisabled = true;
+            logBusEvent({
+                event: BUS_DISPOSITION_EVENT,
+                outcome: "skipped_disabled",
+                cwd: normalizeFilePath(args.cwd),
+            });
+        }
+        return;
+    }
+    if (!busEmit) {
+        if (!hasLoggedUnwired) {
+            hasLoggedUnwired = true;
+            logBusEvent({
+                event: BUS_DISPOSITION_EVENT,
+                outcome: "skipped_unwired",
+                cwd: normalizeFilePath(args.cwd),
+            });
+        }
+        return;
+    }
+    try {
+        const payload = {
+            v: BUS_DISPOSITION_VERSION,
+            source: "pi-lens",
+            cwd: normalizeFilePath(args.cwd),
+            filePath: normalizeFilePath(args.filePath),
+            disposition: args.disposition,
+            tool: args.tool,
+            rule: args.rule,
+            line: args.line,
+            anchor: args.anchor,
+            reason: args.reason,
+        };
+        busEmit(BUS_DISPOSITION_EVENT, payload);
+        logBusEvent({
+            event: BUS_DISPOSITION_EVENT,
+            outcome: "emitted",
+            cwd: payload.cwd,
+        });
+    }
+    catch (err) {
+        logBusEvent({
+            event: BUS_DISPOSITION_EVENT,
+            outcome: "emit_failed",
+            cwd: normalizeFilePath(args.cwd),
+            error: String(err),
+        });
+        if (!hasLoggedFailure) {
+            hasLoggedFailure = true;
+            args.dbg?.(`disposition-publish: pilens:diagnostic:disposition emit failed (further failures suppressed): ${err}`);
+        }
+    }
+}

package/dist/clients/env-utils.js

@@ -43,3 +43,41 @@ export function toPositiveFinite(value) {
     const num = typeof value === "number" ? value : Number(value);
     return Number.isFinite(num) && num > 0 ? num : 0;
 }
+/**
+ * Factory for the lazy-memoized "positive-finite-number env override, else a
+ * default" getter pattern repeated across `startup-scan.ts` (#699, #758) and
+ * originally documented as house style in `runtime-config.ts` / `slow-fs.ts` /
+ * `subagent-mode.ts` (#763).
+ *
+ * `get()` reads `process.env[envName]` through {@link toPositiveFinite} the
+ * first time it's called, memoizes the result (or `fallback` when the env var
+ * is unset/non-finite/non-positive), and returns the memo on every subsequent
+ * call. `_resetForTests()` clears the memo so a test can flip the env var and
+ * observe a fresh read (matching the existing `_resetForTests` convention).
+ *
+ * Deliberately does NOT touch `process.env` until `get()` is first called —
+ * that's the entire point of the lazy pattern: importing a module must never
+ * have a side effect on process env at load time.
+ *
+ * @example
+ * ```ts
+ * const _ttl = lazyEnvNumber("PI_LENS_STARTUP_SCAN_VERDICT_TTL_MS", DEFAULT_TTL_MS);
+ * export const getStartupScanVerdictTtlMs = _ttl.get;
+ * export const _resetStartupScanVerdictTtlForTests = _ttl._resetForTests;
+ * ```
+ */
+export function lazyEnvNumber(envName, fallback) {
+    let memo;
+    return {
+        get() {
+            if (memo !== undefined)
+                return memo;
+            const envValue = toPositiveFinite(process.env[envName]);
+            memo = envValue > 0 ? envValue : fallback;
+            return memo;
+        },
+        _resetForTests() {
+            memo = undefined;
+        },
+    };
+}