@herbertgao/pi-extensions 2026.9.1 → 2026.9.3

package/node_modules/pi-lens/dist/clients/lsp/client.js

@@ -1173,7 +1173,7 @@ export function resolveConfigurationSection(initialization, section) {
 // Exported (only) so tests can invoke the publishDiagnostics notification
 // handler directly against a mock LSPClientState/connection without spawning
 // a real language server. Not part of the public client API surface.
-export function setupIncomingHandlers(state, initialization) {
+export function setupIncomingHandlers(state, initialization, onDiagnosticsPublished) {
     state.connection.onNotification("textDocument/publishDiagnostics", (params) => {
         // #1639: the settle operation's own clock for THIS publish. A
         // "quiet-window" settle's durationMs below measures from here (when
@@ -1188,6 +1188,7 @@ export function setupIncomingHandlers(state, initialization) {
         // that is no longer open on this client.
         if (state.closedDocuments?.has(normalizedPath))
             return;
+        onDiagnosticsPublished?.(state.serverId);
         const newDiags = normalizeLspDiagnostics(params.diagnostics || []);
         const docVersion = params.version;
         if (PUB_DEBUG) {
@@ -3498,7 +3499,7 @@ async function resolveCodeActionBestEffort(state, action) {
 // --- Client Factory ---
 export async function createLSPClient(options) {
     installCrashGuard();
-    const { serverId, process: lspProcess, root, sessionCwd, initialization, initializeTimeoutMs = INITIALIZE_TIMEOUT_MS, launchVariant, } = options;
+    const { serverId, process: lspProcess, root, sessionCwd, initialization, initializeTimeoutMs = INITIALIZE_TIMEOUT_MS, launchVariant, onDiagnosticsPublished, } = options;
     // #449/#472: register this LSP child in the cross-process instance registry
     // as soon as we have a live pid — BEFORE `initialize` completes, not after.
     // Registering early means a child that dies/hangs during initialize (the
@@ -3671,7 +3672,7 @@ export async function createLSPClient(options) {
             return;
         void safeSendNotification(state.connection, "workspace/didChangeWatchedFiles", { changes });
     });
-    setupIncomingHandlers(state, initialization);
+    setupIncomingHandlers(state, initialization, onDiagnosticsPublished);
     connection.listen();
     setupConnectionLifecycle(state, recentStderr);
     let initResult;

package/node_modules/pi-lens/dist/clients/lsp/config.js

@@ -63,10 +63,11 @@ import { getGlobalPiLensDir } from "../file-utils.js";
 import { claimPhaseOncePerSession, currentSessionRecordId, logLatency, releaseOncePerSessionPhase, releasePhaseClaim, } from "../latency-logger.js";
 import { getPiLensGlobalConfigPath } from "../lens-config.js";
 import { normalizeFilePath } from "../path-utils.js";
+import { resolveToolCwd } from "../tool-cwd.js";
 import { logSessionStart } from "../sessionstart-logger.js";
 import { launchLSP } from "./launch.js";
 import { registerSessionRoot, resetSessionRootsForTests, sessionRootConfigEntries, setSessionRootConfig, } from "./session-roots.js";
-import { createRootDetector, LSP_SERVERS, resetLSPCaseSensitivityState, } from "./server.js";
+import { LSP_SERVERS, resetLSPCaseSensitivityState, resolveLspServerCwd, } from "./server.js";
 // --- Config Loading ---
 /**
  * For tests that need to force the warn-once cache to reset between cases —
@@ -336,10 +337,15 @@ export function createCustomServer(config, id) {
     return {
         id,
         name: config.name,
+        custom: true,
         extensions: config.extensions,
+        ...(config.rootMarkers ? { rootMarkers: config.rootMarkers } : {}),
         root: config.rootMarkers
-            ? createRootDetector(config.rootMarkers)
-            : async () => process.cwd(),
+            ? async (file) => resolveToolCwd("lsp", id, file, {
+                cwd: process.cwd(),
+                ...(config.rootMarkers ? { rootMarkers: config.rootMarkers } : {}),
+            })
+            : async (file) => resolveToolCwd("lsp", id, file, { cwd: process.cwd() }),
         async spawn(root) {
             const proc = await launchLSP(config.command, config.args ?? ["--stdio"], {
                 cwd: root,
@@ -599,12 +605,21 @@ export function getServersForFileWithConfig(filePath) {
     const base = path.basename(filePath).toLowerCase();
     return registeredServers(config).filter((server) => selectionReason(server, config, filePath, ext, base) === "selected");
 }
+/**
+ * The primary language server ENTRY for a file — the one "first non-auxiliary
+ * server" predicate, shared by {@link primaryServerId} and
+ * {@link resolveLspCwdForFile} so the id-level and entry-level consumers
+ * cannot drift. `role` is only ever set to "auxiliary" on cross-cutting
+ * scanner entries (ast-grep, opengrep, zizmor, typos, marksman, ...) — see
+ * clients/lsp/server.ts; undefined here means a real language server.
+ */
+function primaryServerEntry(filePath) {
+    return getServersForFileWithConfig(filePath).find((s) => s.role !== "auxiliary");
+}
 /**
  * The primary language server for a file (e.g. "typescript"), as opposed to a
  * cross-cutting auxiliary scanner attached via clientScope "all"/
- * "with-auxiliary" (ast-grep, opengrep, zizmor, typos, marksman, ...). `role`
- * is only ever set to "auxiliary" on those auxiliary entries (see
- * clients/lsp/server.ts) — undefined means a real language server. Used to
+ * "with-auxiliary" (ast-grep, opengrep, zizmor, typos, marksman, ...). Used to
  * split a file's diagnostics into "primary confirmation" vs "auxiliary
  * findings" so a page of ast-grep/opengrep/marksman noise never buries
  * whether the actual type checker/compiler confirmed the file clean.
@@ -615,7 +630,22 @@ export function getServersForFileWithConfig(filePath) {
  * now report the same primary-vs-auxiliary split for the same file.
  */
 export function primaryServerId(filePath) {
-    return getServersForFileWithConfig(filePath).find((s) => s.role !== "auxiliary")?.id;
+    return primaryServerEntry(filePath)?.id;
+}
+/**
+ * #2777 O1: the one seam a tool uses to answer "which cwd did this file's
+ * primary LSP server resolve to". Folds the three-step lookup callers used to
+ * hand-roll (`primaryServerId` + `getServersForFileWithConfig` +
+ * `resolveLspServerCwd`) into one call that returns `undefined` for a file
+ * with no primary LSP server, so the caller must handle the absent case
+ * instead of rendering it (the N1 `cwd=undefined` row becomes structurally
+ * impossible).
+ */
+export async function resolveLspCwdForFile(filePath, sessionCwd) {
+    const primary = primaryServerEntry(filePath);
+    if (!primary)
+        return undefined;
+    return resolveLspServerCwd(primary, filePath, sessionCwd);
 }
 /**
  * Look up an initializationOptions override for a built-in server.

package/node_modules/pi-lens/dist/clients/lsp/diagnostic-binding.js

@@ -73,6 +73,27 @@ export function touchCoverageGap(result) {
 export function touchCompletedConfirmationPolicy(result) {
     return result?.confirmation !== undefined;
 }
+/**
+ * #2878: one publication-evidence predicate for auxiliary coverage. A
+ * content-hash binding proves that the stored publication describes these
+ * bytes. For a version-less publisher, an advanced per-path publication stamp
+ * proves that the auxiliary published after this touch's pre-notify baseline;
+ * the stamp alone cannot prove that the bytes matched. The pre-notify boolean
+ * passed as `bindingMatchesContent` preserves a binding that the notify
+ * cleared, while the live stamp covers a publication that landed after the
+ * wait began. This predicate is the union. Four callers use it; only the
+ * demoted row's `publishedThisContent` takes the union — the sibling and
+ * aggregate rows compute that field from `auxCoversThisContent` directly
+ * (#2914), while their `outcome` field still reads the stamp through this
+ * predicate. Absent evidence fails closed.
+ */
+export function auxiliaryPublicationEvidence({ bindingMatchesContent, baseline, currentPathVersion, raced = true, }) {
+    return (bindingMatchesContent ||
+        (raced &&
+            Number.isFinite(baseline) &&
+            currentPathVersion !== undefined &&
+            currentPathVersion > baseline));
+}
 /**
  * #1493: the single policy deciding which auxiliaries a touch carries NO
  * evidence from. Both no-answer shapes belong here, because they are the same
@@ -106,7 +127,9 @@ export function touchCompletedConfirmationPolicy(result) {
  * irrelevant once a verified publication for them exists. Exempting `silent` but
  * not `cut_off` on identical evidence would report the same coverage two ways
  * depending on which timer happened to win. This stays fail-closed — it
- * un-narrows only against a content-hash match, never against a timer.
+ * un-narrows only against publication evidence (content-hash match, or an
+ * advanced per-path publication stamp for version-less publishers), never
+ * against a timer.
  */
 export function auxiliaryCoverageGap(evidence) {
     return evidence

package/node_modules/pi-lens/dist/clients/lsp/document-drift.js

@@ -88,7 +88,7 @@ const SKIPPED = {
     tracked: 0,
 };
 /** Documents stat'd per pass. Bounds the per-pass cost on a large workspace. */
-export const DRIFT_CHECK_BATCH = 64;
+const DRIFT_CHECK_BATCH = 64;
 /** Resyncs issued per pass. Paces the heal so a bulk edit cannot burst. */
 export const DRIFT_RESYNC_BATCH = 4;
 /** Tracked-document ceiling. A workspace sweep can open far more than this. */
@@ -106,6 +106,8 @@ export function driftCheckIntervalMs() {
 export class DocumentDriftTracker {
     /** Insertion-ordered; the sweep cursor walks it round-robin. */
     synced = new Map();
+    /** Git/external recovery targets waiting for the same paced resync budget. */
+    pendingResync = new Set();
     lastSweepAt = 0;
     cursor = 0;
     /**
@@ -123,6 +125,15 @@ export class DocumentDriftTracker {
     peek(filePath) {
         return this.synced.get(normalizeMapKey(filePath));
     }
+    /** Queue known-open targets for the next ordinary paced drift pass. */
+    enqueueResync(filePaths) {
+        for (const filePath of filePaths) {
+            this.pendingResync.add(normalizeMapKey(filePath));
+        }
+    }
+    get pendingResyncCount() {
+        return this.pendingResync.size;
+    }
     /**
      * Record content that landed on EVERY server holding this document.
      *
@@ -154,6 +165,7 @@ export class DocumentDriftTracker {
     /** Drop every record. Used on shutdown/session reset, where the server's view dies with it. */
     clear() {
         this.synced.clear();
+        this.pendingResync.clear();
         this.cursor = 0;
         this.lastSweepAt = 0;
         this.flight.clear();
@@ -270,11 +282,77 @@ export class DocumentDriftTracker {
                 mtimeMs: entry.stat.mtimeMs,
             });
         }
+        const queued = [...this.pendingResync];
+        for (const key of queued) {
+            if (deps.holdsDocument && !deps.holdsDocument(key)) {
+                this.pendingResync.delete(key);
+                unheld += 1;
+                continue;
+            }
+        }
         let resynced = 0;
         let failed = 0;
         let unchanged = 0;
         let deferred = 0;
+        const resyncedKeys = new Set();
+        for (const key of queued) {
+            if (!this.pendingResync.has(key))
+                continue;
+            if (resynced >= DRIFT_RESYNC_BATCH) {
+                deferred += 1;
+                deps.onDrift?.({
+                    filePath: key,
+                    driftAgeMs: 0,
+                    disposition: "deferred",
+                    syncedSize: this.synced.get(key)?.size ?? 0,
+                    diskSize: -1,
+                });
+                continue;
+            }
+            let content;
+            try {
+                content = await read(key);
+            }
+            catch {
+                this.pendingResync.delete(key);
+                vanished += 1;
+                continue;
+            }
+            let landed = false;
+            try {
+                landed = await deps.resync(key, content, 0);
+            }
+            catch {
+                landed = false;
+            }
+            if (!landed) {
+                failed += 1;
+                deps.onDrift?.({
+                    filePath: key,
+                    driftAgeMs: 0,
+                    disposition: "failed",
+                    syncedSize: this.synced.get(key)?.size ?? 0,
+                    diskSize: Buffer.byteLength(content, "utf8"),
+                });
+                continue;
+            }
+            this.pendingResync.delete(key);
+            resynced += 1;
+            resyncedKeys.add(key);
+            deps.onDrift?.({
+                filePath: key,
+                driftAgeMs: 0,
+                disposition: "resynced",
+                syncedSize: this.synced.get(key)?.size ?? 0,
+                diskSize: Buffer.byteLength(content, "utf8"),
+            });
+        }
         for (const { key, record, mtimeMs } of drifted) {
+            // A Git recovery target and the ordinary stat backstop can identify the
+            // same file in one pass. One event gets one resync opportunity; otherwise
+            // folding Git recovery onto this scheduler double-counts the same write.
+            if (resyncedKeys.has(key))
+                continue;
             const driftAgeMs = Math.max(0, now() - record.syncedAt);
             if (resynced >= DRIFT_RESYNC_BATCH) {
                 // Paced, not dropped: the cursor already advanced past this file, but

package/node_modules/pi-lens/dist/clients/lsp/edits.js

@@ -131,7 +131,7 @@ function parseWorkspaceEdit(edit) {
 function formatRange(range) {
     return `${range.start.line + 1}:${range.start.character + 1}-${range.end.line + 1}:${range.end.character + 1}`;
 }
-export function rangesOverlap(a, b) {
+function rangesOverlap(a, b) {
     return (comparePosition(a.start, b.end) < 0 && comparePosition(b.start, a.end) < 0);
 }
 function positionsEqual(a, b) {
@@ -351,7 +351,7 @@ export async function normalizeWorkspaceEditToUtf16(edit, positionEncoding, cwd)
         ...(edit.documentChanges !== undefined ? { documentChanges } : {}),
     };
 }
-export function flattenWorkspaceTextEdits(edit) {
+function flattenWorkspaceTextEdits(edit) {
     parseWorkspaceEdit(edit);
     const buckets = new Map();
     const push = (uri, edits) => {
@@ -786,7 +786,7 @@ async function createWorkspaceUriConfiner(cwd) {
             filePath = uriToPath(uri);
         }
         catch (err) {
-            throw new Error(`invalid workspace edit URI ${uri}: ${err instanceof Error ? err.message : String(err)}`);
+            throw new Error(`invalid workspace edit URI ${uri}: ${err instanceof Error ? err.message : String(err)}`, { cause: err });
         }
         if (!path.isAbsolute(filePath))
             throw new Error(`workspace edit path escapes workspace: ${uri}`);