@herbertgao/pi-extensions 2026.8.4 → 2026.8.6

package/node_modules/pi-lens/dist/clients/bash-file-access.js

@@ -15,10 +15,8 @@
  */
 import * as nodeFs from "node:fs";
 import * as path from "node:path";
+import { isReadableSourceFile } from "./file-kinds.js";
 import { countFileLines } from "./read-guard-tool-lines.js";
-// Source-ish extensions worth registering. Anchored end-check → linear (no
-// catastrophic backtracking).
-const READABLE_EXT_RE = /\.(?:ts|tsx|js|jsx|mjs|cjs|py|sh|rs|go|cs|java|kt|rb|php|c|cpp|cc|h|hpp|json|jsonc|yaml|yml|toml|md|txt|env|cfg|conf|ini|html|css|scss|less|xml|sql|vue|svelte)$/i;
 function stripQuotes(token) {
     if (token.length >= 2) {
         const first = token[0];
@@ -32,14 +30,123 @@ function stripQuotes(token) {
 function stripAnsi(value) {
     return value.replace(/\x1b\[[0-9;?]*[ -/]*[@-~]/g, "");
 }
-function tokenizeSegment(segment) {
-    const matches = segment.match(/'[^']*'|"(?:[^"\\]|\\.)*"|\S+/g);
-    return matches ?? [];
+export function tokenizeShellCommand(command) {
+    const segments = [];
+    let tokens = [];
+    let word = "";
+    let quote;
+    let escaped = false;
+    let unsupported = false;
+    let atTokenStart = true;
+    const flushWord = () => {
+        if (word)
+            tokens.push(word);
+        word = "";
+        atTokenStart = true;
+    };
+    const flushSegment = () => {
+        flushWord();
+        if (tokens.length > 0 || unsupported)
+            segments.push({ tokens, unsupported });
+        tokens = [];
+        unsupported = false;
+        atTokenStart = true;
+    };
+    for (let i = 0; i < command.length; i++) {
+        const ch = command[i];
+        const next = command[i + 1];
+        if (quote === "single") {
+            if (ch === "'")
+                quote = undefined;
+            else
+                word += ch;
+            continue;
+        }
+        if (quote === "double") {
+            if (escaped) {
+                word += ch;
+                escaped = false;
+            }
+            else if (ch === "\\")
+                escaped = true;
+            else if (ch === '"')
+                quote = undefined;
+            else
+                word += ch;
+            continue;
+        }
+        if (escaped) {
+            // A backslash-newline is a shell line continuation, not part of the
+            // command argument. Keeping the newline here makes a continued git command
+            // visible to command guards.
+            if (ch !== "\n")
+                word += ch;
+            escaped = false;
+            atTokenStart = false;
+            continue;
+        }
+        if (ch === "\\") {
+            // Bash uses backslash as a general escape, but command inputs on
+            // Windows routinely contain native paths (C:\\src\\file.ts). Preserve
+            // backslashes before ordinary path characters while still honoring
+            // shell escapes and line continuations.
+            if (next === "\n" || /[\s\\'\";$|&<>]/.test(next ?? "")) {
+                escaped = true;
+            }
+            else {
+                word += ch;
+                atTokenStart = false;
+            }
+            atTokenStart = false;
+            continue;
+        }
+        if (ch === "'") {
+            quote = "single";
+            atTokenStart = false;
+            continue;
+        }
+        if (ch === '"') {
+            quote = "double";
+            atTokenStart = false;
+            continue;
+        }
+        if (ch === "#" && atTokenStart) {
+            while (i + 1 < command.length && command[i + 1] !== "\n")
+                i++;
+            continue;
+        }
+        if (/\s/.test(ch)) {
+            flushWord();
+            continue;
+        }
+        if (ch === ";" || ch === "\n" || ch === "|" || ch === "&") {
+            flushWord();
+            if (ch === "|" && next === "|")
+                i++;
+            else if (ch === "&" && next === "&")
+                i++;
+            else if (ch === "|" || ch === "&")
+                unsupported = true;
+            flushSegment();
+            continue;
+        }
+        if (ch === "<" || ch === ">") {
+            flushWord();
+            unsupported = true;
+            continue;
+        }
+        word += ch;
+        atTokenStart = false;
+    }
+    if (quote || escaped)
+        unsupported = true;
+    flushSegment();
+    return segments;
 }
 /** Resolve a token to an absolute path if it looks like a source file. */
 function resolveCandidate(token, cwd) {
     const cleaned = stripQuotes(token);
-    if (!cleaned || cleaned.startsWith("-") || !READABLE_EXT_RE.test(cleaned)) {
+    if (!cleaned || cleaned.startsWith("-") || !isReadableSourceFile(cleaned)) {
         return null;
     }
     return path.isAbsolute(cleaned) ? cleaned : path.resolve(cwd, cleaned);
@@ -52,8 +159,67 @@ function parseCountFlag(token) {
     const n = Number.parseInt(digits, 10);
     return Number.isFinite(n) && n > 0 ? n : undefined;
 }
-function splitSegments(command) {
-    return command.split(/&&|\|\||[;|\n]/);
+function commandSegments(command) {
+    return tokenizeShellCommand(command).map((segment) => segment.tokens);
+}
+/** Find redirect targets without treating quoted `>` characters as syntax. */
+function extractRedirectTargets(command) {
+    const targets = [];
+    let quote;
+    let escaped = false;
+    for (let i = 0; i < command.length; i += 1) {
+        const ch = command[i];
+        if (quote === "single") {
+            if (ch === "'")
+                quote = undefined;
+            continue;
+        }
+        if (quote === "double") {
+            if (escaped)
+                escaped = false;
+            else if (ch === "\\")
+                escaped = true;
+            else if (ch === '"')
+                quote = undefined;
+            continue;
+        }
+        if (escaped) {
+            escaped = false;
+            continue;
+        }
+        if (ch === "\\") {
+            escaped = true;
+            continue;
+        }
+        if (ch === "'") {
+            quote = "single";
+            continue;
+        }
+        if (ch === '"') {
+            quote = "double";
+            continue;
+        }
+        if (ch !== ">")
+            continue;
+        while (i + 1 < command.length && /\s/.test(command[i + 1]))
+            i += 1;
+        if (command[i + 1] === ">")
+            i += 1;
+        while (i + 1 < command.length && /\s/.test(command[i + 1]))
+            i += 1;
+        let target = "";
+        for (i += 1; i < command.length; i += 1) {
+            const next = command[i];
+            if (/\s/.test(next) || next === ";" || next === "|" || next === "&") {
+                i -= 1;
+                break;
+            }
+            target += next;
+        }
+        if (target)
+            targets.push(target);
+    }
+    return targets;
 }
 /**
  * Extract the line ranges a bash command explicitly showed the agent.
@@ -93,11 +259,9 @@ export function extractReadPathsFromCommand(command, cwd) {
         seen.add(key);
         spans.push({ filePath: file.abs, offset, limit });
     };
-    for (const rawSegment of splitSegments(command)) {
-        const segment = rawSegment.trim();
-        if (!segment)
+    for (const tokens of commandSegments(command)) {
+        if (tokens.length === 0)
             continue;
-        const tokens = segment.split(/\s+/);
         const verb = path.basename(tokens[0] ?? "");
         const args = tokens.slice(1);
         if (["cat", "bat", "less", "more", "nl"].includes(verb)) {
@@ -247,8 +411,7 @@ function parseGrepLineWithoutFile(line, file) {
 function collectGrepCommandFiles(command, cwd) {
     const files = new Set();
     let hasLineNumberGrep = false;
-    for (const rawSegment of splitSegments(command)) {
-        const tokens = tokenizeSegment(rawSegment.trim());
+    for (const tokens of commandSegments(command)) {
         const verb = path.basename(stripQuotes(tokens[0] ?? ""));
         if (verb !== "grep" && verb !== "egrep" && verb !== "fgrep")
             continue;
@@ -311,15 +474,22 @@ export function extractWrittenPathsFromCommand(command, cwd) {
         if (abs)
             out.add(abs);
     };
-    for (const rawSegment of splitSegments(command)) {
-        const segment = rawSegment.trim();
-        if (!segment)
+    for (const tokens of commandSegments(command)) {
+        if (tokens.length === 0)
+            continue;
+        // Redirect targets are collected by a quote-aware scanner. The shared
+        // tokenizer supplies the normalized command arguments; it deliberately
+        // does not expose shell redirection operators as arguments.
+        for (const target of extractRedirectTargets(command))
+            add(target);
+        // A command may contain multiple segments; only the first pass should
+        // attach redirects, otherwise targets would be duplicated harmlessly but
+        // needlessly rescanned.
+        break;
+    }
+    for (const tokens of commandSegments(command)) {
+        if (tokens.length === 0)
             continue;
-        // Redirect targets: the token after `>` / `>>` (optionally prefixed by a
-        // file descriptor like `2>` or `&>`, with or without a space).
-        for (const m of segment.matchAll(/>>?\s*([^\s>|&]+)/g))
-            add(m[1]);
-        const tokens = segment.split(/\s+/);
         const verb = path.basename(tokens[0] ?? "");
         const args = tokens.slice(1);
         if (verb === "tee" || verb === "touch") {

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

@@ -7,15 +7,38 @@
  * Requires: npm install @biomejs/biome (or npx @biomejs/biome)
  * Docs: https://biomejs.dev/
  */
+import { createSubsystemLogger } from "./extension-log.js";
 import * as fs from "node:fs";
 import * as path from "node:path";
 import { isFileKind } from "./file-kinds.js";
 import { getGlobalPiLensDir } from "./file-utils.js";
 import { findGlobalBinary } from "./package-manager.js";
 import { safeSpawnAsync } from "./safe-spawn.js";
+import { biomeConfigArgs } from "./tool-policy.js";
+import { resolveManagedToolClient, } from "./dispatch/runners/utils/runner-helpers.js";
+import { classifyProbeFailure, createAvailabilityLatch, logAvailabilityDecision, startHostStallSampler, } from "./dispatch/runners/utils/availability-policy.js";
 // --- Client ---
+const PROBE_TIMEOUT_MS = 10_000;
 export class BiomeClient {
-    biomeAvailable = null;
+    /**
+     * Availability memo, backed by the shared transient-aware latch (#1476).
+     *
+     * Biome is the hot-path formatter: before this, ANY probe failure — a
+     * timeout included — collapsed to `{ outcome: "missing" }`, which both
+     * triggered an install and latched `false` for the life of the process. One
+     * slow first format then disabled formatting until restart.
+     */
+    availabilityLatch = createAvailabilityLatch();
+    /** Cause of the last probe, read when the resolution comes back. */
+    lastProbeCause = null;
+    /**
+     * Measurements of the last failed probe, held until the latch decides how
+     * long the verdict lasts. The decision record is emitted after that, so it
+     * can carry `retryAfterMs` — a latch you can see is worth little if the
+     * retry schedule is not greppable beside it (#1474).
+     */
+    lastProbeElapsedMs = 0;
+    lastProbeHostStallMs = 0;
     // Per-cwd cache of the resolved biome binary. Keying by cwd matters in
     // monorepos where different sub-packages each ship their own biome
     // installation; sharing one slot across the whole client would cause
@@ -29,7 +52,7 @@ export class BiomeClient {
     log;
     constructor(verbose = false) {
         this.log = verbose
-            ? (msg) => console.error(`[biome] ${msg}`)
+            ? createSubsystemLogger("biome")
             : () => { };
     }
     /**
@@ -87,7 +110,7 @@ export class BiomeClient {
     }
     async spawnBiomeAsync(args, timeout = 15000, cwd) {
         const { cmd, args: prefix } = await this.getBiomeBinary(cwd);
-        return safeSpawnAsync(cmd, [...prefix, ...args], { timeout });
+        return safeSpawnAsync(cmd, [...prefix, ...args], { timeout, cwd });
     }
     /**
      * Ensure Biome is available, auto-installing if necessary.
@@ -97,10 +120,15 @@ export class BiomeClient {
      * `ensureInFlight` promise so probing/auto-install isn't duplicated.
      * Mirrors the dedupe pattern in `SgRunner` / `KnipClient` /
      * `DependencyChecker`.
+     *
+     * The memo returns `null` when the last verdict was transient and its
+     * cooldown expired, which re-enters the probe: "biome is not installed" is a
+     * fact worth caching, "the probe timed out" is a moment worth retrying.
      */
     async ensureAvailable() {
-        if (this.biomeAvailable !== null)
-            return this.biomeAvailable;
+        const memo = this.availabilityLatch.read();
+        if (memo !== null)
+            return memo;
         if (this.ensureInFlight)
             return this.ensureInFlight;
         this.ensureInFlight = this.doEnsureAvailable();
@@ -111,27 +139,105 @@ export class BiomeClient {
             this.ensureInFlight = null;
         }
     }
-    async doEnsureAvailable() {
-        // Check if already available
-        const result = await this.spawnBiomeAsync(["--version"], 10000);
+    /**
+     * Probe `biome --version` and classify the failure through the shared
+     * policy. Only a durable verdict (`missing` / `non-installable`) may reach
+     * the install branch of `resolveManagedToolClient`; a transient one returns
+     * as `transient`, which that seam passes straight back without installing.
+     */
+    async probeBiome() {
+        // The probe budget is enforced by a HOST-side timer, so a stalled event
+        // loop expires it while the child is still healthy. Measure the stall
+        // that overlapped the window and let the classifier see it (#1467).
+        const sampler = startHostStallSampler();
+        const startedAt = Date.now();
+        let result;
+        let hostStallMs;
+        try {
+            result = await this.spawnBiomeAsync(["--version"], PROBE_TIMEOUT_MS);
+        }
+        finally {
+            hostStallMs = sampler.stop();
+        }
+        const elapsedMs = Date.now() - startedAt;
         if (!result.error && result.status === 0) {
-            this.biomeAvailable = true;
-            return true;
+            this.lastProbeCause = "ok";
+            logAvailabilityDecision({
+                tool: "biome",
+                verdict: "available",
+                outcome: "success",
+                cause: "ok",
+                elapsedMs,
+                latched: true,
+                hostStallMs,
+                budgetMs: PROBE_TIMEOUT_MS,
+            });
+            return { outcome: "success", value: true };
         }
-        // Auto-install via pi-lens installer
-        this.log("Biome not found, attempting auto-install...");
-        const { ensureTool } = await import("./installer/index.js");
-        const installedPath = await ensureTool("biome");
-        if (installedPath) {
-            this.log(`Biome auto-installed: ${installedPath}`);
-            // Set the installed path as the global fallback so every cwd
-            // reaches it after its own per-package lookup misses.
-            this.autoInstalledBinaryPath = installedPath;
-            this.biomeAvailable = true;
+        // `unclassifiedFailureOutcome: "missing"` preserves the pre-#1476
+        // meaning of a plain non-zero exit (npx reporting no biome package):
+        // still "missing", still installable. Only the timeout/abort arm changes.
+        const { outcome, cause } = classifyProbeFailure(result, {
+            hostStallMs,
+            unclassifiedFailureOutcome: "missing",
+        });
+        // `classifyProbeFailure` is typed over the full outcome union but never
+        // returns "success" for a failed probe; narrow it for the seam's type.
+        const failureOutcome = outcome === "success" ? "non-installable" : outcome;
+        this.lastProbeCause = cause;
+        this.lastProbeElapsedMs = elapsedMs;
+        this.lastProbeHostStallMs = hostStallMs;
+        // The record is emitted by `doEnsureAvailable`, once the latch has said how
+        // long this verdict holds.
+        return { outcome: failureOutcome };
+    }
+    async doEnsureAvailable() {
+        const resolved = await resolveManagedToolClient({
+            toolId: "biome",
+            cwd: process.cwd(),
+            probe: () => this.probeBiome(),
+            acceptInstalled: (installedPath) => {
+                this.autoInstalledBinaryPath = installedPath;
+                return true;
+            },
+        });
+        if (resolved.outcome === "success") {
+            this.availabilityLatch.noteAvailable();
+            // The probe itself logs a clean hit. This arm is the other way to
+            // succeed — the install repaired a durable miss — and it needs its own
+            // record, or "biome went missing and came back" reads as silence.
+            if (this.lastProbeCause !== null && this.lastProbeCause !== "ok") {
+                logAvailabilityDecision({
+                    tool: "biome",
+                    verdict: "available",
+                    outcome: "success",
+                    cause: "ok",
+                    elapsedMs: this.lastProbeElapsedMs,
+                    latched: true,
+                    hostStallMs: this.lastProbeHostStallMs,
+                    budgetMs: PROBE_TIMEOUT_MS,
+                });
+            }
             return true;
         }
-        this.log("Biome auto-install failed");
-        this.biomeAvailable = false;
+        // A transient probe expires; a durable verdict is remembered for the
+        // session exactly as before.
+        const cause = this.lastProbeCause ?? "not-found";
+        const retryAfterMs = this.availabilityLatch.noteUnavailable(resolved.outcome, cause);
+        logAvailabilityDecision({
+            tool: "biome",
+            verdict: "unavailable",
+            outcome: resolved.outcome,
+            cause,
+            elapsedMs: this.lastProbeElapsedMs,
+            latched: resolved.outcome !== "transient",
+            hostStallMs: this.lastProbeHostStallMs,
+            ...(retryAfterMs > 0 && { retryAfterMs }),
+            budgetMs: PROBE_TIMEOUT_MS,
+        });
+        if (resolved.outcome === "transient") {
+            this.log("biome availability probe timed out; will retry (not installing)");
+        }
         return false;
     }
     /**
@@ -142,8 +248,10 @@ export class BiomeClient {
     }
     /**
      * Async auto-fix variant for pipeline use (non-blocking spawn).
+     * `cwd` is the dispatch language root (used for config discovery); when
+     * omitted it defaults to the file's directory.
      */
-    async fixFileAsync(filePath) {
+    async fixFileAsync(filePath, cwd) {
         if (!(await this.ensureAvailable())) {
             return {
                 success: false,
@@ -163,7 +271,11 @@ export class BiomeClient {
         }
         try {
             const before = await fs.promises.readFile(absolutePath, "utf-8");
-            const result = await this.spawnBiomeAsync(["lint", "--write", absolutePath], 15000, path.dirname(absolutePath));
+            const configCwd = cwd ?? path.dirname(absolutePath);
+            // Shared config-args seam (#1247): the lint runner consumes the same
+            // builder, so `lint --write` can never drift to biome's default
+            // config when a user config or the package fallback exists.
+            const result = await this.spawnBiomeAsync(["lint", "--write", ...biomeConfigArgs(configCwd), absolutePath], 15000, configCwd);
             if (result.error) {
                 return {
                     success: false,

package/node_modules/pi-lens/dist/clients/bootstrap.js

@@ -1,3 +1,4 @@
+import { logExtension } from "./extension-log.js";
 let bootstrapPromise = null;
 /**
  * A stand-in for an analysis client whose module failed to load (an unresolved
@@ -28,11 +29,19 @@ export function degradedClient() {
  */
 async function logBootstrapFailures(failures) {
     for (const { name, err } of failures) {
-        console.error(`[pi-lens] analyzer "${name}" disabled (degraded mode): ${err?.message ?? String(err)}`);
+        logExtension({
+            subsystem: "bootstrap",
+            message: `analyzer "${name}" disabled (degraded mode): ${err?.message ?? String(err)}`,
+            metadata: { analyzer: name },
+        });
     }
     try {
         const { collectInstallDiagnostics, formatInstallDiagnostics } = await import("./install-diagnostics.js");
-        console.error(formatInstallDiagnostics(collectInstallDiagnostics(), failures[0]?.err));
+        logExtension({
+            subsystem: "bootstrap",
+            message: formatInstallDiagnostics(collectInstallDiagnostics(), failures[0]?.err),
+            metadata: { kind: "install_diagnostics" },
+        });
     }
     catch {
         // the per-analyzer lines above already named the failures

package/node_modules/pi-lens/dist/clients/bounded-cache.js

@@ -0,0 +1,34 @@
+/** Small insertion-ordered LRU used for process-lifetime memo tables. */
+export class BoundedLruCache {
+    maxEntries;
+    entries = new Map();
+    constructor(maxEntries) {
+        this.maxEntries = maxEntries;
+    }
+    get(key) {
+        const value = this.entries.get(key);
+        if (value !== undefined) {
+            this.entries.delete(key);
+            this.entries.set(key, value);
+        }
+        return value;
+    }
+    has(key) { return this.entries.has(key); }
+    set(key, value) {
+        this.entries.delete(key);
+        this.entries.set(key, value);
+        while (this.entries.size > this.maxEntries) {
+            const oldest = this.entries.keys().next().value;
+            if (oldest === undefined)
+                break;
+            this.entries.delete(oldest);
+        }
+    }
+    delete(key) { return this.entries.delete(key); }
+    clear() { this.entries.clear(); }
+    get size() { return this.entries.size; }
+    keys() { return this.entries.keys(); }
+    values() { return this.entries.values(); }
+    entriesArray() { return [...this.entries.entries()]; }
+    [Symbol.iterator]() { return this.entries[Symbol.iterator](); }
+}