@herbertgao/pi-extensions 2026.8.4 → 2026.8.6

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

@@ -0,0 +1,155 @@
+/**
+ * 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/node_modules/pi-lens/dist/clients/tool-set-policy.js

@@ -0,0 +1,76 @@
+import { logLatency } from "./latency-logger.js";
+/**
+ * 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 },
+    });
+}

package/node_modules/pi-lens/dist/clients/tree-sitter-cache.js

@@ -11,6 +11,7 @@
  * the Map's first key removes the least-recently-used file, not merely the
  * oldest insertion, and hot per-edit files survive scan traffic (#890).
  */
+import { logTreeSitterDiagnostic } from "./tree-sitter-logger.js";
 import * as crypto from "node:crypto";
 import * as fs from "node:fs";
 import { normalizeFilePath } from "./path-utils.js";
@@ -47,7 +48,11 @@ export class TreeCache {
         this.counterObserver = counterObserver;
         this.treeErrorObserver = treeErrorObserver;
         this.debug = debug
-            ? (msg) => console.error(`[tree-cache] ${msg}`)
+            ? (msg) => logTreeSitterDiagnostic({
+                subsystem: "tree-cache",
+                level: "debug",
+                message: msg,
+            })
             : () => { };
     }
     recordCounter(key, amount = 1) {