@diegopetrucci/pi-extensions 0.1.76 → 0.1.79

package/extensions/quiet-tools/index.ts

@@ -1,53 +1,114 @@
 import { homedir } from "node:os";
 
 import {
-  createBashToolDefinition,
-  createEditToolDefinition,
-  createFindToolDefinition,
-  createGrepToolDefinition,
-  createLsToolDefinition,
-  createReadToolDefinition,
-  createWriteToolDefinition,
   keyHint,
-  SettingsManager,
   type ExtensionAPI,
-  type ToolDefinition as PiToolDefinition,
-  type ToolsOptions,
+  type ToolRendererResolver,
+  type ToolRenderers,
 } from "@earendil-works/pi-coding-agent";
-import { Container, Text, truncateToWidth } from "@earendil-works/pi-tui";
+import { Box, Container, truncateToWidth, visibleWidth } from "@earendil-works/pi-tui";
 
-const QUIET_CALL_TOOL_NAMES = new Set(["bash", "edit", "find", "grep", "ls", "read", "write"]);
+const QUIET_TOOL_NAMES = new Set(["bash", "edit", "find", "grep", "ls", "read", "write"]);
+const MAX_MCP_ARG_LENGTH = 2000;
 
-type ToolDefinition = PiToolDefinition<any, any, any>;
-type ToolRenderCall = NonNullable<ToolDefinition["renderCall"]>;
-type ToolRenderResult = NonNullable<ToolDefinition["renderResult"]>;
+type ToolRenderCall = NonNullable<ToolRenderers["renderCall"]>;
+type ToolRenderResult = NonNullable<ToolRenderers["renderResult"]>;
 type ToolRenderCallParams = Parameters<ToolRenderCall>;
 type ToolRenderResultParams = Parameters<ToolRenderResult>;
-type RenderTheme = ToolRenderResultParams[2];
-type ToolRenderContext = ToolRenderResultParams[3];
-
-type TimerRenderState = {
+type RenderTheme = ToolRenderCallParams[1];
+type ToolRenderContext = ToolRenderCallParams[2];
+type QuietToolRenderContext = ToolRenderContext & {
+  durationMs?: number;
+  outputPad?: number;
+};
+type BashRenderState = {
   startedAt?: number;
   endedAt?: number;
   interval?: ReturnType<typeof setInterval>;
 };
 
+type QuietLinesRenderer = (width: number) => string[];
+
 class QuietLinesRenderComponent extends Container {
-  private linesRenderer: ((width: number) => string[]) | undefined;
+  private linesRenderer: QuietLinesRenderer | undefined;
 
-  setLinesRenderer(linesRenderer: (width: number) => string[]): void {
+  setLinesRenderer(linesRenderer: QuietLinesRenderer): void {
     this.linesRenderer = linesRenderer;
     this.invalidate();
   }
 
-  render(width: number): string[] {
+  protected renderLines(width: number): string[] {
     return this.linesRenderer?.(width).filter((line) => line) ?? [];
   }
+
+  render(width: number): string[] {
+    return this.renderLines(width);
+  }
+}
+
+class QuietCallRenderComponent extends QuietLinesRenderComponent {
+  private frame: Box | undefined;
+  private framePaddingX: number | undefined;
+
+  private readonly frameBody = {
+    render: (width: number) => this.renderLines(width),
+    invalidate: () => {},
+  };
+
+  setNativeFrame(theme: RenderTheme, context: QuietToolRenderContext): void {
+    const outputPad = getOutputPad(context);
+    if (!this.frame || this.framePaddingX !== outputPad) {
+      this.frame = new Box(outputPad, 1);
+      this.framePaddingX = outputPad;
+    }
+
+    const themeWithBackground = theme as RenderTheme & {
+      bg?: (kind: string, text: string) => string;
+    };
+    const backgroundKind = context.isPartial
+      ? "toolPendingBg"
+      : context.isError
+        ? "toolErrorBg"
+        : "toolSuccessBg";
+    const background = themeWithBackground.bg;
+    this.frame.setBgFn(
+      background ? (text) => background.call(themeWithBackground, backgroundKind, text) : undefined,
+    );
+  }
+
+  clearNativeFrame(): void {
+    this.frame = undefined;
+    this.framePaddingX = undefined;
+  }
+
+  render(width: number): string[] {
+    if (!this.frame) return super.render(width);
+
+    this.frame.clear();
+    this.frame.addChild(this.frameBody);
+    return this.frame.render(width);
+  }
+
+  invalidate(): void {
+    super.invalidate();
+    this.frame?.invalidate();
+  }
 }
 
-class QuietCallRenderComponent extends QuietLinesRenderComponent {}
 class QuietResultRenderComponent extends QuietLinesRenderComponent {}
 
+/**
+ * Thrown from a delegating renderCall/renderResult slot when next() did not supply that slot.
+ * Pi's ToolExecutionComponent catches renderer errors and falls back to its native
+ * createCallFallback/createResultFallback, which preserve the host's expanded behavior.
+ */
+class QuietToolsDelegateToDefault extends Error {
+  constructor() {
+    super("quiet-tools: delegate to Pi default renderer");
+    this.name = "QuietToolsDelegateToDefault";
+  }
+}
+
 function sanitizeInlineText(text: string): string {
   return text
     .replace(/\x1b\][^\x07]*(?:\x07|\x1b\\)/g, "")
@@ -195,30 +256,69 @@ function formatQuietCallLine(toolName: string, args: unknown, theme: RenderTheme
   }
 }
 
+function formatMcpCallLine(toolName: string, args: unknown, theme: RenderTheme): string {
+  let argsStr = "";
+  if (args != null) {
+    let raw: string | undefined;
+    try {
+      raw = JSON.stringify(args);
+    } catch {
+      // circular references, BigInt, etc.
+    }
+    if (raw === undefined) {
+      argsStr = "[\u2026]";
+    } else {
+      const capped = raw.length > MAX_MCP_ARG_LENGTH ? raw.slice(0, MAX_MCP_ARG_LENGTH) : raw;
+      argsStr = sanitizeInlineText(capped);
+    }
+  }
+  return `${formatToolTitle(toolName, theme)}${argsStr ? ` ${theme.fg("toolOutput", argsStr)}` : ""}`;
+}
+
 function formatExpandHint(theme: RenderTheme): string {
   return `${theme.fg("muted", "(")}${keyHint("app.tools.expand", "to expand")}${theme.fg("muted", ")")}`;
 }
 
-function markToolTiming(options: ToolRenderResultParams[1], context: ToolRenderContext): void {
-  const state = context.state as TimerRenderState;
+function formatFailedMarker(theme: RenderTheme): string {
+  return theme.fg("error", " [failed]");
+}
 
-  if ((!options.isPartial || context.isError) && state.startedAt !== undefined) {
-    state.endedAt ??= Date.now();
-  }
+function truncateQuietCallLine(line: string, status: string, width: number): string {
+  if (!status) return truncateToWidth(line, width, "...");
+  const statusWidth = visibleWidth(status);
+  if (statusWidth >= width) return truncateToWidth(status, width, "");
+  return `${truncateToWidth(line, width - statusWidth, "...")}${status}`;
+}
+
+function getOutputPad(context: QuietToolRenderContext): number {
+  const outputPad = context.outputPad;
+  if (typeof outputPad !== "number" || !Number.isFinite(outputPad)) return 1;
+  return Math.max(0, Math.floor(outputPad));
+}
 
-  if ((!options.isPartial || context.isError) && state.interval) {
-    clearInterval(state.interval);
-    state.interval = undefined;
+function finishBashTiming(
+  options: ToolRenderResultParams[1],
+  context: QuietToolRenderContext,
+): void {
+  const state = context.state as BashRenderState;
+
+  if (!options.isPartial || context.isError) {
+    state.endedAt ??= Date.now();
+    if (state.interval) {
+      clearInterval(state.interval);
+      state.interval = undefined;
+    }
   }
 }
 
 function renderQuietCollapsedResult(
+  toolName: string,
   _result: ToolRenderResultParams[0],
   options: ToolRenderResultParams[1],
   _theme: RenderTheme,
-  context: ToolRenderContext,
+  context: QuietToolRenderContext,
 ): QuietResultRenderComponent {
-  markToolTiming(options, context);
+  if (toolName === "bash") finishBashTiming(options, context);
   const component =
     context.lastComponent instanceof QuietResultRenderComponent
       ? context.lastComponent
@@ -227,169 +327,136 @@ function renderQuietCollapsedResult(
   return component;
 }
 
-function renderQuietCall(
-  toolName: string,
-  base: ToolDefinition,
+function delegateCall(
+  nextRenderers: ToolRenderers | undefined,
   args: ToolRenderCallParams[0],
-  theme: ToolRenderCallParams[1],
-  context: ToolRenderCallParams[2],
-) {
-  const state = context.state as TimerRenderState;
-  if (context.executionStarted && state.startedAt === undefined) {
-    state.startedAt = Date.now();
-    state.endedAt = undefined;
-  }
-
-  if (context.expanded || !QUIET_CALL_TOOL_NAMES.has(toolName)) {
-    const delegateContext =
-      context.lastComponent instanceof QuietCallRenderComponent
-        ? { ...context, lastComponent: undefined }
-        : context;
-    return (
-      base.renderCall?.(args, theme, delegateContext) ??
-      new Text(theme.fg("toolTitle", theme.bold(toolName)), 0, 0)
-    );
-  }
-
-  const component =
+  theme: RenderTheme,
+  context: ToolRenderContext,
+): ReturnType<ToolRenderCall> {
+  if (!nextRenderers?.renderCall) throw new QuietToolsDelegateToDefault();
+  const delegateContext =
     context.lastComponent instanceof QuietCallRenderComponent
-      ? context.lastComponent
-      : new QuietCallRenderComponent();
-  const line = formatQuietCallLine(toolName, args, theme);
-  const hint = formatExpandHint(theme);
-  component.setLinesRenderer((width) => [
-    truncateToWidth(line, width, "..."),
-    truncateToWidth(hint, width, "..."),
-  ]);
-  return component;
+      ? { ...context, lastComponent: undefined }
+      : context;
+  return nextRenderers.renderCall(args, theme, delegateContext);
+}
+
+function delegateResult(
+  nextRenderers: ToolRenderers | undefined,
+  result: ToolRenderResultParams[0],
+  options: ToolRenderResultParams[1],
+  theme: RenderTheme,
+  context: ToolRenderContext,
+): ReturnType<ToolRenderResult> {
+  if (!nextRenderers?.renderResult) throw new QuietToolsDelegateToDefault();
+  const delegateContext =
+    context.lastComponent instanceof QuietResultRenderComponent
+      ? { ...context, lastComponent: undefined }
+      : context;
+  return nextRenderers.renderResult(result, options, theme, delegateContext);
 }
 
-function createQuietToolDefinition(base: ToolDefinition): ToolDefinition {
-  const baseRenderResult = base.renderResult;
+export function createQuietResolver(): ToolRendererResolver {
+  return (toolName, next) => {
+    const isBuiltin = QUIET_TOOL_NAMES.has(toolName);
+    const isMcp = toolName.startsWith("mcp__");
 
-  return {
-    ...base,
-    renderCall(args, theme, context) {
-      return renderQuietCall(base.name, base, args, theme, context);
-    },
-    renderResult(result, options, theme, context) {
-      if (options.expanded && baseRenderResult) {
-        const delegateContext =
-          context.lastComponent instanceof QuietResultRenderComponent
-            ? { ...context, lastComponent: undefined }
-            : context;
-        return baseRenderResult(result, options, theme, delegateContext);
-      }
+    if (!isBuiltin && !isMcp) return next();
 
-      return renderQuietCollapsedResult(result, options, theme, context);
-    },
-  };
-}
+    const nextRenderers = next();
+    const usesNativeShell = nextRenderers?.renderShell === "self";
 
-function createBaseToolOptions(cwd: string): ToolsOptions | undefined {
-  try {
-    const settings = SettingsManager.create(cwd);
     return {
-      read: { autoResizeImages: settings.getImageAutoResize() },
-      bash: {
-        commandPrefix: settings.getShellCommandPrefix(),
-        shellPath: settings.getShellPath(),
+      renderShell: nextRenderers?.renderShell,
+      renderCall(args, theme, context) {
+        if (context.expanded) return delegateCall(nextRenderers, args, theme, context);
+
+        const quietContext = context as QuietToolRenderContext;
+        if (toolName === "bash") {
+          const state = quietContext.state as BashRenderState;
+          if (quietContext.executionStarted && state.startedAt === undefined) {
+            state.startedAt = Date.now();
+            state.endedAt = undefined;
+          }
+        }
+
+        const component =
+          context.lastComponent instanceof QuietCallRenderComponent
+            ? context.lastComponent
+            : new QuietCallRenderComponent();
+        if (usesNativeShell) component.setNativeFrame(theme, quietContext);
+        else component.clearNativeFrame();
+
+        const line = isBuiltin
+          ? formatQuietCallLine(toolName, args, theme)
+          : formatMcpCallLine(toolName, args, theme);
+        const status = quietContext.isError ? formatFailedMarker(theme) : "";
+        const hint = formatExpandHint(theme);
+        component.setLinesRenderer((width) => [
+          truncateQuietCallLine(line, status, width),
+          truncateToWidth(hint, width, "..."),
+        ]);
+        return component;
+      },
+      renderResult(result, options, theme, context) {
+        if (options.expanded) return delegateResult(nextRenderers, result, options, theme, context);
+        return renderQuietCollapsedResult(
+          toolName,
+          result,
+          options,
+          theme,
+          context as QuietToolRenderContext,
+        );
       },
     };
-  } catch {
-    return undefined;
-  }
-}
-
-function createBaseToolDefinitions(cwd: string): ToolDefinition[] {
-  const options = createBaseToolOptions(cwd);
-  return [
-    createReadToolDefinition(cwd, options?.read),
-    createBashToolDefinition(cwd, options?.bash),
-    createEditToolDefinition(cwd, options?.edit),
-    createWriteToolDefinition(cwd, options?.write),
-    createGrepToolDefinition(cwd, options?.grep),
-    createFindToolDefinition(cwd, options?.find),
-    createLsToolDefinition(cwd, options?.ls),
-  ] as ToolDefinition[];
-}
-
-function createQuietToolDefinitions(cwd: string, enabled: boolean): ToolDefinition[] {
-  const baseDefinitions = createBaseToolDefinitions(cwd);
-  return enabled ? baseDefinitions.map(createQuietToolDefinition) : baseDefinitions;
+  };
 }
 
 export const __testing = {
   sanitizeInlineText,
   formatQuietCallLine,
-  createQuietToolDefinition,
+  formatMcpCallLine,
+  createQuietResolver,
+  QuietCallRenderComponent,
+  QuietResultRenderComponent,
+  QuietToolsDelegateToDefault,
 };
 
+const STATUS_MESSAGE =
+  "Quiet tool previews are always on. Collapsed built-in and MCP tool rows show a one-line invocation and hide output until expanded. Model-visible tool results are unchanged.";
+const FALLBACK_STATUS_MESSAGE =
+  "Quiet tool previews are inactive: this Pi host lacks registerToolRenderer (requires Pi >=1.0.1).";
+const STATUS_USAGE = "Usage: /quiet-tools status";
+
 export default function quietToolsExtension(pi: ExtensionAPI) {
-  let enabled = true;
+  let notifiedFallback = false;
 
-  function registerTools(cwd: string): void {
-    for (const tool of createQuietToolDefinitions(cwd, enabled)) {
-      pi.registerTool(tool);
-    }
-  }
+  const hasRenderer = typeof (pi as any).registerToolRenderer === "function";
+
+  if (hasRenderer) pi.registerToolRenderer(createQuietResolver());
 
   pi.on("session_start", async (_event, ctx) => {
-    registerTools(ctx.cwd);
+    if (!hasRenderer && !notifiedFallback) {
+      notifiedFallback = true;
+      ctx.ui.notify(
+        "quiet-tools needs Pi >=1.0.1 to customise tool renderers. Quiet rendering is inactive.",
+        "warning",
+      );
+    }
   });
 
   pi.registerCommand("quiet-tools", {
-    description: "Toggle one-line collapsed invocations for built-in tool rows",
+    description: "Show always-on one-line collapsed invocations for built-in and MCP tool rows",
     getArgumentCompletions: (prefix) => {
-      const commands = ["on", "off", "toggle", "status"];
       const query = prefix.trim().toLowerCase();
-      const matches = commands.filter((command) => command.startsWith(query));
-      return matches.length > 0 ? matches.map((value) => ({ value, label: value })) : null;
+      return "status".startsWith(query) ? [{ value: "status", label: "status" }] : null;
     },
     handler: async (args, ctx) => {
-      const action = args.trim().toLowerCase() || "toggle";
-
-      if (action === "on" || action === "enable") {
-        enabled = true;
-        registerTools(ctx.cwd);
-        ctx.ui.notify(
-          "Quiet tool previews enabled: collapsed built-in tool rows show a one-line invocation plus an expand hint.",
-          "info",
-        );
+      if (!args.trim() || args.trim().toLowerCase() === "status") {
+        ctx.ui.notify(hasRenderer ? STATUS_MESSAGE : FALLBACK_STATUS_MESSAGE, "info");
         return;
       }
-
-      if (action === "off" || action === "disable") {
-        enabled = false;
-        registerTools(ctx.cwd);
-        ctx.ui.notify(
-          "Quiet tool previews disabled: restored pi's standard built-in tool renderers.",
-          "info",
-        );
-        return;
-      }
-
-      if (action === "toggle") {
-        enabled = !enabled;
-        registerTools(ctx.cwd);
-        ctx.ui.notify(
-          enabled
-            ? "Quiet tool previews enabled: collapsed built-in tool rows show a one-line invocation plus an expand hint."
-            : "Quiet tool previews disabled: restored pi's standard built-in tool renderers.",
-          "info",
-        );
-        return;
-      }
-
-      if (action === "status") {
-        ctx.ui.notify(
-          `Quiet tool previews are ${enabled ? "enabled" : "disabled"}. Collapsed tool rows ${enabled ? "show a one-line invocation and hide output until expanded" : "use pi's default rendering"}. Model-visible tool results are unchanged.`,
-          "info",
-        );
-        return;
-      }
-
-      ctx.ui.notify("Usage: /quiet-tools on | off | toggle | status", "warning");
+      ctx.ui.notify(STATUS_USAGE, "warning");
     },
   });
 }

package/extensions/quiet-tools/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@diegopetrucci/pi-quiet-tools",
-  "version": "0.1.13",
-  "description": "A pi extension that visually compacts collapsed built-in tool rows in the TUI without changing tool results sent to the model.",
+  "version": "0.1.14",
+  "description": "A pi extension that visually compacts collapsed built-in tool rows and MCP tool rows in the TUI without changing tool results sent to the model.",
   "keywords": [
     "pi-package",
     "pi",

package/extensions/review/README.md

@@ -29,7 +29,9 @@ Then reload pi:
 
 ## Notes
 
+- `/review` requires interactive mode (TUI); `/end-review` requires a UI.
 - This fork adds loop fixing, custom review instructions persisted in the session, a blocking-findings parser, and `/end-review` handoff modes (return only, return and summarize, or return and fix findings). Loop fixing cycles until the parser reports no blocking findings: tagged P0–P2 items, or a "needs attention" verdict when no priority tags are present. Commit review is excluded from loop fixing.
+- Loop fixing always uses Empty branch mode and skips the Empty branch / Current session choice.
 - PR review requires `gh` access and a clean working tree for tracked files.
 - If the project is trusted and a `REVIEW_GUIDELINES.md` file exists next to the repo's `<pi-config-dir>` directory, its contents are appended to the review prompt. `<pi-config-dir>` is Pi's runtime config directory name (`CONFIG_DIR_NAME`; `.pi` by default).
 

package/extensions/review/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@diegopetrucci/pi-review",
-  "version": "0.1.15",
+  "version": "0.1.16",
   "description": "A standalone pi extension that adds /review and /end-review commands adapted from mitsuhiko/agent-stuff.",
   "keywords": [
     "pi-package",

package/extensions/todo/index.ts

@@ -1,15 +1,3 @@
-/**
- * Todo Extension - Demonstrates state management via session entries
- *
- * This extension:
- * - Registers a `todo` tool for the LLM to manage todos
- * - Registers a `/todos` command for users to view the list
- *
- * State is stored in tool result details (not external files), which allows
- * proper branching - when you branch, the todo state is automatically
- * correct for that point in history.
- */
-
 import { StringEnum } from "@earendil-works/pi-ai";
 import type { ExtensionAPI, ExtensionContext, Theme } from "@earendil-works/pi-coding-agent";
 import { matchesKey, Text, truncateToWidth } from "@earendil-works/pi-tui";
@@ -36,9 +24,6 @@ const TodoParams = Type.Object({
   id: Type.Optional(Type.Number({ description: "Todo ID (for toggle)" })),
 });
 
-/**
- * UI component for the /todos command
- */
 class TodoListComponent {
   private todos: Todo[];
   private theme: Theme;
@@ -109,7 +94,6 @@ class TodoListComponent {
 }
 
 export default function (pi: ExtensionAPI) {
-  // In-memory state (reconstructed from session on load)
   let todos: Todo[] = [];
   let nextId = 1;
 
@@ -134,11 +118,9 @@ export default function (pi: ExtensionAPI) {
     }
   };
 
-  // Reconstruct state on session events
   pi.on("session_start", async (_event, ctx) => reconstructState(ctx));
   pi.on("session_tree", async (_event, ctx) => reconstructState(ctx));
 
-  // Register the todo tool for the LLM
   pi.registerTool({
     name: "todo",
     label: "Todo",
@@ -303,7 +285,6 @@ export default function (pi: ExtensionAPI) {
     },
   });
 
-  // Register the /todos command for users
   pi.registerCommand("todos", {
     description: "Show all todos on the current branch",
     handler: async (_args, ctx) => {

package/extensions/todo/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@diegopetrucci/pi-todo",
-  "version": "0.1.11",
+  "version": "0.1.12",
   "description": "A pi extension that adds a branch-aware todo tool and /todos viewer.",
   "keywords": [
     "pi-package",

package/extensions/triage-comments/README.md

@@ -1,6 +1,6 @@
 # triage-comments
 
-Adds `/triage-comments` plus a read-only `triage_comments` subagent tool for evidence-based review-comment triage.
+Adds `/triage-comments` plus a `triage_comments` subagent tool with read-only built-in tools and configured MCP tools for evidence-based review-comment triage.
 
 Use it when you want `/triage-comments` to inspect selected PR feedback, classify whether each comment is valid, cite local evidence, draft review-thread responses, and propose handling options. It does **not** implement changes; after triage, the main agent should ask which handling option to take before editing anything.
 
@@ -71,7 +71,8 @@ The tool accepts selected comments and optional PR, base, diff, and caller conte
 When called, it launches an isolated in-memory subagent with:
 
 - no inherited extensions, skills, prompt templates, themes, context files, or agents files;
-- read-only tools only: `read`, `grep`, `find`, `ls`, and guarded `bash`;
+- read-only built-in tools: `read`, `grep`, `find`, `ls`, and guarded `bash`;
+- configured MCP tools (run without confirmation in the subagent; may have side effects; use for evidence gathering only; requires host Pi >=1.0.4; older hosts degrade to no MCP, no error); the global `mcp.json` always applies; a project `.pi/mcp.json` is loaded only when the host session has already trusted the project;
 - a local-checkout path guard for file inspection;
 - a bash guard that allows only direct read-only `git`, `gh`, or `pwd` invocations and blocks write/edit tools, shell pipelines, redirection, destructive git commands, and mutating `gh`/GitHub API calls;
 - a fixed triage output format with verdicts, evidence, reasoning, suggested responses, handling options, and a list of read-only checks performed.
@@ -83,6 +84,7 @@ Verdicts are one of `valid`, `invalid`, `partially valid`, `subjective`, or `nee
 - The slash command only collects/selects comments and asks the main agent to run triage.
 - The subagent is explicitly instructed not to implement changes.
 - Runtime guards block write tools, filesystem mutation through shell syntax, mutating git commands, and mutating GitHub CLI/API calls.
+- Runtime guards apply to built-in tools only; configured MCP tools pass the guard, run without confirmation, and are limited only by prompt guidance.
 - The generated prompt tells the main agent to summarize findings and ask which handling option to take before implementation.
 - Suggested responses are drafts for the user/agent to adapt; the extension does not post them to GitHub.