@herbertgao/pi-extensions 2026.10.1 → 2026.10.2

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

@@ -1,270 +0,0 @@
-import * as os from "node:os";
-import { existsSync, readdirSync } from "node:fs";
-import * as path from "node:path";
-import { logExtension } from "./extension-log.js";
-import { isRealGitMarker, isAtOrAboveHomeDir, isUnderDir, isWindowsPath, nameMatchesMarkerGlob, normalizeEphemeralMapKey, } from "./path-utils.js";
-import { getDegradationLedgerGeneration, recordDegradationOnce, } from "./degradation-ledger.js";
-import { createGenerationMap, createGenerationSource, } from "./generation-guard.js";
-import { rootMarkersForFile } from "./language-profile.js";
-export const FORMATTER_MARKERS = {
-    biome: ["biome.json", "biome.jsonc", "package.json", ".gitignore"],
-    prettier: [
-        ".prettierrc",
-        ".prettierrc.json",
-        ".prettierrc.yaml",
-        ".prettierrc.yml",
-        ".prettierrc.js",
-        ".prettierrc.cjs",
-        ".prettierrc.mjs",
-        "prettier.config.js",
-        "prettier.config.cjs",
-        "prettier.config.mjs",
-        ".prettierignore",
-        "package.json",
-        ".gitignore",
-    ],
-    ruff: ["pyproject.toml", "ruff.toml", ".ruff.toml", ".gitignore"],
-    black: ["pyproject.toml", "black.toml", ".black", ".gitignore"],
-    "php-cs-fixer": [".php-cs-fixer.php", ".php-cs-fixer.dist.php", ".gitignore"],
-    sqlfluff: [".sqlfluff", "pyproject.toml", "setup.cfg", ".gitignore"],
-    oxfmt: [
-        "oxfmt.toml",
-        ".oxfmtrc.json",
-        "vite-plus.json",
-        "package.json",
-        ".gitignore",
-    ],
-    rustfmt: ["rustfmt.toml", ".rustfmt.toml", "Cargo.toml", ".gitignore"],
-    rubocop: [".rubocop.yml", ".rubocop.yaml", ".gitignore"],
-    standardrb: [".standard.yml", ".standard.yaml", ".gitignore"],
-    "clang-format": [".clang-format", "_clang-format", ".gitignore"],
-    stylua: ["stylua.toml", ".stylua.toml", ".gitignore"],
-    ocamlformat: [".ocamlformat", ".gitignore"],
-    "google-java-format": [".google-java-format", ".editorconfig", ".gitignore"],
-    cljfmt: [".cljfmt.edn", "cljfmt.edn", ".cljfmt", ".gitignore"],
-    "cmake-format": [
-        ".cmake-format",
-        ".cmake-format.yaml",
-        ".cmake-format.yml",
-        ".cmake-format.json",
-        ".cmake-format.py",
-        "cmake-format.yaml",
-        "cmake-format.yml",
-        ".editorconfig",
-        ".gitignore",
-    ],
-    "psscriptanalyzer-format": [
-        "PSScriptAnalyzerSettings.psd1",
-        "ScriptAnalyzerSettings.psd1",
-        ".gitignore",
-    ],
-    csharpier: [
-        ".csharpierrc",
-        ".csharpierrc.json",
-        ".csharpierrc.yaml",
-        ".csharpierrc.yml",
-        ".gitignore",
-    ],
-    ormolu: [".ormolu", ".gitignore"],
-    taplo: ["taplo.toml", ".taplo.toml", ".gitignore"],
-    terraform: [".terraform.lock.hcl", ".gitignore"],
-    swiftformat: [".swiftformat", ".gitignore"],
-    fantomas: [".fantomasignore", ".editorconfig", ".gitignore"],
-    mix: [".formatter.exs", ".gitignore"],
-    shfmt: [".editorconfig", ".gitignore"],
-    ktlint: [".editorconfig", ".gitignore"],
-    ktfmt: [
-        ".editorconfig",
-        ".ktfmt",
-        ".ktfmt.kts",
-        "build.gradle",
-        "build.gradle.kts",
-        "settings.gradle",
-        "settings.gradle.kts",
-        ".gitignore",
-    ],
-    typstyle: [".gitignore"],
-};
-const toolCwdGeneration = createGenerationSource("tool-cwd");
-const logged = createGenerationMap("tool-cwd-resolution-log");
-/** Pure key seam for resolution-log and runner-advisory identity. */
-export function _toolCwdEphemeralKey(parts) {
-    return parts.map(normalizeEphemeralMapKey).join("\0");
-}
-function syncGeneration() {
-    if (toolCwdGeneration.current() === getDegradationLedgerGeneration())
-        return;
-    logged.clear();
-    while (toolCwdGeneration.current() < getDegradationLedgerGeneration()) {
-        toolCwdGeneration.bump();
-    }
-}
-function walkMarkerRoot(startDir, markers, homeDir) {
-    let current = path.resolve(startDir);
-    for (let depth = 0; depth < 64; depth++) {
-        if (isAtOrAboveHomeDir(current, homeDir))
-            break;
-        for (const marker of markers) {
-            const slash = marker.replace(/\\/g, "/").lastIndexOf("/");
-            const parent = slash >= 0 ? marker.slice(0, slash) : "";
-            const basename = slash >= 0 ? marker.slice(slash + 1) : marker;
-            const target = parent
-                ? path.join(current, ...parent.split("/").filter(Boolean))
-                : current;
-            let found = false;
-            if (basename.includes("*")) {
-                try {
-                    found = readdirSync(target, { withFileTypes: true }).some((entry) => (entry.isFile() || entry.isSymbolicLink()) &&
-                        nameMatchesMarkerGlob(entry.name, basename));
-                }
-                catch {
-                    found = false;
-                }
-            }
-            else {
-                found = existsSync(path.join(target, basename));
-            }
-            if (found)
-                return { root: current, marker };
-        }
-        const parentDir = path.dirname(current);
-        if (parentDir === current)
-            break;
-        current = parentDir;
-    }
-    return { root: null };
-}
-function findMarkerRoot(startDir, markers, homeDir) {
-    syncGeneration();
-    return walkMarkerRoot(startDir, markers, homeDir);
-}
-function markersFor(kind, tool, file, ctx) {
-    if (kind === "lsp")
-        return ctx.rootMarkers ?? [];
-    // #2965: runner fallback uses the language table that also anchors the
-    // dispatch context. A caller-owned table remains an explicit override.
-    if (kind === "runner")
-        return ctx.rootMarkers ?? rootMarkersForFile(file, tool);
-    return FORMATTER_MARKERS[tool] ?? [".gitignore"];
-}
-function emitResolution(kind, tool, cwd, reason) {
-    syncGeneration();
-    const key = _toolCwdEphemeralKey([kind, tool, cwd, reason]);
-    if (logged.current(key) !== 0)
-        return;
-    logged.bump(key);
-    logExtension({
-        subsystem: "tool-cwd",
-        level: "debug",
-        message: `cwd ${kind} ${tool} cwd=${cwd} reason=${reason}`,
-    });
-}
-/**
- * Emit a constant runner advisory once per (tool, resolved root) per session
- * (#2811): the yamllint/stylelint/sqlfluff "no config detected" lines and
- * markdownlint's spawn-timeout cooldown notice logged once PER FILE at error
- * level — 17 lines in one session for one tool. The throttle shares the
- * resolution-log map and its ledger-generation reset, so `session_start`
- * re-arms it like every once-latch in this module. The message rides
- * `ctx.log` at debug level so the dispatch seam stays the one sink for
- * runner lines, with its own filePath/kind metadata.
- */
-export function logRunnerAdvisoryOnce(ctx, tool, root, message) {
-    syncGeneration();
-    const key = _toolCwdEphemeralKey(["runner-advisory", tool, root]);
-    if (logged.current(key) !== 0)
-        return;
-    logged.bump(key);
-    ctx.log(message, "debug");
-}
-/** Resolve every child process cwd/root through one bounded, synchronous seam. */
-export function resolveToolCwd(kind, tool, file, ctx) {
-    const dispatchRoot = path.resolve(ctx.cwd ?? process.cwd());
-    const absoluteFile = path.resolve(file);
-    const fileDir = path.dirname(absoluteFile);
-    const homeDir = ctx.homeDir ?? os.homedir();
-    const insideDispatch = isUnderDir(absoluteFile, dispatchRoot);
-    if (ctx.serverRoot) {
-        const rootPath = isWindowsPath(ctx.serverRoot) ? path.win32 : path;
-        const serverRoot = rootPath.resolve(ctx.serverRoot);
-        if (!ctx.suppressTelemetry)
-            emitResolution(kind, tool, serverRoot, "server-root");
-        return { cwd: serverRoot };
-    }
-    const markers = markersFor(kind, tool, absoluteFile, ctx);
-    const markerResult = markers.length
-        ? findMarkerRoot(fileDir, markers, ctx.allowHomeMarker ? path.parse(homeDir).root : homeDir)
-        : { root: null };
-    const markerRoot = markerResult.root;
-    if (markerRoot &&
-        (insideDispatch ? isUnderDir(markerRoot, dispatchRoot) : true)) {
-        const finalReason = `marker:${markerResult.marker ?? markers[0]}`;
-        if (!ctx.suppressTelemetry)
-            emitResolution(kind, tool, markerRoot, finalReason);
-        return {
-            cwd: markerRoot,
-            ...(markerResult.marker !== undefined
-                ? { marker: markerResult.marker }
-                : {}),
-        };
-    }
-    const memo = ctx.toolCwdMemo;
-    if (memo && memo.gitRoot === undefined) {
-        const gitResult = findMarkerRoot(fileDir, [".git"], homeDir);
-        memo.gitRoot =
-            gitResult.root && isRealGitMarker(path.join(gitResult.root, ".git"))
-                ? gitResult.root
-                : null;
-    }
-    const gitRoot = memo && memo.gitRoot !== undefined
-        ? memo.gitRoot
-        : (() => {
-            const gitResult = findMarkerRoot(fileDir, [".git"], homeDir);
-            return gitResult.root &&
-                isRealGitMarker(path.join(gitResult.root, ".git"))
-                ? gitResult.root
-                : null;
-        })();
-    if (gitRoot && (insideDispatch ? isUnderDir(gitRoot, dispatchRoot) : true)) {
-        if (!ctx.suppressTelemetry)
-            emitResolution(kind, tool, gitRoot, "git-root");
-        return { cwd: gitRoot, marker: ".git" };
-    }
-    if (insideDispatch) {
-        if (kind === "formatter") {
-            if (!ctx.suppressTelemetry)
-                emitResolution(kind, tool, fileDir, "file-dir-fallback");
-            if (!ctx.suppressTelemetry && !isUnderDir(fileDir, homeDir)) {
-                recordDegradationOnce({
-                    kind: "tool-cwd-resolution",
-                    subject: tool,
-                    reason: `${kind}:home-cap:${absoluteFile}`,
-                });
-            }
-            return { cwd: fileDir };
-        }
-        if (!ctx.suppressTelemetry)
-            emitResolution(kind, tool, dispatchRoot, "dispatch-root");
-        return { cwd: dispatchRoot };
-    }
-    const reason = isUnderDir(fileDir, homeDir)
-        ? "file-dir-fallback"
-        : "home-cap";
-    const fallback = isUnderDir(fileDir, homeDir) ? fileDir : homeDir;
-    if (!ctx.suppressTelemetry)
-        recordDegradationOnce({
-            kind: "tool-cwd-resolution",
-            subject: tool,
-            reason: `${kind}:${reason}:${absoluteFile}`,
-        });
-    if (!ctx.suppressTelemetry)
-        emitResolution(kind, tool, fallback, reason);
-    return { cwd: fallback };
-}
-/** Runner-shaped adapter kept at the same seam for every runner consumer. */
-export function resolveRunnerCwd(ctx, tool) {
-    return resolveToolCwd("runner", tool, ctx.filePath, ctx).cwd;
-}
-export function resolveRunnerCwdWithReason(ctx, tool) {
-    return resolveToolCwd("runner", tool, ctx.filePath, ctx);
-}

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

@@ -1,47 +0,0 @@
-/**
- * THE final registration boundary for a host-facing tool: everything that
- * must be true of a tool definition the instant before `pi.registerTool`
- * sees it. `index.ts` runs every tool it registers — always-active,
- * situational, and the compact-line-wrapped variants — through this one
- * function, so a property added here reaches every tool without a second
- * call site to keep in sync.
- *
- * Two jobs today:
- *  1. metadata the host requires is present (a non-empty description);
- *  2. an in-flight tool call HOLDS the event loop (#2507). pi-lens unrefs the
- *     LSP child, its stdio pipes and several waiting timers so an idle
- *     one-shot process can exit; in a headless child with no other referenced
- *     handle that let Node exit 0 in the middle of `lsp_diagnostics`. Every
- *     tool call therefore takes a counted hold for its own duration — see
- *     `clients/event-loop-hold.ts` for why the hold lives there and not in
- *     the unref itself.
- */
-import { acquireEventLoopHold } from "./event-loop-hold.js";
-export function normalizeToolDefinition(tool) {
-    const name = typeof tool.name === "string" ? tool.name.trim() : "tool";
-    const description = typeof tool.description === "string" && tool.description.trim().length > 0
-        ? tool.description
-        : `Use the ${name} tool.`;
-    const execute = tool.execute;
-    if (typeof execute !== "function") {
-        return { ...tool, description };
-    }
-    const inner = execute;
-    return {
-        ...tool,
-        description,
-        // A plain function, not an arrow: `this` stays whatever the host called
-        // the tool with, so a definition whose `execute` reads `this` keeps
-        // working. The hold is released in `finally`, so a rejected or aborted
-        // call releases exactly like a resolved one.
-        execute: async function (...args) {
-            const release = acquireEventLoopHold(name);
-            try {
-                return await inner.apply(this, args);
-            }
-            finally {
-                release();
-            }
-        },
-    };
-}

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

@@ -1,105 +0,0 @@
-/**
- * Local re-implementation of the host SDK's `isToolCallEventType`.
- *
- * Why this exists instead of importing from `@earendil-works/pi-coding-agent`:
- * pi installs extension dependencies with `npm install --omit=dev`, so the host
- * coding-agent package is NOT present in the extension's `node_modules` at
- * runtime. Importing a *runtime value* from it therefore fails to resolve on a
- * clean install. Pulling it in as a real dependency is worse — it drags a huge
- * transitive tree (LLM provider SDKs) whose deeply nested paths exceed Windows'
- * MAX_PATH, which breaks `git clean -fdx` during `pi update`.
- *
- * 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. **The host union is narrower than the events pi-lens handles.** The host
- *    `ToolResultEvent` declares `toolCallId`/`input`/`content`/`isError`/
- *    `details`/`usage`; pi-lens's local `ToolResultEvent`
- *    (`clients/runtime-tool-result.ts`) declares the subset it reads. It used
- *    to additionally carry `id`/`callId`/`requestId`/`provider`/`model`/
- *    `sessionId`/`session` "for the telemetry-identity path" — #1655 item 2
- *    deleted all seven, because pi's `afterToolCall` builds the event with
- *    exactly `type`/`toolName`/`toolCallId`/`input`/`content`/`details`/
- *    `isError`/`usage` (`dist/core/agent-session.js:243-256`, source
- *    `src/core/agent-session.ts:502-516`), so the branch reading them was dead
- *    code. The standing reason not to narrow is point 3: pi-lens also
- *    synthesizes its OWN `tool_result` payloads (bash-derived writes,
- *    partial-apply) that no host discriminator would admit.
- *
- * 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.
- */
-import { sanitizeCorrelationId } from "./read-guard-logger.js";
-export function isToolCallEventType(toolName, event) {
-    return (!!event &&
-        typeof event === "object" &&
-        event.toolName === toolName);
-}
-/**
- * Resolve a STABLE correlation id shared between a `tool_call` and its
- * paired `tool_result`, checking every field name a host is known to use
- * (#1642 F4) — the SDK declares `toolCallId` (see the file header above for
- * why pi-lens can't import the SDK's own type at runtime), but
- * `read-guard-logger.ts`'s `getReadGuardCorrelationId` already had to widen
- * to `callId`/`requestId`/`id` for hosts that populate one of those instead.
- * Single source of truth for that field list — do not hand-roll a narrower
- * `event.toolCallId` read at a new call site.
- *
- * Deliberately does NOT fall back to a generated id the way
- * `getReadGuardCorrelationId` does: that fallback is minted fresh on EVERY
- * call (a bare per-invocation counter), which is exactly right for grouping
- * one call's own log lines but useless — actively misleading — for
- * correlating two SEPARATE events (a `tool_call` and its `tool_result`)
- * against each other. `undefined` means the host supplies no stable
- * identity at all under any known field; callers decide their own safe
- * default for that case rather than treat a generated id as a match.
- */
-export function resolveToolCallCorrelationId(event) {
-    const value = (event ?? {});
-    for (const candidate of [
-        value.toolCallId,
-        value.callId,
-        value.requestId,
-        // Widest rung, only reached when toolCallId/callId/requestId are all
-        // absent (#1678 item 2): this assumes a host's `id` field identifies
-        // one TOOL CALL. A host that instead populates `id` per MESSAGE (one
-        // id shared by every tool call in that message) would cross two
-        // parallel calls in the same turn under the same id. Stated plainly:
-        // real pi builds `tool_call`/`tool_result` events with exactly
-        // `toolCallId` and no bare `id` field at all (see the file header
-        // above, #1655 item 2, `src/core/agent-session.ts:502-516`), so this
-        // rung is dead code against today's host — kept only in case a
-        // different host shape needs it; drop it once #1655's audit confirms
-        // none does.
-        value.id,
-    ]) {
-        const sanitized = sanitizeCorrelationId(candidate);
-        if (sanitized)
-            return sanitized;
-    }
-    return undefined;
-}