@herbertgao/pi-extensions 2026.8.4 → 2026.8.6

package/node_modules/pi-lens/dist/clients/lsp/tsserver-sync.js

@@ -32,10 +32,106 @@
  * `undefined`). The caller must handle `undefined` as "sync path unavailable,
  * fall back to existing unconfirmed/timed-out behavior".
  */
+import { logLatency } from "../latency-logger.js";
+import { normalizeMapKey } from "../path-utils.js";
 // ---------------------------------------------------------------------------
 // Constants
 // ---------------------------------------------------------------------------
 export const TSSERVER_REQUEST_COMMAND = "typescript.tsserverRequest";
+function classifyProjectInfo(body) {
+    if (!body || typeof body !== "object") {
+        return { projectKind: "unassociated", association: "unassociated" };
+    }
+    const info = body;
+    const configFile = typeof info.configFileName === "string" && info.configFileName.length > 0
+        ? info.configFileName
+        : undefined;
+    const inferred = configFile
+        ? /(?:^|[/\\])inferredProject\d*\*?$/i.test(configFile) ||
+            /inferred[-_ ]?project/i.test(configFile)
+        : false;
+    const projectKind = configFile
+        ? inferred
+            ? "inferred"
+            : /(?:^|[/\\])(?:tsconfig|jsconfig)\.json$/i.test(configFile)
+                ? "configured"
+                : "unassociated"
+        : "unassociated";
+    return {
+        projectKind,
+        ...(configFile ? { configFile } : {}),
+        association: info.languageServiceDisabled === true
+            ? "language-service-disabled"
+            : projectKind === "unassociated"
+                ? "unassociated"
+                : "associated",
+    };
+}
+/**
+ * #1412: after classic TypeScript's first successful didOpen, sample the
+ * tsserver project association without delaying diagnostics. The supplied
+ * executeCommand channel owns the existing bounded anti-deadlock backstop.
+ */
+export async function probeTsserverProjectIdentity(options) {
+    const normalizedFile = options.normalizedFile ?? normalizeMapKey(options.file);
+    const startedAt = Date.now();
+    // Logging starts only once a probe is actually eligible and attempted:
+    // ineligible servers (wrong serverId/launchVariant, no command channel) and
+    // already-probed dedupe are both routine, high-volume, and per-server — a
+    // bare return keeps them out of the telemetry stream entirely instead of
+    // writing an `lsp_typescript_project_identity` row per didOpen on every
+    // server (python, go, opengrep, ...).
+    const logOutcome = (outcome, metadata = {}) => logLatency({
+        type: "phase", phase: "lsp_typescript_project_identity", filePath: normalizedFile,
+        durationMs: Date.now() - startedAt,
+        metadata: { serverId: options.serverId, launchVariant: options.launchVariant, clientRoot: options.clientRoot, outcome, ...metadata },
+    });
+    if (options.serverId !== "typescript" ||
+        options.launchVariant !== "classic" ||
+        typeof options.commandChannel.executeCommand !== "function") {
+        return;
+    }
+    if (options.probedFiles.has(normalizedFile))
+        return;
+    // Claim before yielding so concurrent opens cannot issue duplicate probes.
+    options.probedFiles.add(normalizedFile);
+    try {
+        const outcome = await options.commandChannel.executeCommand(TSSERVER_REQUEST_COMMAND, ["projectInfo", { file: options.file, needFileNameList: false }]);
+        if (!outcome.executed) {
+            logOutcome("not-executed");
+            return;
+        }
+        const response = outcome.result;
+        if (!response) {
+            logOutcome("no-response");
+            return;
+        }
+        if (response.success !== true) {
+            logOutcome("unsuccessful");
+            return;
+        }
+        const identity = classifyProjectInfo(response.body);
+        logLatency({
+            type: "phase",
+            phase: "lsp_typescript_project_identity",
+            filePath: normalizedFile,
+            durationMs: Date.now() - startedAt,
+            metadata: {
+                outcome: "ok",
+                serverId: options.serverId,
+                launchVariant: options.launchVariant,
+                clientRoot: options.clientRoot,
+                projectKind: identity.projectKind,
+                configFile: identity.configFile,
+                association: identity.association,
+            },
+        });
+    }
+    catch {
+        logOutcome("threw");
+        // Best-effort telemetry: command errors/timeouts never reach diagnostics.
+    }
+}
 // ---------------------------------------------------------------------------
 // Helpers
 // ---------------------------------------------------------------------------

package/node_modules/pi-lens/dist/clients/lsp/wait-policy/classification.js

@@ -26,7 +26,7 @@ export function classifyServerWaitTier(serverId, snapshot) {
         return "pull-capable";
     if (mode !== "push-only")
         return "waits";
-    const strategy = getStrategy(serverId);
+    const strategy = getStrategy(serverId, snapshot.launchVariant);
     if (strategy.silentOnClean !== true)
         return "waits"; // 2*/unknown push-only
     // #524/#529/#541/#558: `silentOnClean` on a server-id-keyed strategy is
@@ -44,6 +44,24 @@ export function classifyServerWaitTier(serverId, snapshot) {
         return "waits";
     return "tier3-silent";
 }
+/**
+ * Resolve `filePath`'s PRIMARY (non-auxiliary) server id and its live
+ * capability snapshot, or `undefined` when the file has no primary server
+ * configured. The single place that decides what "this file's server" means
+ * for wait-policy purposes — shared by {@link classifyCascadeWaitTier} and the
+ * cascade-lane wrapper in `clients/lsp/cascade-tier.ts`, which needs the same
+ * id/snapshot pair to apply its one cascade-only override.
+ */
+export function resolvePrimaryServerForWaitPolicy(filePath, snapshots) {
+    const servers = getServersForFileWithConfig(filePath).filter((s) => s.role !== "auxiliary");
+    const primary = servers[0];
+    if (!primary)
+        return undefined;
+    return {
+        serverId: primary.id,
+        snapshot: snapshots.find((s) => s.serverId === primary.id),
+    };
+}
 /**
  * Classify whether `filePath`'s PRIMARY language server is a cascade-lane
  * Tier-3 (push-only, silent-on-clean) server. Ambiguous or missing capability
@@ -54,10 +72,8 @@ export function classifyServerWaitTier(serverId, snapshot) {
  */
 export function classifyCascadeWaitTier(lspService, filePath, snapshots) {
     void lspService; // kept in the signature for call-site clarity/typing only
-    const servers = getServersForFileWithConfig(filePath).filter((s) => s.role !== "auxiliary");
-    const primary = servers[0];
+    const primary = resolvePrimaryServerForWaitPolicy(filePath, snapshots);
     if (!primary)
         return "waits";
-    const snapshot = snapshots.find((s) => s.serverId === primary.id);
-    return classifyServerWaitTier(primary.id, snapshot);
+    return classifyServerWaitTier(primary.serverId, primary.snapshot);
 }

package/node_modules/pi-lens/dist/clients/lsp/wait-policy/strategies.js

@@ -138,7 +138,8 @@ export const SERVER_DIAGNOSTIC_STRATEGIES = {
     // (#242), so on a 2500ms-capped edit opengrep waits min(2500, 3500)=2500
     // and on uncapped paths it gets its full 3500. 3500 covers warm and most
     // cold; a cold scan that overruns isn't lost — late diagnostics are cached
-    // and surface on the next edit.
+    // and surface on the next unchanged-content read through the content-bound
+    // auxiliary carry-over path.
     opengrep: {
         seedFirstPush: false,
         pullRetryBudgetMs: 0,
@@ -174,7 +175,8 @@ export const SERVER_DIAGNOSTIC_STRATEGIES = {
     // reopen-on-resync. A native single-workflow audit is sub-second offline;
     // online mode may add a GitHub-API round-trip, so 2000ms gives headroom
     // (bounded by the per-edit caller cap as a ceiling, #242), and any late online
-    // finding is cached and surfaces on the next edit.
+    // finding can surface on the next unchanged-content read through the
+    // content-bound auxiliary carry-over path.
     zizmor: {
         seedFirstPush: true,
         pullRetryBudgetMs: 0,
@@ -231,6 +233,16 @@ export const SERVER_DIAGNOSTIC_STRATEGIES = {
         silentOnClean: true,
     },
 };
+/** Native TS7 can publish multiple versionless partial-program snapshots for a
+ * single open. Its first push is therefore provisional; a quiet window, rather
+ * than a protocol-unstable publication count, establishes the settled push. */
+const NATIVE_TS7_DIAGNOSTIC_STRATEGY = {
+    ...SERVER_DIAGNOSTIC_STRATEGIES.typescript,
+    seedFirstPush: false,
+    // Native TS7 demonstrably publishes on clean, so the classic-only marker
+    // must not leak through the shared server id.
+    silentOnClean: false,
+};
 /** Fallback for unknown servers. Conservative defaults. */
 export const DEFAULT_STRATEGY = {
     seedFirstPush: false,
@@ -239,6 +251,9 @@ export const DEFAULT_STRATEGY = {
     aggregateWaitMs: 1500,
     expectSemanticSecondPush: false,
 };
-export function getStrategy(serverId) {
+export function getStrategy(serverId, launchVariant) {
+    if (serverId === "typescript" && launchVariant === "native-ts7") {
+        return NATIVE_TS7_DIAGNOSTIC_STRATEGY;
+    }
     return SERVER_DIAGNOSTIC_STRATEGIES[serverId] ?? DEFAULT_STRATEGY;
 }

package/node_modules/pi-lens/dist/clients/lsp/workspace-diagnostics-cache.js

@@ -1,9 +1,11 @@
 import * as fs from "node:fs";
 import * as path from "node:path";
 import { getProjectDataDir } from "../file-utils.js";
+import { writeFileAtomic } from "../atomic-write.js";
 import { readJsonCache } from "../json-cache-read.js";
 import { normalizeMapKey } from "../path-utils.js";
 import { loadReverseDependencyIndexFromSnapshot } from "../reverse-deps.js";
+import { createDiskBindingCache, } from "./diagnostic-binding.js";
 /**
  * #671: per-file cache of the last CONFIRMED `runWorkspaceDiagnostics` sweep
  * result, so a repeat `lens_diagnostics mode=full` with no intervening edits
@@ -24,7 +26,12 @@ import { loadReverseDependencyIndexFromSnapshot } from "../reverse-deps.js";
  * `LSPWorkspaceDiagnosticResult.timedOut` in `./index.ts`) into
  * `WorkspaceDiagnosticsCacheEntry`.
  */
-export const WORKSPACE_DIAGNOSTICS_CACHE_VERSION = 1;
+// v2 (#1095): entries may carry an optional `contentHash` fingerprint of the
+// file bytes the cached diagnostics were computed against, so a `lookup` can
+// surface a content `binding` (boundToCurrentDisk) beyond the mtime proxy.
+// Legacy v1 entries are rejected by the version guard and re-scanned — a
+// deliberately clean break so no entry lacking the field is ever served.
+export const WORKSPACE_DIAGNOSTICS_CACHE_VERSION = 2;
 const CACHE_FILE = "lsp-workspace-diagnostics.json";
 function cachePath(cwd) {
     return path.join(getProjectDataDir(cwd), "cache", CACHE_FILE);
@@ -48,7 +55,11 @@ export function loadWorkspaceDiagnosticsCache(cwd) {
 export function saveWorkspaceDiagnosticsCache(cwd, cache) {
     const filePath = cachePath(cwd);
     fs.mkdirSync(path.dirname(filePath), { recursive: true });
-    fs.writeFileSync(filePath, JSON.stringify(cache, null, 2));
+    // bestEffort: false — persist()'s catch is the error policy here, and it
+    // must observe the failure so `dirty` stays set and the next sweep retries.
+    writeFileAtomic(filePath, JSON.stringify(cache, null, 2), {
+        bestEffort: false,
+    });
 }
 /**
  * True when `filePath`'s cached entry is still trustworthy enough to reuse
@@ -133,6 +144,8 @@ export function createWorkspaceDiagnosticsCacheContext(cwd) {
             return undefined;
         return reverseDepsIndex.imports[cacheKeyFor(filePath)] ?? [];
     };
+    // #1095: per-sweep disk-fingerprint memo (per file+mtime) for binding verify.
+    const diskBindingCache = createDiskBindingCache();
     let dirty = false;
     return {
         lookup(filePath, scopeKey) {
@@ -141,15 +154,26 @@ export function createWorkspaceDiagnosticsCacheContext(cwd) {
                 return undefined;
             if (!isEntryFresh(filePath, entry, getImports))
                 return undefined;
-            return { diagnostics: entry.diagnostics, count: entry.count };
+            return {
+                diagnostics: entry.diagnostics,
+                count: entry.count,
+                binding: {
+                    contentHash: entry.contentHash,
+                    boundToCurrentDisk: diskBindingCache.boundToCurrentDisk(filePath, {
+                        contentHash: entry.contentHash,
+                    }),
+                },
+                scannedAt: entry.scannedAt,
+            };
         },
-        record(filePath, scopeKey, diagnostics, mtimeMs) {
+        record(filePath, scopeKey, diagnostics, mtimeMs, contentHash) {
             entries[cacheKeyFor(filePath)] = {
                 diagnostics,
                 count: diagnostics.length,
                 mtimeMs,
                 scannedAt: Date.now(),
                 scopeKey,
+                ...(contentHash !== undefined && { contentHash }),
             };
             dirty = true;
         },

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

@@ -0,0 +1,8 @@
+/** Shared lazy LSP service seam (#1394). */
+let lspPromise;
+export function warmLspService() {
+    return (lspPromise ??= import("./lsp/index.js"));
+}
+export function loadLspService() {
+    return warmLspService();
+}

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

@@ -0,0 +1,248 @@
+import * as path from "node:path";
+import { createReadGuardEditBatchSummary, getReadGuardCorrelationId, logReadGuardEvent, } from "./read-guard-logger.js";
+import { appendProjectChange, } from "./project-changes.js";
+import { normalizeMapKey } from "./path-utils.js";
+const MAX_SAMPLES = 100;
+const MAX_SUMMARIES_PER_CONTEXT = 100;
+export function newLspMutationCorrelationId(toolCallId) {
+    return getReadGuardCorrelationId(toolCallId ? { toolCallId } : {});
+}
+function allResults(options) {
+    return options.results ?? [];
+}
+function combineResults(results) {
+    const files = new Set();
+    const fileDetails = [];
+    const appliedIndexes = [];
+    const paths = [];
+    let requestedTotal = 0;
+    let appliedTotal = 0;
+    let textEdits = 0;
+    let create = 0;
+    let rename = 0;
+    let deleteCount = 0;
+    for (const result of results) {
+        requestedTotal += result.operationTotal;
+        appliedTotal += result.appliedOperationTotal;
+        textEdits += result.operationCounts.textEdits;
+        create += result.operationCounts.create;
+        rename += result.operationCounts.rename;
+        deleteCount += result.operationCounts.delete;
+        for (const index of result.appliedOperationIndexes)
+            appliedIndexes.push(index);
+        for (const file of result.files) {
+            if (!files.has(file)) {
+                files.add(file);
+                paths.push(file);
+            }
+        }
+        fileDetails.push(...result.fileDetails);
+    }
+    return {
+        requestedTotal,
+        appliedTotal,
+        appliedIndexes,
+        files: [...files],
+        fileDetails,
+        textEdits,
+        create,
+        rename,
+        delete: deleteCount,
+        paths,
+    };
+}
+function uniqueDetails(files, fileDetails) {
+    const byPath = new Map();
+    for (const detail of fileDetails) {
+        const key = normalizeMapKey(path.resolve(detail.filePath));
+        const previous = byPath.get(key);
+        if (!previous) {
+            byPath.set(key, detail);
+            continue;
+        }
+        byPath.set(key, {
+            filePath: previous.filePath,
+            range: previous.range && detail.range
+                ? {
+                    start: Math.min(previous.range.start, detail.range.start),
+                    end: Math.max(previous.range.end, detail.range.end),
+                }
+                : previous.range ?? detail.range,
+            importsChanged: previous.importsChanged || detail.importsChanged,
+        });
+    }
+    return files.map((filePath) => byPath.get(normalizeMapKey(path.resolve(filePath))) ?? {
+        filePath,
+        // Resource operations have no already-computed text range. A small
+        // range is still enough to invalidate the touched-file turn state;
+        // never synchronously re-read the whole file here.
+        range: { start: 1, end: 1 },
+        importsChanged: true,
+    });
+}
+function bookkeepLspMutation(context, files, fileDetails) {
+    const details = uniqueDetails(files, fileDetails);
+    for (const detail of details) {
+        const filePath = path.resolve(detail.filePath);
+        if (context.readGuard) {
+            try {
+                context.readGuard.recordWritten(filePath);
+            }
+            catch (err) {
+                context.dbg?.(`lsp mutation read-guard stamp failed for ${filePath}: ${err}`);
+            }
+        }
+        const runtime = context.runtime;
+        if (runtime?.bumpFileSeq) {
+            const { projectSeq, fileSeq } = runtime.bumpFileSeq(filePath);
+            try {
+                appendProjectChange(context.cwd, {
+                    seq: projectSeq,
+                    timestamp: new Date().toISOString(),
+                    sessionId: runtime.telemetrySessionId ?? "unknown",
+                    turnIndex: runtime.turnIndex ?? 0,
+                    source: context.source,
+                    filePath,
+                    fileSeq,
+                    changedRange: detail.range,
+                });
+            }
+            catch (err) {
+                context.dbg?.(`lsp mutation project change append failed for ${filePath}: ${err}`);
+            }
+        }
+        if (context.cacheManager) {
+            try {
+                context.cacheManager.addModifiedRange(filePath, detail.range ?? { start: 1, end: 1 }, detail.importsChanged ?? true, context.cwd, runtime?.telemetrySessionId);
+            }
+            catch (err) {
+                context.dbg?.(`lsp mutation modified-range tracking failed for ${filePath}: ${err}`);
+            }
+        }
+        if (context.recordAutofix && context.source === "autofix") {
+            const key = normalizeMapKey(filePath);
+            const seen = context.autofixRecordedPaths ?? new Set();
+            context.autofixRecordedPaths = seen;
+            if (!seen.has(key)) {
+                if (seen.size >= MAX_SAMPLES) {
+                    const oldest = seen.values().next().value;
+                    if (oldest)
+                        seen.delete(oldest);
+                }
+                seen.add(key);
+                context.recordAutofix(filePath);
+            }
+        }
+    }
+    if (context.publishFilesTouched && files.length > 0) {
+        context.publishFilesTouched(files);
+    }
+}
+function telemetryFor(context, options) {
+    const combined = combineResults(allResults(options));
+    const requestedTotal = options.requestedTotal ?? combined.requestedTotal;
+    const appliedTotal = combined.appliedTotal;
+    const requestedIndexes = Array.from({ length: Math.min(requestedTotal, MAX_SAMPLES) }, (_, index) => index);
+    const rejectedTotal = Math.max(0, requestedTotal - appliedTotal);
+    const rejectedReasons = Array.from({ length: Math.min(rejectedTotal, MAX_SAMPLES) }, (_, index) => ({ index, code: "write_failed" }));
+    const status = options.status ?? (appliedTotal > 0 ? "success" : "skipped");
+    const editBatchSummary = createReadGuardEditBatchSummary({
+        requestedIndexes,
+        requestedTotal,
+        resolvedIndexes: requestedIndexes,
+        resolvedTotal: requestedTotal,
+        rejectedReasons,
+        rejectedTotal,
+        appliedIndexes: combined.appliedIndexes,
+        appliedTotal,
+        participantIds: [context.correlationId],
+        participantTotal: 1,
+        commitStatus: status === "failed"
+            ? "failed"
+            : appliedTotal > 0
+                ? "committed"
+                : "no_changes",
+        terminalStatus: status,
+    });
+    return {
+        editBatchSummary,
+        operationCounts: {
+            requested: requestedTotal,
+            applied: appliedTotal,
+            textEdits: combined.textEdits,
+            create: combined.create,
+            rename: combined.rename,
+            delete: combined.delete,
+        },
+        sampledPaths: combined.paths.slice(0, MAX_SAMPLES),
+        sampledPathsTotal: combined.paths.length,
+        sampledPathsTruncated: combined.paths.length > MAX_SAMPLES,
+        considered: options.considered,
+        completed: options.completed,
+        failedCount: options.failedCount,
+    };
+}
+export function recordLspMutation(context, options = {}) {
+    const results = allResults(options);
+    const combined = combineResults(results);
+    if (options.bookkeep !== false && combined.files.length > 0) {
+        bookkeepLspMutation(context, combined.files, combined.fileDetails);
+    }
+    const telemetry = telemetryFor(context, options);
+    if (context.emitSummary !== false) {
+        const summaryCount = context.summaryCount ?? 0;
+        context.summaryEmitted = true;
+        if (summaryCount < MAX_SUMMARIES_PER_CONTEXT) {
+            context.summaryCount = summaryCount + 1;
+            logReadGuardEvent({
+                event: "edit_batch_summary",
+                correlationId: context.correlationId,
+                filePath: combined.files[0] ?? context.cwd,
+                metadata: {
+                    tool: context.tool,
+                    source: context.source,
+                    outcome: telemetry.editBatchSummary.terminalStatus,
+                    // The outer correlation identifies the soliciting tool call; the
+                    // bounded sequence distinguishes multiple applyEdit requests within it.
+                    summaryIndex: summaryCount,
+                    editBatchSummary: telemetry.editBatchSummary,
+                    operationCounts: telemetry.operationCounts,
+                    sampledPaths: telemetry.sampledPaths,
+                    sampledPathsTotal: telemetry.sampledPathsTotal,
+                    sampledPathsTruncated: telemetry.sampledPathsTruncated,
+                    considered: telemetry.considered,
+                    completed: telemetry.completed,
+                    failedCount: telemetry.failedCount,
+                },
+            });
+        }
+        else if (!context.summaryOverflowed) {
+            context.summaryOverflowed = true;
+            logReadGuardEvent({
+                event: "edit_batch_summary_overflow",
+                correlationId: context.correlationId,
+                filePath: combined.files[0] ?? context.cwd,
+                metadata: {
+                    tool: context.tool,
+                    source: context.source,
+                    summaryLimit: MAX_SUMMARIES_PER_CONTEXT,
+                    suppressedSummaries: "one or more",
+                },
+            });
+        }
+    }
+    return telemetry;
+}
+export function recordLspMutationBatch(context, options) {
+    const previous = context.emitSummary;
+    context.emitSummary = true;
+    try {
+        return recordLspMutation(context, options);
+    }
+    finally {
+        context.emitSummary = previous;
+    }
+}
+export function recordLspMutationOutcome(context, status) {
+    return recordLspMutation(context, { status, requestedTotal: 0 });
+}