@herbertgao/pi-extensions 2026.8.6 → 2026.8.7

package/node_modules/pi-lens/dist/clients/lsp/inferred-project.js

@@ -0,0 +1,215 @@
+/**
+ * #1640: honest rendering for TypeScript diagnostics on files that belong to no
+ * tsconfig project.
+ *
+ * When a file matches no project's `include`/`files`, tsserver still checks it —
+ * in a synthetic INFERRED project with default compiler options, no `types`
+ * from the project's `tsconfig`, and different module resolution. The project's
+ * own `tsc --noEmit` never looks at those files, so the two answers legitimately
+ * disagree. Presenting the inferred answer at full blocking authority tells the
+ * agent that a gate failed when no gate ever ran.
+ *
+ * The fix is DEMOTE-WITH-LABEL, never suppress. The live #1640 triage found the
+ * inferred-project batch was a MIX: some diagnostics were provably phantom
+ * (missing test-runner globals, module resolution), and others were genuine type
+ * errors the project's `tsc` gate cannot see precisely BECAUSE the files sit
+ * outside every project. Suppression would hide the real ones. Blocking would
+ * overstate confidence in the phantom ones. Demoting to warning and naming the
+ * config gap preserves the signal and hands the verification burden to the
+ * person who can close it.
+ *
+ * Every "we do not know" path leaves the diagnostics untouched. An unanswered
+ * `projectInfo` probe is not a verdict (AGENTS.md shape 10).
+ */
+import * as path from "node:path";
+import { fetchTsserverProjectIdentity, } from "./tsserver-sync.js";
+import { toProjectRelativePath } from "../path-utils.js";
+import { logLatency } from "../latency-logger.js";
+/**
+ * The stable, greppable half of the label. Tests and renderers match on this;
+ * the actionable `add <glob>` half varies per file.
+ *
+ * Sibling of `STALE_LINE_MARKER` (`clients/runtime-turn.ts`) — same idea: a
+ * finding that survives at reduced authority says so in its own text, so no
+ * downstream renderer has to be taught about the demotion separately.
+ */
+export const INFERRED_PROJECT_MARKER = "not in any tsconfig project — checked with inferred settings";
+/** Extensions tsserver owns. A file outside this set never reaches the probe. */
+const TS_PROJECT_EXTENSIONS = new Set([
+    ".ts",
+    ".tsx",
+    ".mts",
+    ".cts",
+    ".js",
+    ".jsx",
+    ".mjs",
+    ".cjs",
+]);
+/**
+ * `source` values the classic typescript-language-server stamps on its own
+ * diagnostics. Auxiliary servers sharing the same result (opengrep, typos,
+ * zizmor, ast-grep) carry their own source and are NOT affected by a tsconfig
+ * gap, so they keep their severity.
+ */
+const TYPESCRIPT_DIAGNOSTIC_SOURCES = new Set(["typescript", "ts", "tsserver"]);
+export function isTsProjectFile(filePath) {
+    return TS_PROJECT_EXTENSIONS.has(path.extname(filePath).toLowerCase());
+}
+export function isTypeScriptSourcedDiagnostic(d) {
+    return TYPESCRIPT_DIAGNOSTIC_SOURCES.has((d.source ?? "").toLowerCase());
+}
+/**
+ * The glob the user should add to a tsconfig `include`. A file at
+ * `tests/unit/a.test.ts` yields `tests/**` — the top-level directory is what a
+ * person actually adds, and it is what the #1640 report itself asked for. A
+ * file sitting directly in the project root yields its own relative path, since
+ * there is no containing directory to name.
+ */
+export function suggestTsconfigInclude(filePath, cwd) {
+    const relative = toProjectRelativePath(filePath, cwd);
+    if (path.posix.isAbsolute(relative) || /^[A-Za-z]:/.test(relative)) {
+        // Outside the project root: name the file's own directory instead of
+        // inventing a root-relative glob that would not match anything.
+        const dir = relative.slice(0, relative.lastIndexOf("/"));
+        return dir ? `${dir}/**` : relative;
+    }
+    const segments = relative.split("/").filter(Boolean);
+    return segments.length > 1 ? `${segments[0]}/**` : relative;
+}
+/** The full label appended to a demoted diagnostic's message. */
+export function inferredProjectNotice(filePath, cwd) {
+    return `[${INFERRED_PROJECT_MARKER}; add ${suggestTsconfigInclude(filePath, cwd)} to a tsconfig for authoritative checking]`;
+}
+/**
+ * Pure transform: demote every TypeScript-sourced ERROR to a warning and append
+ * the label. Warnings, hints, and auxiliary-sourced findings are returned
+ * untouched — they were never blockers, so relabelling them would be noise.
+ *
+ * Returns the SAME array reference when nothing changed, so callers can cheaply
+ * skip rebuilding their result objects.
+ */
+export function applyInferredProjectDemotion(diagnostics, filePath, cwd) {
+    if (!diagnostics.some(isDemotableDiagnostic))
+        return diagnostics;
+    const notice = inferredProjectNotice(filePath, cwd);
+    return diagnostics.map((d) => isDemotableDiagnostic(d)
+        ? { ...d, severity: 2, message: `${d.message} ${notice}` }
+        : d);
+}
+function isDemotableDiagnostic(d) {
+    return d.severity === 1 && isTypeScriptSourcedDiagnostic(d);
+}
+/**
+ * Probe project membership for `filePath` and demote its diagnostics when
+ * tsserver answers "inferred project".
+ *
+ * Short-circuits BEFORE any probe when there is nothing a demotion could change:
+ * a non-TypeScript file, or a diagnostic list with no TypeScript-sourced error
+ * in it. So a clean sweep pays nothing, and a sweep over 500 clean files issues
+ * zero extra requests.
+ */
+export async function demoteInferredProjectDiagnostics(diagnostics, options) {
+    const { filePath, cwd, service } = options;
+    if (!isTsProjectFile(filePath))
+        return diagnostics;
+    if (!diagnostics.some(isDemotableDiagnostic))
+        return diagnostics;
+    if (options.signal?.aborted)
+        return diagnostics;
+    const fetchIdentity = options.fetchIdentity ?? fetchTsserverProjectIdentity;
+    const cache = options.identityCache;
+    let identity;
+    if (cache?.has(filePath)) {
+        identity = cache.get(filePath);
+    }
+    else {
+        identity = await fetchIdentity(service, filePath);
+        cache?.set(filePath, identity);
+    }
+    // `undefined` (probe unavailable/failed) and "unassociated" (tsserver named
+    // no project at all) are both UNKNOWN, not "inferred". Demoting on either
+    // would downgrade real blockers on any server that does not speak the
+    // tsserverRequest escape hatch.
+    if (identity?.projectKind !== "inferred")
+        return diagnostics;
+    return applyInferredProjectDemotion(diagnostics, filePath, cwd);
+}
+/**
+ * Cap on how many `projectInfo` probes one sweep may issue. Only files that
+ * actually carry a TypeScript error probe at all, so on a healthy project this
+ * is never approached. Past the cap, membership stays UNKNOWN and nothing is
+ * demoted — the fail-safe direction is the pre-#1640 behavior, not a silent
+ * mass demotion.
+ */
+export const INFERRED_PROJECT_PROBE_BUDGET = 300;
+/**
+ * Sweep-wide entry point: demote every result whose file tsserver owns only
+ * through an inferred project. Sequential on purpose — the probes run against a
+ * single-threaded tsserver, so fanning out would only queue behind itself.
+ *
+ * The identity memo is local to this call. A module-level cache would pin the
+ * first sweep's verdict for the life of the process, and editing a tsconfig is
+ * precisely what changes the answer.
+ *
+ * The loop honors the caller's abort signal between files. The sweep that
+ * produced these results is itself signal-bounded, so continuing to probe after
+ * an abort would spend budget on an answer nobody will read (#1645 review F1).
+ */
+export async function demoteInferredProjectSweepResults(results, cwd, service, signal) {
+    if (typeof service?.executeReadOnlyCommandOnLiveClient !== "function") {
+        return results;
+    }
+    const startedAt = Date.now();
+    const identityCache = new Map();
+    const out = [];
+    let demotedFiles = 0;
+    let demotedDiagnostics = 0;
+    let budgetExhausted = false;
+    let aborted = false;
+    for (const result of results) {
+        const diagnostics = result.diagnostics ?? [];
+        if (signal?.aborted) {
+            // Carry the remaining results through UNCHANGED rather than dropping
+            // them — an abort must cost the demotion, never a finding.
+            aborted = true;
+            out.push(result);
+            continue;
+        }
+        if (identityCache.size >= INFERRED_PROJECT_PROBE_BUDGET && !identityCache.has(result.filePath)) {
+            budgetExhausted = true;
+            out.push(result);
+            continue;
+        }
+        const demoted = await demoteInferredProjectDiagnostics(diagnostics, {
+            filePath: result.filePath,
+            cwd,
+            service,
+            identityCache,
+            signal,
+        });
+        if (demoted === diagnostics) {
+            out.push(result);
+            continue;
+        }
+        demotedFiles += 1;
+        demotedDiagnostics += demoted.filter((d, i) => d !== diagnostics[i]).length;
+        out.push({ ...result, diagnostics: demoted });
+    }
+    if (demotedFiles > 0 || budgetExhausted || aborted) {
+        logLatency({
+            type: "phase",
+            phase: "lsp_inferred_project_demote",
+            filePath: cwd,
+            durationMs: Date.now() - startedAt,
+            metadata: {
+                filesConsidered: results.length,
+                filesProbed: identityCache.size,
+                demotedFiles,
+                demotedDiagnostics,
+                budgetExhausted,
+                aborted,
+            },
+        });
+    }
+    return out;
+}

package/node_modules/pi-lens/dist/clients/lsp/jvm-runtime.js

@@ -15,9 +15,11 @@
 import { existsSync, readdirSync } from "node:fs";
 import os from "node:os";
 import path from "node:path";
+import { classifyProbeFailure, createAvailabilityLatch, logAvailabilityDecision, startHostStallSampler, } from "../dispatch/runners/utils/availability-policy.js";
 import { getGlobalPiLensDir } from "../file-utils.js";
-import { isCommandAvailableAsync } from "../safe-spawn.js";
+import { safeSpawnAsync } from "../safe-spawn.js";
 const JAVA_EXE = process.platform === "win32" ? "java.exe" : "java";
+const JAVA_PROBE_TIMEOUT_MS = 5_000;
 /** jdtls requires a JDK ≥ 17 to run; recent builds prefer 21. */
 const MIN_JAVA_MAJOR = 17;
 /**
@@ -124,35 +126,165 @@ export function discoverJdkHome(roots = candidateRoots(), javaHome = process.env
     return usable[0].home;
 }
 let _cachedEnv;
+/**
+ * Availability latch for the `java` PATH probe (#1538, the #1467 latch family's
+ * benign-direction sibling). A stalled probe is not evidence the tool is
+ * missing — only a genuine "not found" (or a genuinely resolvable `java`) is a
+ * durable fact worth caching for the session. A transient verdict (timeout,
+ * abort, host stall) expires on the shared cooldown and is re-probed on the
+ * next demand instead of pinning whatever `JAVA_HOME` happened to be ambient.
+ */
+const javaAvailabilityLatch = createAvailabilityLatch();
+/**
+ * Shared spawn while a probe is in flight (#1538 follow-up). Without this, two
+ * concurrent `resolveJavaRuntimeEnv` calls — e.g. a multi-root Java project
+ * spawning jdtls per root — each fire their own 5 s `where`/`which java`, and
+ * every expired cooldown reopens that window for the process's whole
+ * lifetime, not just at startup.
+ */
+let inFlightJavaProbe = null;
 export function _resetJvmRuntimeCacheForTests() {
     _cachedEnv = undefined;
+    javaAvailabilityLatch.reset();
+    inFlightJavaProbe = null;
+}
+/**
+ * Probe `java` on PATH, distinguishing a durable verdict (found, or genuinely
+ * absent) from a transient probe failure. Returns `true`/`false` for a durable
+ * verdict; `undefined` when the probe was transient — including a memo served
+ * from mid-cooldown — so the caller must not treat this call as proof `java`
+ * is absent.
+ *
+ * `AvailabilityLatch.read()` returns `false` (not `null`) for BOTH a durable
+ * "not found" AND a transient verdict whose cooldown hasn't expired yet — the
+ * latch's own contract is "cache a safe fallback answer for this call", not
+ * "this is durable". Blindly forwarding that `false` as durable is exactly
+ * the #1538 bug moved one call deeper: jdtls's failed-spawn retry
+ * (`BROKEN_BASE_COOLDOWN_MS`, `clients/lsp/index.ts`) re-enters
+ * `resolveJavaRuntimeEnv` ~15-20 s later — inside this probe's 30 s transient
+ * cooldown — so the very first retry after a stall would otherwise still
+ * launder into the permanent `_cachedEnv`. Only `javaAvailabilityLatch`'s own
+ * `outcome` distinguishes the two; a durable verdict is never `"transient"`.
+ */
+function probeJavaOnPath() {
+    const memo = javaAvailabilityLatch.read();
+    if (memo !== null) {
+        if (javaAvailabilityLatch.getOutcome() === "transient") {
+            // Served from the memo, but the cooldown from the earlier stall
+            // hasn't expired — this is NOT a durable verdict. Log it (otherwise
+            // this state leaves zero record in latency.log) and surface
+            // `undefined` so the caller never writes the session cache.
+            logAvailabilityDecision({
+                tool: "java",
+                verdict: "unavailable",
+                outcome: "transient",
+                cause: javaAvailabilityLatch.getCause() ?? "probe-timeout",
+                elapsedMs: 0,
+                latched: false,
+                retryAfterMs: Math.max(0, javaAvailabilityLatch.getRetryAtMs() - Date.now()),
+                budgetMs: JAVA_PROBE_TIMEOUT_MS,
+            });
+            return Promise.resolve(undefined);
+        }
+        return Promise.resolve(memo);
+    }
+    if (inFlightJavaProbe)
+        return inFlightJavaProbe;
+    inFlightJavaProbe = runJavaProbe().finally(() => {
+        inFlightJavaProbe = null;
+    });
+    return inFlightJavaProbe;
+}
+/** The actual `where`/`which java` spawn + classification. Never call this
+ * directly — go through `probeJavaOnPath()`, which memoizes and dedupes it. */
+async function runJavaProbe() {
+    const finder = process.platform === "win32" ? "where" : "which";
+    const startedAt = Date.now();
+    const sampler = startHostStallSampler();
+    let result;
+    let hostStallMs;
+    try {
+        result = await safeSpawnAsync(finder, ["java"], {
+            timeout: JAVA_PROBE_TIMEOUT_MS,
+        });
+    }
+    finally {
+        hostStallMs = sampler.stop();
+    }
+    const elapsedMs = Date.now() - startedAt;
+    if (result.status === 0 && !result.error) {
+        javaAvailabilityLatch.noteAvailable();
+        logAvailabilityDecision({
+            tool: "java",
+            verdict: "available",
+            outcome: "success",
+            cause: "ok",
+            elapsedMs,
+            latched: true,
+            hostStallMs,
+            budgetMs: JAVA_PROBE_TIMEOUT_MS,
+        });
+        return true;
+    }
+    // A `where`/`which` that ran fine and found nothing is a genuine absence,
+    // same as a pre-existing #1496/#1467 sibling; anything else (timeout,
+    // abort, host stall) is transient and must not latch.
+    const { outcome, cause } = classifyProbeFailure(result, {
+        hostStallMs,
+        unclassifiedFailureOutcome: "missing",
+    });
+    const retryAfterMs = javaAvailabilityLatch.noteUnavailable(outcome, cause);
+    logAvailabilityDecision({
+        tool: "java",
+        verdict: "unavailable",
+        outcome,
+        cause,
+        elapsedMs,
+        latched: outcome !== "transient",
+        hostStallMs,
+        ...(retryAfterMs > 0 && { retryAfterMs }),
+        budgetMs: JAVA_PROBE_TIMEOUT_MS,
+    });
+    return outcome === "transient" ? undefined : false;
 }
 /**
  * Spawn-env overlay that makes a JVM-gated server (jdtls) launch when `java`
  * isn't on PATH. Returns undefined when `java` is already resolvable (respect
  * the user's PATH java) or when no JDK can be discovered (fail as before).
- * Memoized per process — discovery is filesystem-only but stable for a session.
+ *
+ * Memoized per process — but only once the verdict is durable. A JDK found by
+ * filesystem discovery is always safe to cache immediately: `discoverJdkHome`
+ * is pure stat/readdir, unaffected by the PATH probe's timing. When no JDK is
+ * discovered AND the PATH probe was transient, nothing is cached — the next
+ * call re-probes (respecting the latch's own cooldown) instead of pinning a
+ * "no override" verdict that a stalled probe never earned (#1538).
  */
 export async function resolveJavaRuntimeEnv() {
     if (_cachedEnv)
         return _cachedEnv.value;
     // `java` already on PATH — nothing to inject; defer to the user's runtime.
-    if (await isCommandAvailableAsync("java")) {
+    const javaOnPath = await probeJavaOnPath();
+    if (javaOnPath === true) {
         _cachedEnv = { value: undefined };
         return undefined;
     }
     const home = discoverJdkHome();
-    if (!home) {
+    if (home) {
+        const binDir = path.join(home, "bin");
+        const currentPath = process.env.PATH ?? process.env.Path ?? "";
+        _cachedEnv = {
+            value: {
+                JAVA_HOME: home,
+                PATH: binDir + path.delimiter + currentPath,
+            },
+        };
+        return _cachedEnv.value;
+    }
+    // No JDK discovered. Cache "no override" only when the PATH probe gave a
+    // durable "not found" — a transient probe (timeout/host-stall) must not
+    // pin this session to `undefined` forever.
+    if (javaOnPath === false) {
         _cachedEnv = { value: undefined };
-        return undefined;
     }
-    const binDir = path.join(home, "bin");
-    const currentPath = process.env.PATH ?? process.env.Path ?? "";
-    _cachedEnv = {
-        value: {
-            JAVA_HOME: home,
-            PATH: binDir + path.delimiter + currentPath,
-        },
-    };
-    return _cachedEnv.value;
+    return undefined;
 }

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

@@ -1,10 +1,16 @@
 import path from "node:path";
+import { getLanguageId as getKindLanguageId, KIND_EXTENSIONS, SPECIAL_FILENAMES, } from "../file-kinds.js";
+import { getLspCapableKinds } from "../language-policy.js";
 /**
  * Language ID Mappings for LSP
  *
  * Maps file extensions to LSP language identifiers.
  */
-export const LANGUAGE_EXTENSIONS = {
+// Hand-curated ids, finer-grained than the per-kind registry id: one FileKind
+// can span several language ids (jsts covers typescript/typescriptreact/vue,
+// cxx covers c and cpp), and some servers want a spelling the registry doesn't
+// use ("shellscript", not "shell"). These win over the derived fill-in below.
+const CURATED_LANGUAGE_EXTENSIONS = {
     // JavaScript/TypeScript
     ".ts": "typescript",
     ".tsx": "typescriptreact",
@@ -66,7 +72,6 @@ export const LANGUAGE_EXTENSIONS = {
     ".fish": "fish",
     // CMake
     ".cmake": "cmake",
-    "CMakeLists.txt": "cmake",
     // JSON/YAML
     ".json": "json",
     ".jsonc": "jsonc",
@@ -87,7 +92,6 @@ export const LANGUAGE_EXTENSIONS = {
     ".sql": "sql",
     // Docker
     ".dockerfile": "dockerfile",
-    "Dockerfile": "dockerfile",
     // Terraform
     ".tf": "terraform",
     ".tfvars": "terraform",
@@ -157,6 +161,44 @@ export const LANGUAGE_EXTENSIONS = {
     ".typ": "typst",
     ".typc": "typst",
 };
+/**
+ * Curated ids plus a derived fill-in for every extension an lspCapable kind
+ * registers. Before #1545 this table was hand-maintained alone and had drifted:
+ * powershell had no entry at all and cxx covered a third of its extensions, so
+ * `didOpen` announced those files as "plaintext". Tolerance for that varies by
+ * server — json/yaml/clangd answer the same either way, a DocumentSelector
+ * server may not handle the document at all — so the id is sent correctly
+ * rather than relied on being ignored. A newly registered language now reaches
+ * this seam by being lspCapable.
+ */
+export const LANGUAGE_EXTENSIONS = (() => {
+    const map = { ...CURATED_LANGUAGE_EXTENSIONS };
+    for (const kind of getLspCapableKinds()) {
+        for (const extension of KIND_EXTENSIONS[kind]) {
+            map[extension] ??= getKindLanguageId(kind);
+        }
+    }
+    return map;
+})();
+/**
+ * file-kinds.ts's basename classifier (Makefile, Dockerfile.<suffix>,
+ * CMakeLists.txt, …) matches by regex, not literal filename, so it can't be
+ * flattened into LANGUAGE_EXTENSIONS' literal-key map. Derived from
+ * SPECIAL_FILENAMES — the same single source of truth detectFileKind() uses —
+ * filtered to lspCapable kinds so a basename pattern that classifies into an
+ * lspCapable kind always resolves a language id here too (#1594).
+ */
+const BASENAME_LANGUAGE_PATTERNS = (() => {
+    const lspCapableKinds = new Set(getLspCapableKinds());
+    return SPECIAL_FILENAMES.filter(({ kind }) => lspCapableKinds.has(kind)).map(({ pattern, kind }) => ({
+        pattern,
+        languageId: getKindLanguageId(kind),
+    }));
+})();
+function getBasenameLanguageId(base) {
+    return BASENAME_LANGUAGE_PATTERNS.find(({ pattern }) => pattern.test(base))
+        ?.languageId;
+}
 /**
  * Get language ID for a file path
  */
@@ -166,7 +208,9 @@ export function getLanguageId(filePath) {
         return LANGUAGE_EXTENSIONS[ext];
     }
     const base = path.basename(filePath);
-    return LANGUAGE_EXTENSIONS[base] ?? LANGUAGE_EXTENSIONS[base.toLowerCase()];
+    return (LANGUAGE_EXTENSIONS[base] ??
+        LANGUAGE_EXTENSIONS[base.toLowerCase()] ??
+        getBasenameLanguageId(base));
 }
 /**
  * Get all extensions for a language ID