@yagni-app/code-staging 1.1.9-staging.1490.1 → 1.2.0-staging.1504.1

package/dist/extension/condensedTools.d.ts

@@ -35,10 +35,6 @@ export declare const DIFF_PREVIEW_LINES = 12;
 export declare const ERROR_TAIL_LINES = 5;
 /** Output tail lines shown under a still-running shell command. */
 export declare const PARTIAL_TAIL_LINES = 3;
-/** Left/right margin for self-rendered rows, matching pi's `outputPad` (1) so
- * tool rows align with prose. Self-render rows bypass pi's pad (renderShell
- * "self" → unpadded container), so we reapply it here. */
-export declare const OUTPUT_PAD = 1;
 declare const BUILTIN_NAMES: readonly ["read", "bash", "edit", "write", "grep", "find", "ls"];
 type BuiltinName = (typeof BUILTIN_NAMES)[number];
 export type RowStatus = "running" | "ok" | "error";

package/dist/extension/condensedTools.js

@@ -32,7 +32,7 @@ import { logEvent } from "./errorSink.js";
 import { EXIT_STATUS_LINE_RE, interpretCommandResult, lastSegmentBaseCommand, splitExitStatusError } from "./bashSemantics.js";
 import { isSandboxDenialOutput } from "./sandbox/bash.js";
 import { ReadStateTracker, READ_FIRST_ERROR, readIsPartial, readTextOf, STALE_ERROR } from "./fileGuards.js";
-import { isQuiet, kindForTool, ToolRunTracker } from "./toolRuns.js";
+import { EXPAND_HINT, isQuiet, kindForTool, OUTPUT_PAD, ToolRunTracker } from "./toolRuns.js";
 /** Lines of write content shown collapsed (mirrors Claude Code's preview). */
 export const WRITE_PREVIEW_LINES = 8;
 /** Visual lines of a diff shown collapsed. */
@@ -45,10 +45,6 @@ export const PARTIAL_TAIL_LINES = 3;
 const EXPANDED_MAX_LINES = 1000;
 /** Title arg preview width. */
 const ARG_PREVIEW_MAX = 96;
-/** Left/right margin for self-rendered rows, matching pi's `outputPad` (1) so
- * tool rows align with prose. Self-render rows bypass pi's pad (renderShell
- * "self" → unpadded container), so we reapply it here. */
-export const OUTPUT_PAD = 1;
 const BUILTIN_NAMES = ["read", "bash", "edit", "write", "grep", "find", "ls"];
 const TITLE_BY_NAME = {
     read: "Read",
@@ -195,7 +191,6 @@ function countPatchRemovals(patch) {
     }
     return removed;
 }
-const EXPAND_HINT = "(ctrl+o to expand)";
 /**
  * `⎿ Wrote N lines to path` + a numbered, syntax-highlighted preview.
  * `highlight` is injectable so tests stay independent of pi's theme state.

package/dist/extension/mcp/panel.d.ts

@@ -27,7 +27,7 @@ export interface PanelDeps {
     hasUI: boolean;
 }
 /** Wire the /mcp command + subcommands. */
-export declare function registerMcpPanel(pi: ExtensionAPI, manager: McpManager, configErrors: () => string[]): void;
+export declare function registerMcpPanel(pi: ExtensionAPI, manager: McpManager, configErrors: () => string[], env?: NodeJS.ProcessEnv): void;
 /** Read the persisted disabled list for a repo root (exported for tests). */
 export declare function readDisabledServers(repoRoot: string): string[];
 //# sourceMappingURL=panel.d.ts.map

package/dist/extension/mcp/panel.js

@@ -67,7 +67,7 @@ export function renderPanelListing(servers, errors) {
     return lines.join("\n");
 }
 /** Wire the /mcp command + subcommands. */
-export function registerMcpPanel(pi, manager, configErrors) {
+export function registerMcpPanel(pi, manager, configErrors, env = process.env) {
     const repoRoot = () => resolveProjectRoot(deps.cwd);
     let deps = { cwd: process.cwd(), hasUI: true };
     const persistDisabled = (name, disabled) => {
@@ -88,7 +88,7 @@ export function registerMcpPanel(pi, manager, configErrors) {
     const refreshForServer = async (serverName) => {
         const server = manager.get(serverName);
         if (server?.client) {
-            await registerServerTools(pi, manager, serverName);
+            await registerServerTools(pi, manager, serverName, env);
             await registerServerPrompts(pi, manager, serverName);
         }
     };

package/dist/extension/mcp/render.d.ts

@@ -0,0 +1,45 @@
+/**
+ * Condensed transcript rows for MCP tools (YAG-765).
+ *
+ * pi renders a tool without `renderCall`/`renderResult` as a bare bold name
+ * over the ENTIRE result text, so one Datadog span query dumped kilobytes of
+ * `<METADATA>` and JSON into the transcript. These builders give every MCP
+ * tool the same shape as the built-ins in condensedTools.ts: a one-line
+ * `● server: tool(args)` title, a three-line preview under `⎿` with a
+ * "+N lines · size (ctrl+o to expand)" hint, and the full output only when
+ * the transcript is expanded. The model still receives the full result; only
+ * the transcript is quiet.
+ *
+ * Pure over {@link RenderTheme} (no pi imports) so tests run on plain text;
+ * the pi wiring lives in tools.ts.
+ */
+import type { RenderTheme } from "../subagentRender.js";
+/** Non-empty output lines shown collapsed. */
+export declare const MCP_PREVIEW_LINES = 3;
+/** Width each collapsed preview line is clipped to. */
+export declare const MCP_PREVIEW_WIDTH = 120;
+/** Hard cap on expanded body lines so a huge result cannot stall a repaint. */
+export declare const MCP_EXPANDED_MAX_LINES = 1000;
+/** Output lines kept under a failed call's error line. */
+export declare const MCP_ERROR_TAIL_LINES = 4;
+export type McpRowStatus = "running" | "ok" | "error";
+/** `key: "value", n: 5` — the tool's arguments on one clipped line. */
+export declare function formatMcpArgs(args: unknown, max?: number): string;
+/** `● server: tool(args)` — the row title. */
+export declare function formatMcpTitle(server: string, tool: string, args: unknown, status: McpRowStatus, theme: RenderTheme): string;
+/**
+ * The row body. Collapsed: the first {@link MCP_PREVIEW_LINES} non-empty
+ * lines, each clipped, then a remainder hint carrying the hidden line count,
+ * the byte size, and any image count. Expanded: every line, capped.
+ */
+export declare function formatMcpResultBody(text: string, opts: {
+    expanded: boolean;
+    images: number;
+}, theme: RenderTheme): string[];
+/**
+ * `⎿ error line` + a tail, for a failed call. Collapsed keeps
+ * {@link MCP_ERROR_TAIL_LINES} lines and hints at the rest; expanded shows
+ * every line, capped like a successful result.
+ */
+export declare function formatMcpErrorBody(text: string, expanded: boolean, theme: RenderTheme): string[];
+//# sourceMappingURL=render.d.ts.map

package/dist/extension/mcp/render.js

@@ -0,0 +1,131 @@
+/**
+ * Condensed transcript rows for MCP tools (YAG-765).
+ *
+ * pi renders a tool without `renderCall`/`renderResult` as a bare bold name
+ * over the ENTIRE result text, so one Datadog span query dumped kilobytes of
+ * `<METADATA>` and JSON into the transcript. These builders give every MCP
+ * tool the same shape as the built-ins in condensedTools.ts: a one-line
+ * `● server: tool(args)` title, a three-line preview under `⎿` with a
+ * "+N lines · size (ctrl+o to expand)" hint, and the full output only when
+ * the transcript is expanded. The model still receives the full result; only
+ * the transcript is quiet.
+ *
+ * Pure over {@link RenderTheme} (no pi imports) so tests run on plain text;
+ * the pi wiring lives in tools.ts.
+ */
+import { EXPAND_HINT } from "../toolRuns.js";
+/** Non-empty output lines shown collapsed. */
+export const MCP_PREVIEW_LINES = 3;
+/** Width each collapsed preview line is clipped to. */
+export const MCP_PREVIEW_WIDTH = 120;
+/** Hard cap on expanded body lines so a huge result cannot stall a repaint. */
+export const MCP_EXPANDED_MAX_LINES = 1000;
+/** Output lines kept under a failed call's error line. */
+export const MCP_ERROR_TAIL_LINES = 4;
+/** Title arg preview width. */
+const ARGS_PREVIEW_MAX = 80;
+function clip(text, max) {
+    const collapsed = text.replace(/\s+/g, " ").trim();
+    if (collapsed.length <= max)
+        return collapsed;
+    return `${collapsed.slice(0, max - 1)}…`;
+}
+function formatBytes(bytes) {
+    if (bytes < 1024)
+        return `${bytes} B`;
+    if (bytes < 1024 * 1024)
+        return `${(bytes / 1024).toFixed(1)} KB`;
+    return `${(bytes / (1024 * 1024)).toFixed(1)} MB`;
+}
+function previewValue(value) {
+    if (typeof value === "string")
+        return JSON.stringify(value);
+    if (value === null || typeof value !== "object")
+        return String(value);
+    try {
+        return JSON.stringify(value);
+    }
+    catch {
+        return Array.isArray(value) ? "[…]" : "{…}";
+    }
+}
+/** `key: "value", n: 5` — the tool's arguments on one clipped line. */
+export function formatMcpArgs(args, max = ARGS_PREVIEW_MAX) {
+    if (!args || typeof args !== "object" || Array.isArray(args))
+        return "";
+    const pairs = Object.entries(args)
+        .filter(([, v]) => v !== undefined)
+        .map(([k, v]) => `${k}: ${previewValue(v)}`);
+    return clip(pairs.join(", "), max);
+}
+function statusDot(status, theme) {
+    if (status === "error")
+        return theme.fg("error", "●");
+    if (status === "running")
+        return theme.fg("accent", "●");
+    return theme.fg("success", "●");
+}
+/** `● server: tool(args)` — the row title. */
+export function formatMcpTitle(server, tool, args, status, theme) {
+    const title = theme.bold(theme.fg("toolTitle", `${server}: ${tool}`));
+    const preview = formatMcpArgs(args);
+    const suffix = preview ? `(${theme.fg("accent", preview)})` : "";
+    return `${statusDot(status, theme)} ${title}${suffix}`;
+}
+function withElbow(lines, theme) {
+    return lines.map((line, i) => (i === 0 ? `  ${theme.fg("muted", "⎿")} ${line}` : `    ${line}`));
+}
+/**
+ * The row body. Collapsed: the first {@link MCP_PREVIEW_LINES} non-empty
+ * lines, each clipped, then a remainder hint carrying the hidden line count,
+ * the byte size, and any image count. Expanded: every line, capped.
+ */
+export function formatMcpResultBody(text, opts, theme) {
+    const trimmed = text.replace(/\n$/, "");
+    if (!trimmed.trim() && opts.images === 0) {
+        return withElbow([theme.fg("dim", "(no text content)")], theme);
+    }
+    if (opts.expanded) {
+        const all = trimmed.split("\n");
+        const shown = all.slice(0, MCP_EXPANDED_MAX_LINES).map((l) => theme.fg("toolOutput", l));
+        if (all.length > MCP_EXPANDED_MAX_LINES) {
+            shown.push(theme.fg("muted", `… +${all.length - MCP_EXPANDED_MAX_LINES} lines`));
+        }
+        return withElbow(shown, theme);
+    }
+    const nonEmpty = trimmed.split("\n").filter((l) => l.trim().length > 0);
+    const shown = nonEmpty.slice(0, MCP_PREVIEW_LINES);
+    const hidden = nonEmpty.length - shown.length;
+    const clipped = shown.some((l) => l.replace(/\s+/g, " ").trim().length > MCP_PREVIEW_WIDTH);
+    const lines = shown.map((l) => theme.fg("toolOutput", clip(l, MCP_PREVIEW_WIDTH)));
+    const facts = [];
+    if (hidden > 0)
+        facts.push(`+${hidden} ${hidden === 1 ? "line" : "lines"} · ${formatBytes(Buffer.byteLength(trimmed, "utf8"))}`);
+    if (opts.images > 0)
+        facts.push(`${opts.images} ${opts.images === 1 ? "image" : "images"}`);
+    if (facts.length > 0 || clipped) {
+        lines.push(theme.fg("muted", `… ${[...facts, EXPAND_HINT].join(" ")}`));
+    }
+    return withElbow(lines, theme);
+}
+/**
+ * `⎿ error line` + a tail, for a failed call. Collapsed keeps
+ * {@link MCP_ERROR_TAIL_LINES} lines and hints at the rest; expanded shows
+ * every line, capped like a successful result.
+ */
+export function formatMcpErrorBody(text, expanded, theme) {
+    const lines = text.split("\n").filter((l) => l.length > 0);
+    if (lines.length === 0)
+        return withElbow([theme.fg("error", "Tool call failed")], theme);
+    const [first, ...rest] = lines;
+    const cap = expanded ? MCP_EXPANDED_MAX_LINES - 1 : MCP_ERROR_TAIL_LINES;
+    const tail = rest.slice(0, cap).map((l) => theme.fg("toolOutput", l));
+    const hidden = rest.length - tail.length;
+    const out = [theme.fg("error", first), ...tail];
+    if (hidden > 0) {
+        const remainder = `… +${hidden} ${hidden === 1 ? "line" : "lines"}`;
+        out.push(theme.fg("muted", expanded ? remainder : `${remainder} ${EXPAND_HINT}`));
+    }
+    return withElbow(out, theme);
+}
+//# sourceMappingURL=render.js.map

package/dist/extension/mcp/startup.js

@@ -54,7 +54,7 @@ export async function startMcp(pi, opts) {
     const repoRoot = resolveProjectRoot(opts.cwd);
     const { servers, errors } = loadMcpServers(opts.cwd, env);
     outcome.configErrors = errors.map((e) => (e.serverName ? `${e.serverName}: ${e.message}` : e.message));
-    registerMcpPanel(pi, outcome.manager, () => outcome.configErrors);
+    registerMcpPanel(pi, outcome.manager, () => outcome.configErrors, env);
     const { state } = readProjectApproval(repoRoot);
     // Claude Code bridge: one line when `~/.claude.json` carries servers,
     // approvals, or claude.ai connectors this install does not have. Computed

package/dist/extension/mcp/tools.js

@@ -9,8 +9,12 @@
  * eagerly per server — a server exposing 100 tools puts 100 tools into every
  * request. No tool-list deferral / ToolSearch in v1.
  */
+import { Container, Text } from "@earendil-works/pi-tui";
+import { isDesktopSurface } from "../surface.js";
+import { OUTPUT_PAD } from "../toolRuns.js";
 import { toolTimeoutFromEnv } from "./manager.js";
 import { buildMcpToolName } from "./names.js";
+import { formatMcpErrorBody, formatMcpResultBody, formatMcpTitle, } from "./render.js";
 export const MAX_MCP_DESCRIPTION_LENGTH = 2048;
 export async function registerServerTools(pi, manager, serverName, env = process.env) {
     const server = manager.get(serverName);
@@ -30,6 +34,10 @@ export async function registerServerTools(pi, manager, serverName, env = process
         return result;
     }
     const toolTimeout = toolTimeoutFromEnv(env);
+    // The built-ins' condition (index.ts): the classic-rows escape hatch and
+    // the desktop surface both keep pi's stock renderers, so a transcript is
+    // never half condensed. (Eval mode never registers MCP tools at all.)
+    const condensedRows = env.YAGNI_CLASSIC_TOOL_ROWS !== "1" && !isDesktopSurface(env);
     const selectedTools = server.config.type === "http" || server.config.type === "sse"
         ? server.config.tools
         : undefined;
@@ -48,6 +56,7 @@ export async function registerServerTools(pi, manager, serverName, env = process
             label: `${serverName}: ${tool.name}`,
             description,
             parameters: schemaFor(tool.inputSchema),
+            ...(condensedRows ? condensedRenderers(serverName, tool.name) : {}),
             async execute(_toolCallId, params) {
                 const active = manager.get(serverName);
                 if (!active?.client) {
@@ -76,6 +85,44 @@ export async function registerServerTools(pi, manager, serverName, env = process
     }
     return result;
 }
+function statusFromFlags(flags) {
+    if (flags.isError)
+        return "error";
+    if (flags.isPartial)
+        return "running";
+    return "ok";
+}
+/**
+ * Condensed transcript rows (YAG-765): a `● server: tool(args)` title plus a
+ * clipped preview collapsed, the full output on ctrl+o. Without these pi
+ * paints the whole result text under a bare tool name. pi passes `isError`
+ * on the render context (a thrown execute becomes an error result), which
+ * is the same signal condensedTools reads for a failed bash.
+ */
+function condensedRenderers(serverName, toolName) {
+    return {
+        renderShell: "self",
+        renderCall(args, theme, context) {
+            const status = statusFromFlags(context);
+            return new Text(formatMcpTitle(serverName, toolName, args, status, theme), OUTPUT_PAD, 0);
+        },
+        renderResult(result, options, theme, context) {
+            if (options.isPartial)
+                return new Container();
+            const content = (result.content ?? []);
+            const text = content
+                .filter((c) => c.type === "text" && typeof c.text === "string")
+                .map((c) => c.text)
+                .join("\n");
+            const images = content.filter((c) => c.type === "image").length;
+            const t = theme;
+            const lines = context.isError
+                ? formatMcpErrorBody(text, options.expanded, t)
+                : formatMcpResultBody(text, { expanded: options.expanded, images }, t);
+            return new Text(lines.join("\n"), OUTPUT_PAD, 0);
+        },
+    };
+}
 export function capDescription(description) {
     return description.length > MAX_MCP_DESCRIPTION_LENGTH
         ? description.slice(0, MAX_MCP_DESCRIPTION_LENGTH - 1) + "…"

package/dist/extension/toolRuns.d.ts

@@ -18,6 +18,12 @@
  * Everything here is PURE (no pi imports) so tests run against plain objects;
  * the pi wiring lives in condensedTools.ts.
  */
+/** Left/right margin for self-rendered rows, matching pi's `outputPad` (1) so
+ * tool rows align with prose. Self-render rows bypass pi's pad (renderShell
+ * "self" → unpadded container), so renderers reapply it. */
+export declare const OUTPUT_PAD = 1;
+/** The remainder hint every condensed row uses. */
+export declare const EXPAND_HINT = "(ctrl+o to expand)";
 /** Aggregation category of one tool row. */
 export type RowKind = "read" | "shell" | "search" | "list" | "write" | "edit";
 /** Facts about one tool row; `quiet` is derived, never stored. */

package/dist/extension/toolRuns.js

@@ -18,6 +18,12 @@
  * Everything here is PURE (no pi imports) so tests run against plain objects;
  * the pi wiring lives in condensedTools.ts.
  */
+/** Left/right margin for self-rendered rows, matching pi's `outputPad` (1) so
+ * tool rows align with prose. Self-render rows bypass pi's pad (renderShell
+ * "self" → unpadded container), so renderers reapply it. */
+export const OUTPUT_PAD = 1;
+/** The remainder hint every condensed row uses. */
+export const EXPAND_HINT = "(ctrl+o to expand)";
 const KIND_BY_TOOL = {
     read: "read",
     bash: "shell",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@yagni-app/code-staging",
-  "version": "1.1.9-staging.1490.1",
+  "version": "1.2.0-staging.1504.1",
   "description": "YAGNI Code: a terminal coding agent that already knows your company. One YAGNI login routes the model and grounds the agent in your team's context.",
   "license": "SEE LICENSE IN LICENSE.md",
   "author": "YAGNI, Inc. <jack@yagni.app> (https://yagni.app)",
@@ -58,5 +58,5 @@
     "turndown": "^7.2.4",
     "typebox": "^1.3.15"
   },
-  "yagniSourceSha": "b5f9bfa8ebbf40c8db5285e440a2dbb4271d9fd5"
+  "yagniSourceSha": "d8eb82a97faca5a9dfc62f1074741cc70a8b1934"
 }