@herbertgao/pi-extensions 2026.8.3 → 2026.8.5

package/node_modules/pi-lens/dist/clients/source-walker.js

@@ -31,6 +31,7 @@ import * as fs from "node:fs";
 import * as path from "node:path";
 import { isExcludedDirName } from "./file-utils.js";
 import { isGeneratedArtifactDirectoryName } from "./generated-artifacts.js";
+import { createDeadline, yieldIfOverBudget, } from "./cooperative-budget.js";
 /**
  * Read a directory's entries, returning `[]` for a permission-denied or
  * missing directory instead of throwing. Shared by every walker below — a
@@ -46,12 +47,46 @@ export function readDirEntriesSafe(dirPath) {
         return [];
     }
 }
+/**
+ * Async twin of {@link readDirEntriesSafe} (refs #1137) — the identical
+ * "unreadable directory yields no entries" contract, but the read itself
+ * happens off the event loop via `fs.promises.readdir`.
+ *
+ * Why this exists: chunked yielding is NOT sufficient to keep the loop free.
+ * `walkTreeStackAsync` already `setImmediate`-yielded every N entries, yet each
+ * per-directory read was still `readdirSync` — so on a cloud-backed tree
+ * (OneDrive, network drive) one stalled directory read blocked the Node loop,
+ * and pi's TUI, for the *entire* stall regardless of yield cadence. That is the
+ * exact shape #1170 already fixed in `pipeline.ts`'s autofix snapshot walk
+ * ("the walk was already async + chunk-yielding, but each synchronous per-dir
+ * read still blocked on a cloud stall"); #1170 deferred the SHARED engine, and
+ * this is that same fix applied here — so every async walker gets it at once.
+ */
+export async function readDirEntriesSafeAsync(dirPath) {
+    try {
+        return await fs.promises.readdir(dirPath, { withFileTypes: true });
+    }
+    catch {
+        return [];
+    }
+}
 /**
  * The one shared "should this directory be walked into" decision. Every
  * caller's own loop still owns *when* to call this (inline recursion vs. a
  * stack) and what to do with the answer.
+ *
+ * `onGeneratedDirSkip` (#1107 phase 2) fires exactly once when — and only
+ * when — the `isGeneratedArtifactDirectoryName` branch is the reason this
+ * directory is pruned, so a caller can count PRUNED DIRECTORIES (one event
+ * per directory, regardless of how many files it contains) without
+ * enumerating the directory's contents — doing that would defeat the whole
+ * point of pruning it. Optional and unused by every caller except
+ * `source-filter.ts`'s `classifyEntry`: the other two `shouldRecurseIntoDir`
+ * callers (`language-profile.ts`, `startup-scan.ts`) always pass
+ * `skipGeneratedArtifactDirs: false`, so this branch — and therefore the
+ * callback — never fires for them.
  */
-export function shouldRecurseIntoDir(entry, fullPath, policy) {
+export function shouldRecurseIntoDir(entry, fullPath, policy, onGeneratedDirSkip) {
     if (isExcludedDirName(entry.name, policy.extraExcludeDirs ?? [])) {
         return false;
     }
@@ -59,6 +94,7 @@ export function shouldRecurseIntoDir(entry, fullPath, policy) {
         return false;
     if (policy.skipGeneratedArtifactDirs === true &&
         isGeneratedArtifactDirectoryName(entry.name)) {
+        onGeneratedDirSkip?.();
         return false;
     }
     if (policy.followSymlinks !== true && entry.isSymbolicLink())
@@ -83,15 +119,24 @@ function* walkTreeStackSteps(rootDir, visit, shouldStop) {
         const dir = stack.pop();
         if (dir === undefined)
             continue;
+        // Directory-read REQUEST (#1137): the generator never reads the
+        // filesystem itself — it yields the directory path and the driver
+        // supplies the entries. That is what lets the sync driver stay
+        // `readdirSync` while the async driver reads via `fs.promises.readdir`
+        // WITHOUT forking the traversal into two implementations that can
+        // drift (the invariant this generator exists to protect).
+        const entries = (yield dir) ?? [];
         const subDirs = [];
-        for (const entry of readDirEntriesSafe(dir)) {
+        for (const entry of entries) {
             const fullPath = path.join(dir, entry.name);
             const disposition = visit(entry, fullPath);
             if (disposition === "stop")
                 return true;
             if (disposition === "recurse")
                 subDirs.push(fullPath);
-            yield;
+            // Per-entry yield point: `undefined` distinguishes it from a
+            // directory-read request above.
+            yield undefined;
         }
         for (let i = subDirs.length - 1; i >= 0; i--)
             stack.push(subDirs[i]);
@@ -106,27 +151,38 @@ function* walkTreeStackSteps(rootDir, visit, shouldStop) {
 export function walkTreeStackSync(rootDir, visit, opts = {}) {
     const steps = walkTreeStackSteps(rootDir, visit, opts.shouldStop);
     let step = steps.next();
-    while (!step.done)
-        step = steps.next();
+    while (!step.done) {
+        step = steps.next(step.value === undefined ? undefined : readDirEntriesSafe(step.value));
+    }
     return step.value;
 }
 /**
  * Async, chunked-yield twin of {@link walkTreeStackSync} — the identical
  * {@link walkTreeStackSteps} traversal, plus a `setImmediate` yield every
- * `yieldEvery` processed entries so a large tree never holds the event loop in
+ * its monotonic budget so a large tree never holds the event loop in
  * one synchronous burst. Returns true iff the visitor stopped the walk via
  * `"stop"`.
+ *
+ * #1137: every per-directory read goes through {@link readDirEntriesSafeAsync},
+ * so the walk is non-blocking on BOTH axes — CPU (the `setImmediate` cadence)
+ * and I/O (the directory read itself). The yield cadence alone never covered
+ * the I/O axis: a stalled cloud-backed `readdirSync` held the loop for the full
+ * stall no matter how often the walk yielded around it.
  */
 export async function walkTreeStackAsync(rootDir, visit, opts) {
     await opts.beforeWalk?.();
     const steps = walkTreeStackSteps(rootDir, visit, opts.shouldStop);
-    let processedSinceYield = 0;
+    const deadline = createDeadline(opts.budgetMs ?? 8);
     let step = steps.next();
     while (!step.done) {
-        if (++processedSinceYield >= opts.yieldEvery) {
-            processedSinceYield = 0;
-            await new Promise((resolve) => setImmediate(resolve));
+        if (step.value !== undefined) {
+            // Directory-read request — satisfy it off the loop. No
+            step = steps.next(await readDirEntriesSafeAsync(step.value));
+            deadline.reset();
+            continue;
         }
+        if (deadline.expired())
+            await yieldIfOverBudget(deadline);
         step = steps.next();
     }
     return step.value;

package/node_modules/pi-lens/dist/clients/startup-scan.js

@@ -8,6 +8,8 @@
  */
 import * as os from "node:os";
 import * as path from "node:path";
+import { BoundedLruCache } from "./bounded-cache.js";
+import { normalizeMapKey } from "./path-utils.js";
 import { lazyEnvNumber } from "./env-utils.js";
 import { getProjectIgnoreMatcher, } from "./file-utils.js";
 import { isAtOrAboveHomeDir } from "./path-utils.js";
@@ -220,15 +222,18 @@ export function countSourceFilesWithinLimit(dir, limit) {
 // depends only on the file tree shape and ignore rules — both of which
 // are also captured by the project snapshot freshness check upstream —
 // in-process memoisation is safe for the duration of a single pi process.
-const startupScanContextCache = new Map();
+const startupScanContextCache = new BoundedLruCache(32);
+function startupScanCacheKey(cwd, options) {
+    return [
+        normalizeMapKey(path.resolve(cwd)),
+        options.homeDir ? normalizeMapKey(path.resolve(options.homeDir)) : "",
+        options.maxSourceFiles ?? "",
+        options.maxScanEntries ?? "",
+    ].join("|");
+}
+export const __testing = { startupScanCacheKey };
 export function resolveStartupScanContext(cwd, options = {}) {
-    const cacheKey = path.resolve(cwd) +
-        "|" +
-        (options.homeDir ?? "") +
-        "|" +
-        (options.maxSourceFiles ?? "") +
-        "|" +
-        (options.maxScanEntries ?? "");
+    const cacheKey = startupScanCacheKey(cwd, options);
     const cached = startupScanContextCache.get(cacheKey);
     if (cached)
         return cached;
@@ -322,7 +327,7 @@ async function walkSourceCountAsync(dir, limit, maxEntries, opts = {}) {
         // ~0.1ms of overhead and a 2k-file project produces ~20 yields, so the
         // total async overhead is well under 5ms while keeping per-burst sync
         // work under 50ms (the perceptual threshold for "instant" keystrokes).
-        yieldEvery: opts.yieldEvery ?? 100,
+        budgetMs: opts.budgetMs ?? 8,
         // #703: prime the tracked-files set ONCE before the walk (not per file)
         // so a tracked file matching a `.gitignore`/global pattern isn't dropped
         // from the startup source-file count. Fail-open: resolves even when git
@@ -338,13 +343,7 @@ export async function countSourceFilesWithinLimitAsync(dir, limit, opts = {}) {
     return (await walkSourceCountAsync(dir, limit, Number.POSITIVE_INFINITY, opts)).count;
 }
 export async function resolveStartupScanContextAsync(cwd, options = {}) {
-    const cacheKey = path.resolve(cwd) +
-        "|" +
-        (options.homeDir ?? "") +
-        "|" +
-        (options.maxSourceFiles ?? "") +
-        "|" +
-        (options.maxScanEntries ?? "");
+    const cacheKey = startupScanCacheKey(cwd, options);
     const cached = startupScanContextCache.get(cacheKey);
     if (cached)
         return cached;

package/node_modules/pi-lens/dist/clients/startup-timing.js

@@ -1,5 +1,5 @@
 import { performance } from "node:perf_hooks";
-import { PI_LENS_EVAL_STARTED_MS } from "./startup-marker.js";
+import { PI_LENS_EVAL_STARTED_MS } from "./console-guard-install.js";
 /**
  * Startup timing for pi-lens.
  *

package/node_modules/pi-lens/dist/clients/test-runner-client.js

@@ -10,6 +10,7 @@
  * Design: File-level targeted testing — only runs tests for the
  * specific file being edited, not the entire suite.
  */
+import { createSubsystemLogger } from "./extension-log.js";
 import * as fs from "node:fs";
 import * as path from "node:path";
 import { minimatch } from "./deps/minimatch.js";
@@ -64,7 +65,7 @@ const MAX_NODE_MODULES_WALK_UP = 5;
 // unbounded walk of the whole tests tree.
 const MAX_PYTEST_RECURSE_DEPTH = 3;
 // --- Runner Detection ---
-const RUNNERS = {
+export const RUNNERS = {
     vitest: {
         configFiles: ["vitest.config.ts", "vitest.config.js", "vitest.config.mjs"],
         command: "npx",
@@ -140,6 +141,11 @@ const RUNNERS = {
     rspec: {
         configFiles: [".rspec", "spec/spec_helper.rb"],
         command: "bundle",
+        // The real binary is "bundle" (the command runs `bundle exec rspec
+        // <file>`), NOT "rspec" — without this, binName defaulted to the
+        // runner key "rspec" and local/global resolution looked for the wrong
+        // binary name (#1098).
+        binName: "bundle",
         args: (testFile, _cwd) => ["exec", "rspec", testFile],
         parseJson: false,
     },
@@ -166,6 +172,26 @@ const RUNNERS = {
         parseJson: false, // mix test's default output is text-based
     },
 };
+/**
+ * Drop the leading arg(s) of a runner's args() that merely NAME the binary
+ * being invoked (the npx-wrapper convention: `npx vitest run …` → once
+ * `vitest` becomes the resolved command itself, the leading "vitest" arg is
+ * redundant). This must NOT strip a real subcommand.
+ *
+ * Two wrapper shapes are recognized:
+ *   - `[binName, ...rest]` (vitest/jest-style: `npx <bin> ...`) → drop 1.
+ *   - `["-m", binName, ...rest]` (pytest-style: `python -m <bin> ...`) → drop 2.
+ * Anything else (cargo's `["test", "--no-fail-fast"]`, go's
+ * `["test", "-run", …]`, rspec's `["exec", "rspec", file]` once binName is
+ * "bundle", etc.) is a real subcommand/argv and is returned unchanged (#1098).
+ */
+export function stripWrapperArgs(binName, args) {
+    if (args[0] === binName)
+        return args.slice(1);
+    if (args[0] === "-m" && args[1] === binName)
+        return args.slice(2);
+    return args;
+}
 // --- Client ---
 export class TestRunnerClient {
     log;
@@ -180,7 +206,7 @@ export class TestRunnerClient {
     vitestTestGlobsCache = new Map();
     constructor(verbose = false) {
         this.log = verbose
-            ? (msg) => console.error(`[test-runner] ${msg}`)
+            ? createSubsystemLogger("test-runner")
             : () => { };
     }
     /**
@@ -1213,8 +1239,12 @@ export class TestRunnerClient {
      * Resolve the executable and args for a runner, preferring a local
      * node_modules/.bin binary over npx to avoid the ~150ms npx startup cost.
      *
-     * When a local binary is used, args()[0] (the runner name that npx needs)
-     * is dropped since it becomes the command itself.
+     * When a resolved binary becomes the command itself, `stripWrapperArgs`
+     * drops ONLY the leading arg(s) that named the wrapped binary — never a
+     * real subcommand (#1098: `cargo test --no-fail-fast` unconditionally lost
+     * `test` here because the old code assumed every runner's args() started
+     * with an npx-style runner-name arg, which only holds for wrapper-style
+     * runners like vitest/jest/pytest).
      */
     async resolveExec(runner, config, testFile, cwd) {
         // PHPUnit has no npx-style automatic local-binary resolution — Composer's
@@ -1232,15 +1262,15 @@ export class TestRunnerClient {
         const suffix = process.platform === "win32" ? ".cmd" : "";
         const localBin = path.join(cwd, "node_modules", ".bin", binName + suffix);
         // A resolved binary (local, or any manager's global bin) becomes the command
-        // itself, so the leading runner-name arg (e.g. "vitest") that npx needs is
-        // dropped from args().
+        // itself, so the leading wrapper-name arg(s) that named it (e.g. "vitest",
+        // or "-m pytest") are stripped from args() — see stripWrapperArgs.
         if (fs.existsSync(localBin)) {
-            return { command: localBin, args: config.args(testFile, cwd).slice(1) };
+            return { command: localBin, args: stripWrapperArgs(binName, config.args(testFile, cwd)) };
         }
         // Any package manager's global bin dir (npm/pnpm/yarn/bun) before npx (#375).
         const globalBin = await findGlobalBinary(binName);
         if (globalBin) {
-            return { command: globalBin, args: config.args(testFile, cwd).slice(1) };
+            return { command: globalBin, args: stripWrapperArgs(binName, config.args(testFile, cwd)) };
         }
         return { command: config.command, args: config.args(testFile, cwd) };
     }

package/node_modules/pi-lens/dist/clients/tool-event.js

@@ -11,6 +11,41 @@
  *
  * The SDK function is a one-line discriminant check, so we inline it and keep
  * every `@earendil-works/pi-coding-agent` import type-only (types compile away).
+ * `tests/host-sdk-type-only.test.ts` pins that invariant.
+ *
+ * ## S6 audit: the per-tool `is*ToolResult` discriminators (#1334)
+ *
+ * The SDK also exports seven `tool_result` discriminators — `isBashToolResult`,
+ * `isReadToolResult`, `isEditToolResult`, `isWriteToolResult`,
+ * `isGrepToolResult`, `isFindToolResult`, `isLsToolResult`. pi-lens does NOT
+ * consolidate onto them, and the reasons are worth recording so the question
+ * isn't relitigated:
+ *
+ * 1. **They are runtime values, not types.** Same `--omit=dev` constraint as
+ *    above — importing them would break on a clean user install. Inlining them
+ *    is the only option, and each one's entire body is verbatim
+ *    `e.toolName === "<name>"` (checked against the pinned SDK's `types.js`).
+ * 2. **`isToolCallEventType` already subsumes all seven.** It is the SDK's own
+ *    generic form of the same check, and it is already inlined below and used
+ *    at pi-lens's `tool_call` sites. Adding seven fixed-name aliases of a
+ *    generic we already have would be indirection, not consolidation.
+ * 3. **The seven cover strictly fewer tools than pi-lens intercepts.** They
+ *    enumerate the built-ins only; pi-lens's `tool_call`/`tool_result` paths
+ *    also key off `lsp_navigation` and pi-lens's own registered tools, which no
+ *    host discriminator names.
+ * 4. **Narrowing to the host union would LOSE fields pi-lens reads.** The host
+ *    `ToolResultEvent` declares `toolCallId`/`input`/`content`/`isError`/
+ *    `details`/`usage`; pi-lens's local `ToolResultEvent`
+ *    (`clients/runtime-tool-result.ts`) additionally carries
+ *    `id`/`callId`/`requestId`/`provider`/`model`/`sessionId`/`session`, which
+ *    the telemetry-identity path reads. A guard that narrowed to
+ *    `EditToolResultEvent` would drop them.
+ *
+ * What IS consolidated is the part that costs nothing: the host's `details`
+ * SHAPES are type-only exports, so `EditToolDetails` & co. are imported as
+ * types rather than re-declared ad hoc. Genuinely pi-lens-specific `details`
+ * payloads (`searchReads`, `piLensPartialApply`) stay hand-declared — no host
+ * type describes them.
  */
 export function isToolCallEventType(toolName, event) {
     return (!!event &&