pi-lens 4.2.1 → 4.4.0

package/dist/clients/tool-probe.js

@@ -1,53 +0,0 @@
-/**
- * The tool-probe spawn seam (#2894).
- *
- * A sibling of `tool-cwd.ts`: that module owns where a child that READS A
- * PROJECT starts, this one owns the fact that a child which reads no project
- * starts nowhere in particular.
- *
- * It is a module of its own rather than another export on `safe-spawn.ts`
- * deliberately. Every availability test in this repo fakes the process
- * boundary with `vi.mock("clients/safe-spawn.js", … { safeSpawnAsync })`, and
- * a same-module helper would call the module's own unmocked binding — the
- * probe would spawn for real while the test believed it had the boundary. One
- * module hop keeps every existing double production-faithful.
- */
-import { safeSpawnAsync } from "./safe-spawn.js";
-/**
- * Run a tool's own presence/version invocation — `<tool> --version`, `cl`,
- * `go version`, `which <pm>`, `Get-Module -ListAvailable …` — and hand back
- * the raw spawn result for the caller's availability policy to classify.
- *
- * ## The contract: a probe never gets a `cwd`
- *
- * A probe asks whether a binary exists and what it calls itself. The answer
- * does not depend on the directory the child starts in, so this seam passes
- * NONE — the child inherits the host's directory and nothing it reports is
- * read out of a project. That is why the sweep in
- * `tests/clients/dispatch/runners/runner-spawn-cwd-sweep.test.ts` admits ONE
- * cwd-less spawn here instead of the 23 it admitted before: every one of those
- * sites re-decided the same thing in its own words, and 23 sentences a
- * reviewer has to re-read one at a time is how an admission table stops being
- * auditable (#2872 round 3 shipped 127 rows carrying two canned sentences,
- * four of them false where they were read).
- *
- * `cwd` is STRIPPED rather than merely left out of {@link ProbeSpawnOptions}:
- * the type stops an object literal from carrying one, and the destructure
- * below removes one that arrived inside an already-typed options object a
- * caller widened or spread. Both halves are guarded — deleting the
- * destructure changes this call's text, which retires the sweep's admission
- * row, and `tests/clients/probe-and-root-spawn-cwd.test.ts` reds on the
- * smuggled cwd reaching the child. A probe that genuinely needs to
- * run somewhere — `mix credo --version` needs a mix project, `cargo clippy
- * --version` needs a package, `eslint --version` resolves a project-local
- * binary — must call `safeSpawnAsync` directly and be admitted by that sweep
- * on its own reason.
- */
-export async function probeToolAsync(command, args, options) {
-    // Destructured away rather than overwritten with `undefined`: the key is
-    // then genuinely ABSENT from what reaches the spawn, which is both what the
-    // contract says and what `exactOptionalPropertyTypes` wants (a present
-    // `cwd: undefined` is a strictness spike the `tests/config` ratchet counts).
-    const { cwd: _strippedCwd, ...rest } = (options ?? {});
-    return safeSpawnAsync(command, [...args], { ...rest });
-}

package/dist/clients/tool-render.js

@@ -1,156 +0,0 @@
-/**
- * Opt-in compact one-line tool-result rendering (#1327).
- *
- * pi renders a tool call as two rows by default: the tool-name/args row
- * (`renderCall`) and the result row (`renderResult`). Most pi-lens tools
- * already supply a `renderResult` via `tools/render-compact.ts`'s
- * `compactRenderResult` — a collapsed one-line summary (brand-blue) plus the
- * full output when expanded. This module adds a further, OPT-IN layer that
- * collapses those two rows into ONE — `<status glyph> <name> — <summary>` —
- * by reusing each tool's EXISTING collapsed summary text verbatim (never
- * inventing new strings) and re-styling it through semantic `Theme` tokens
- * instead of a fixed color.
- *
- * Applied generically at the registration seam (index.ts's registerTool
- * loop), not as a per-tool copy: `wrapToolForCompactLine` decorates any
- * `ToolDefinition` that already defines `renderResult`; tools without one are
- * returned untouched. Callers gate the whole thing behind the `ui.compactToolLine`
- * flag (`clients/lens-flag-registry.ts`) — when it is off, the ORIGINAL tool
- * array is registered unwrapped, so behavior is byte-identical to today (no
- * `renderCall`/`renderResult` are added or altered).
- *
- * `clients/` intentionally does NOT import `tools/render-compact.ts` (tools/
- * depends on clients/, never the reverse — see AGENTS.md's seam discipline),
- * so `fullTextOf` is duplicated here in miniature rather than inverting that
- * dependency.
- *
- * API limitation vs the issue's ask: `ToolRenderResultOptions` (the type pi
- * hands `renderResult`) exposes only `{ expanded, isPartial }` — no
- * `outputPad`. `outputPad` exists solely on the unrelated `MessageRenderOptions`
- * (custom message renderers, e.g. clients/turn-summary-render.ts), not on the
- * tool-result render path. There is nothing to honor here; the collapsed line
- * still respects the render width via `fitLines` so it never overflows the
- * terminal (#513's crash class).
- */
-import { stripAnsi } from "./sanitize.js";
-import { fitLines } from "./tui-fit.js";
-const EMPTY_COMPONENT = {
-    render: () => [],
-    invalidate: () => { },
-};
-function fullTextOf(result) {
-    return (result.content ?? [])
-        .filter((c) => c.type === "text" && typeof c.text === "string")
-        .map((c) => c.text)
-        .join("\n");
-}
-/**
- * Build the collapsed compact line from a tool's ALREADY-COMPUTED summary
- * text (verbatim reuse — see module doc). `summaryText` is expected in the
- * `<name/hint> — <detail>` shape every pi-lens summarizer already produces
- * (e.g. `lens_diagnostics all — 3 blocking · 3 errors · 2 warnings (1 file)`);
- * when the separator is absent the whole string is styled as one span
- * instead of guessing a split point.
- *
- * Pure and theme-driven: a status glyph (success/error tokens), the name
- * portion (`toolTitle`, bold), and the detail portion (`error`/`toolOutput`)
- * are each styled through semantic `Theme.fg` tokens — never a fixed color.
- */
-export function buildCompactToolLine(summaryText, isError, theme) {
-    const glyph = isError ? theme.fg("error", "✗") : theme.fg("success", "✓");
-    const detailColor = isError ? "error" : "toolOutput";
-    const sepIndex = summaryText.indexOf(" — ");
-    if (sepIndex === -1) {
-        return `${glyph} ${theme.fg(detailColor, summaryText)}`;
-    }
-    const namePart = summaryText.slice(0, sepIndex);
-    const detailPart = summaryText.slice(sepIndex + " — ".length);
-    const styledName = theme.fg("toolTitle", theme.bold(namePart));
-    const styledDash = theme.fg("dim", "—");
-    const styledDetail = theme.fg(detailColor, detailPart);
-    return `${glyph} ${styledName} ${styledDash} ${styledDetail}`;
-}
-/** Render a component at a wide probe width to capture its full text,
- * stripped of ANSI — the collapsed summary is re-styled through this
- * module's own theme tokens rather than carrying over fixed-color escapes
- * (e.g. tools/render-compact.ts's brand-blue). */
-function captureComponentText(component) {
-    try {
-        const lines = component.render(4096);
-        return stripAnsi(lines.join(" ")).trim();
-    }
-    catch {
-        return "";
-    }
-}
-/**
- * Decorate a single tool definition with the opt-in compact-line renderers.
- * Tools with no `renderResult` are returned UNCHANGED (nothing to compact).
- * Call this only when the `ui.compactToolLine` flag is already known to be
- * on — the caller (index.ts) skips the wrap entirely when it is off, which
- * is what keeps the off path byte-identical to today rather than this
- * function branching on a live flag read per render.
- */
-export function wrapToolForCompactLine(tool) {
-    const originalRenderResult = tool.renderResult;
-    if (!originalRenderResult)
-        return tool;
-    const originalRenderCall = tool.renderCall;
-    const renderCall = (args, theme, context) => {
-        // Only blank the call row once a settled (non-partial) result exists —
-        // `renderResult` is about to paint the single combined line. While the
-        // tool is still running/streaming, keep showing the normal call row
-        // (mirrors the host's own createCallFallback) so the UI isn't blank.
-        if (!context.expanded && context.isPartial === false) {
-            return EMPTY_COMPONENT;
-        }
-        if (originalRenderCall)
-            return originalRenderCall(args, theme, context);
-        // Mirrors the host's own createCallFallback exactly: styled `tool.name`
-        // (the registered name, e.g. "lens_diagnostics"), not the display label.
-        const line = theme.fg("toolTitle", theme.bold(tool.name));
-        return {
-            render: (width) => fitLines([line], width),
-            invalidate: () => { },
-        };
-    };
-    const renderResult = (result, options, theme, context) => {
-        if (options.expanded) {
-            return originalRenderResult(result, options, theme, context);
-        }
-        let summaryText;
-        try {
-            // Probe the tool's OWN collapsed renderer to capture its already-built
-            // summary text; `lastComponent` is cleared so the probe never reuses
-            // (and thereby mutates) the real row's retained component.
-            const probeContext = { ...context, lastComponent: undefined };
-            const component = originalRenderResult(result, { ...options, expanded: false }, theme, probeContext);
-            summaryText = captureComponentText(component);
-        }
-        catch {
-            summaryText = "";
-        }
-        const resultLike = result;
-        if (!summaryText) {
-            summaryText = stripAnsi(fullTextOf(resultLike).split("\n")[0] ?? "").trim();
-        }
-        // pi invokes tool renderers with `{ content, details }` -- the failure
-        // bit lives on `context.isError`, not the result (#1341 review). Keep
-        // `result.isError` as a fallback for direct/legacy callers.
-        const contextIsError = context
-            ?.isError;
-        const isError = contextIsError ?? resultLike.isError === true;
-        const line = buildCompactToolLine(summaryText, isError === true, theme);
-        return {
-            render: (width) => fitLines([line], width),
-            invalidate: () => { },
-        };
-    };
-    return { ...tool, renderCall, renderResult };
-}
-/** Wrap every tool in an array — tools without `renderResult` pass through
- * unchanged. Used by index.ts's registerTool loop, only when the
- * `ui.compactToolLine` flag resolved on for this session. */
-export function wrapToolsForCompactLine(tools) {
-    return tools.map((tool) => wrapToolForCompactLine(tool));
-}

package/dist/clients/tool-set-policy.js

@@ -1,118 +0,0 @@
-import { logLatency } from "./latency-logger.js";
-import { BoundedFifoMap } from "./bounded-cache.js";
-import { recordDegradationOnce } from "./degradation-ledger.js";
-// pi re-runs the extension factory for session rebuilds, but imports this
-// module once per process. Keep conversation activation memory here, keyed by
-// pi's session file rather than by a factory closure or process-wide session.
-export const REMEMBERED_LAZY_TOOLS_MAX_SESSIONS = 128;
-const rememberedLazyToolsBySessionFile = new BoundedFifoMap(REMEMBERED_LAZY_TOOLS_MAX_SESSIONS);
-export function rememberLazyTools(sessionFile, names) {
-    if (!sessionFile) {
-        recordDegradationOnce({
-            kind: "tool-set-session-file-unavailable",
-            subject: "activation",
-            reason: "session-file identity unavailable; activation memory is inert",
-        });
-        return;
-    }
-    const remembered = rememberedLazyToolsBySessionFile.get(sessionFile) ?? new Set();
-    for (const name of names)
-        remembered.add(name);
-    rememberedLazyToolsBySessionFile.set(sessionFile, remembered);
-}
-export function getRememberedLazyTools(sessionFile) {
-    return sessionFile
-        ? (rememberedLazyToolsBySessionFile.get(sessionFile) ?? new Set())
-        : new Set();
-}
-export function clearRememberedLazyTools(sessionFile) {
-    if (sessionFile)
-        rememberedLazyToolsBySessionFile.delete(sessionFile);
-}
-export function inheritRememberedLazyTools(parentSessionFile, childSessionFile) {
-    if (!parentSessionFile ||
-        !childSessionFile ||
-        parentSessionFile === childSessionFile)
-        return;
-    const remembered = rememberedLazyToolsBySessionFile.get(parentSessionFile);
-    if (remembered)
-        rememberedLazyToolsBySessionFile.set(childSessionFile, new Set(remembered));
-}
-export function resetRememberedLazyToolsForTests() {
-    rememberedLazyToolsBySessionFile.clear();
-}
-/**
- * Whether the host will send this model deferred (searchable) tool
- * definitions rather than the full inline list.
- *
- * Read the host's own decision off `ctx.model.compat` — pi resolves that
- * flag from the model config (`core/model-config`, `compat.supportsToolReferences`)
- * and it is the only capability signal a consumer can honestly observe.
- * A missing flag means "unknown", which we report as false: this value only
- * annotates the `tool_set_mutation` log line, so guessing high would make the
- * log lie, while guessing low merely under-claims.
- */
-export function supportsDeferredTools(model) {
-    return model?.compat?.supportsToolReferences === true;
-}
-/**
- * A fresh logical conversation — the only reasons that start with an empty
- * activation memory. `undefined` is included because older hosts fire
- * `session_start` with no `reason` at all.
- *
- * Every OTHER reason (fork/reload/resume) is a session REBUILD: the host
- * constructs a brand-new AgentSession with `includeAllExtensionTools: true`
- * (pi `core/agent-session.js`), so every registered pi-lens tool is active
- * again by the time our handler runs, while pi-lens's own extension closure
- * state survives. Those reasons must RESTORE the previous posture, not skip.
- */
-export function isFreshSessionStart(reason) {
-    return reason === undefined || reason === "startup" || reason === "new";
-}
-/**
- * Compute the active-tool set pi-lens wants: everything currently active that
- * is not a lazy tool, plus exactly the lazy tools the model activated in this
- * logical session (`remembered`).
- *
- * On startup/new `remembered` is empty and this is the plain baseline shrink.
- * On fork/reload/resume the host has just re-activated all registered tools,
- * and this restores the parent's posture character-for-character — which both
- * preserves the model's activations and keeps the advertised tool list equal
- * to the one the prompt cache prefix was built from.
- */
-export function planToolSet(active, lazyNames, remembered) {
-    const desired = active.filter(
-    // Lazy tools are dropped here and re-appended below in REMEMBERED
-    // (= activation) order. Keeping them in the host's registration
-    // position would restore the right SET in the wrong ARRAY order, and
-    // the active-tools array is what serializes into the request's tool
-    // block — a transposition is a changed prefix, i.e. a cache miss.
-    (name) => !lazyNames.has(name));
-    // A remembered tool the host did not list as active still belongs in the
-    // set (defensive: the host controls what `getActiveTools` returns).
-    const desiredSet = new Set(desired);
-    for (const name of remembered) {
-        if (!desiredSet.has(name)) {
-            desired.push(name);
-            desiredSet.add(name);
-        }
-    }
-    const activeSet = new Set(active);
-    const removedCount = active.filter((name) => !desiredSet.has(name)).length;
-    const addedCount = desired.filter((name) => !activeSet.has(name)).length;
-    return {
-        desired,
-        addedCount,
-        removedCount,
-        changed: addedCount > 0 || removedCount > 0,
-    };
-}
-export function recordToolSetMutation(mutation) {
-    logLatency({
-        type: "phase",
-        filePath: "<pi-lens>",
-        phase: "tool_set_mutation",
-        durationMs: 0,
-        metadata: { ...mutation },
-    });
-}