@herbertgao/pi-extensions 2026.8.5 → 2026.8.7

package/node_modules/pi-lens/dist/clients/lsp/spawn-history.js

@@ -0,0 +1,22 @@
+/** Process-lifetime history of successful LSP spawn plus initialize durations. */
+const MAX_SERVER_HISTORIES = 64;
+const successfulSpawnDurationMs = new Map();
+export function recordSuccessfulLspSpawn(serverId, durationMs) {
+    if (!Number.isFinite(durationMs) || durationMs < 0)
+        return;
+    successfulSpawnDurationMs.delete(serverId);
+    successfulSpawnDurationMs.set(serverId, durationMs);
+    while (successfulSpawnDurationMs.size > MAX_SERVER_HISTORIES) {
+        const oldest = successfulSpawnDurationMs.keys().next().value;
+        if (oldest === undefined)
+            break;
+        successfulSpawnDurationMs.delete(oldest);
+    }
+}
+export function getSuccessfulLspSpawnDurationMs(serverId) {
+    return successfulSpawnDurationMs.get(serverId);
+}
+/** Test-only: isolate process-lifetime history between cases. */
+export function _clearSuccessfulLspSpawnHistoryForTests() {
+    successfulSpawnDurationMs.clear();
+}

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

@@ -0,0 +1,43 @@
+/**
+ * LSP `textDocument/didChange` sync-kind negotiation (#1669).
+ *
+ * A server advertises how it wants document changes described via
+ * `ServerCapabilities.textDocumentSync`, either as a bare
+ * `TextDocumentSyncKind` number (the legacy pre-3.0 shape) or as a
+ * `TextDocumentSyncOptions` object whose `change` field carries the kind.
+ * pi-lens always sent a single whole-document `{ text }` change event — valid
+ * for `Full` (1) and harmless for `None` (0, since the server ignores content
+ * changes entirely), but out of spec for `Incremental` (2): an
+ * Incremental-only server expects every change event to carry a `range`.
+ *
+ * This module is the pure negotiation core, mirroring `position-encoding.ts`'s
+ * shape: read the kind from the server's `initialize` reply, defaulting to
+ * `Full` when the server doesn't advertise one — the same shape pi-lens has
+ * always sent, so an unrecognized/absent value never regresses `Full`/`None`
+ * behavior.
+ */
+export const TEXT_DOCUMENT_SYNC_KIND_NONE = 0;
+export const TEXT_DOCUMENT_SYNC_KIND_FULL = 1;
+export const TEXT_DOCUMENT_SYNC_KIND_INCREMENTAL = 2;
+function isSyncKind(value) {
+    return value === 0 || value === 1 || value === 2;
+}
+/**
+ * The `change` sync kind the server negotiated, read from its `initialize`
+ * reply. Defaults to `Full` (pi-lens's historical always-whole-document
+ * behavior) when the server omits `textDocumentSync` entirely, or advertises
+ * a shape/value this function doesn't recognize.
+ */
+export function negotiateSyncKind(serverCapabilities) {
+    const sync = serverCapabilities?.textDocumentSync;
+    // Legacy shape: the whole field IS the kind.
+    if (isSyncKind(sync))
+        return sync;
+    // 3.0+ shape: `TextDocumentSyncOptions.change`.
+    if (sync && typeof sync === "object") {
+        const change = sync.change;
+        if (isSyncKind(change))
+            return change;
+    }
+    return TEXT_DOCUMENT_SYNC_KIND_FULL;
+}

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

@@ -32,10 +32,182 @@
  * `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";
+/**
+ * tsserver's synthetic inferred-project name, as its own source builds it:
+ * `"/dev/null/inferredProject" + counter + "*"`. `/dev/null` is a deliberate
+ * sentinel prefix — no real config file can live there — and matching the WHOLE
+ * string against it is the only safe test.
+ *
+ * #1645 review F4: an earlier version also matched an UNANCHORED
+ * `/inferred[-_ ]?project/i` anywhere in the string. That inverted the verdict
+ * for a real project in a directory a human happened to name that way —
+ * `/repo/inferred-project/tsconfig.json` classified as INFERRED, which demoted
+ * its genuine blocking errors. A classifier that gates authority must never key
+ * off user-controlled directory names.
+ *
+ * The optional drive-letter/backslash arm covers a host that normalizes the
+ * sentinel through win32 path handling before it reaches us; the `/dev/null`
+ * prefix is still required.
+ */
+const INFERRED_PROJECT_SENTINEL = /^(?:[A-Za-z]:)?[/\\]dev[/\\]null[/\\]inferredProject\d*\*?$/i;
+/**
+ * Classify one tsserver `projectInfo` response body.
+ *
+ * `configFileName` is tsserver's own answer to "which project owns this file".
+ * A real project answers with a `tsconfig.json`/`jsconfig.json` path; a file
+ * that matches no project's `include`/`files` lands in tsserver's synthetic
+ * inferred project, whose `configFileName` is a `/dev/null/inferredProject1*`
+ * placeholder. The two are the same field, so the placeholder shape is the only
+ * thing that separates "checked against the project's real compiler options"
+ * from "checked against defaults nobody configured" (#1640).
+ *
+ * Exported so the diagnostic-demotion seam (`inferred-project.ts`) and the
+ * #1412 telemetry probe share ONE classifier — a second hand-rolled
+ * configFileName test would be a parallel source of truth for the same verdict.
+ */
+export 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
+        ? INFERRED_PROJECT_SENTINEL.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.
+    }
+}
+/**
+ * #1640: ask tsserver which project owns `file`, on demand, through the same
+ * `typescript.tsserverRequest` escape hatch the sync-diagnostics helpers use.
+ *
+ * Unlike {@link probeTsserverProjectIdentity} — fire-and-forget telemetry
+ * sampled once per didOpen — this is a request/response call a caller awaits
+ * because it needs the answer to decide how to RENDER a diagnostic.
+ *
+ * Routed through `executeReadOnlyCommandOnLiveClient` ONLY, never
+ * `executeCommand` (#1645 review F1/F2). The mutation channel would open the
+ * `workspace/applyEdit` acceptance window, clobber a concurrent command's
+ * `activeMutationContext`, carry the 30s mutation backstop instead of the short
+ * probe one, and spawn a language-server fleet to answer. All four are wrong for
+ * a passive render-path question. A service without the read-only channel is
+ * UNKNOWN, not a reason to fall back.
+ *
+ * Returns `undefined` for every "we do not know" path: no read-only channel, no
+ * live server for the file, the command is not advertised (non-classic server,
+ * older typescript-language-server), the command was not executed, the response
+ * envelope is not `{success:true}`, or the call threw/timed out. `undefined`
+ * must never be treated as "inferred" — an unanswered probe is not a verdict
+ * (AGENTS.md shape 10: an empty result must distinguish clean from unavailable).
+ */
+export async function fetchTsserverProjectIdentity(svc, file) {
+    try {
+        if (typeof svc.executeReadOnlyCommandOnLiveClient !== "function") {
+            return undefined;
+        }
+        // No `getAdvertisedCommands` pre-flight: that helper routes through
+        // `getClientForFile`, which SPAWNS. The read-only channel already enforces
+        // allowlist-by-advertisement server-side and answers `executed:false` for
+        // a server that never advertised the command.
+        const outcome = await svc.executeReadOnlyCommandOnLiveClient(file, TSSERVER_REQUEST_COMMAND, ["projectInfo", { file, needFileNameList: false }]);
+        if (!outcome.executed)
+            return undefined;
+        const response = outcome.result;
+        if (!response || response.success !== true)
+            return undefined;
+        return classifyProjectInfo(response.body);
+    }
+    catch {
+        return undefined;
+    }
+}
 // ---------------------------------------------------------------------------
 // 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,
@@ -230,6 +232,59 @@ export const SERVER_DIAGNOSTIC_STRATEGIES = {
         // warm-up attempt and its retry, with zero diagnostics either time).
         silentOnClean: true,
     },
+    // cue lsp serve (#1522, #1519, #1520). Measured directly against the real
+    // v0.17.1 binary (`getWorkspaceDiagnosticsSupport` reports
+    // `mode: "push-only"`; no pull support advertised).
+    //
+    // It reports load/parse (syntax) errors as you type, but leaves
+    // conflicting-value/constraint-failure (evaluation) errors to `cue vet`
+    // — the #1522 cue-vet auxiliary runner covers that gap. So the syntax
+    // diagnostics this strategy governs are a REAL but PARTIAL signal, not
+    // full CUE validation.
+    //
+    // silentOnClean: true — the load-bearing finding. A cold `didOpen` on an
+    // already-CLEAN file publishes NOTHING inside the wait budget (measured:
+    // `touchFile` returns `inconclusive: true, inconclusiveReason:
+    // "diagnostics-wait"` after the full budget, never an affirmative empty
+    // array). This reproduces the #1520 review's original "reports
+    // conclusively clean while still waiting" concern for the clean-cold-open
+    // case specifically. It is NOT silent on every transition, though: once a
+    // document is open and a `didChange` lands, the server DOES publish —
+    // both the error (edit clean→broken: confirmed, ~930ms warm) and an
+    // explicit empty array clearing it (edit broken→clean: confirmed,
+    // ~320ms warm, `contentHash`-bound). That edit-triggered empty publish is
+    // exactly what the shared push-only clean-confirm gate needs
+    // `silentOnClean` for — it only ever governs the "no publish, notify
+    // succeeded" case, never a case that already got a real publish.
+    //
+    // seedFirstPush: true — the one cold-open case that DOES publish (a
+    // file that is already broken) sends the complete single diagnostic on
+    // its first push; there is no observed partial-then-complete sequence to
+    // wait out.
+    //
+    // aggregateWaitMs: 2000 covers the measured warm edit-to-publish latency
+    // (~930ms, syntax reparse) with margin; a cold spawn's first push (~2.1s
+    // end-to-end including process start) is bounded separately by
+    // maxClientWaitMs, not this per-diagnostics budget.
+    cue: {
+        seedFirstPush: true,
+        pullRetryBudgetMs: 0,
+        debounceMs: 150,
+        aggregateWaitMs: 2000,
+        expectSemanticSecondPush: false,
+        reopenOnResync: false,
+        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 = {
@@ -239,6 +294,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;
 }