pi-pretty-tui 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Kainan Yang
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,44 @@
+# pi-pretty-tui
+
+A visual refinement extension for the [Pi coding agent](https://pi.dev/). It provides compact tool-call rendering and cleaner list presentation while preserving Pi's built-in tool behavior.
+
+## Features
+
+- Compact `Read`, `Bash`, `Edit`, `Write`, `Grep`, `Find`, and `List` calls
+- Gray running, green success, and red failure indicators
+- Concise result summaries with expandable output
+- Colored `+added` and `-removed` edit statistics and diffs
+- Correct hanging indentation for long paths and wrapped tool output
+- Bullet (`•`) markers for unordered Markdown lists
+
+## Install
+
+```sh
+pi install npm:pi-pretty-tui
+```
+
+Restart Pi or run `/reload` after installation.
+
+Pi may warn that built-in tools are being overridden. This is expected: pi-pretty-tui re-registers Pi's built-in tools and delegates execution to their original implementations, changing only their TUI renderers.
+
+## Expand tool output
+
+Use Pi's configured `app.tools.expand` keybinding (usually `Ctrl+E`) to show or hide detailed output and edit diffs.
+
+## Compatibility notice
+
+Tool rendering uses Pi's documented extension APIs. Changing unordered-list markers currently requires runtime patching of an internal `@earendil-works/pi-tui` Markdown renderer method because Pi does not expose a public hook for that presentation detail. Code blocks use Pi's original renderer without modification.
+
+No Pi source files are modified. The list-marker patch is removed during session shutdown, but a future Pi release may require this extension to be updated.
+
+## Uninstall
+
+```sh
+pi remove npm:pi-pretty-tui
+```
+
+Then restart Pi.
+
+## License
+
+MIT

package/extensions/pretty-tui.ts

@@ -0,0 +1,330 @@
+import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
+import {
+  createBashTool,
+  createEditTool,
+  createFindTool,
+  createGrepTool,
+  createLsTool,
+  createReadTool,
+  createWriteTool,
+} from "@earendil-works/pi-coding-agent";
+import {
+  type Component,
+  Markdown,
+  visibleWidth,
+  wrapTextWithAnsi,
+} from "@earendil-works/pi-tui";
+
+/** Polished tool calls and list rendering for Pi's TUI. */
+export default function prettyTui(pi: ExtensionAPI) {
+  const cwd = process.cwd();
+
+  // Pi normalizes unordered-list markers to "-". Replace only that marker;
+  // leave code-block rendering entirely to Pi's built-in Markdown renderer.
+  const markdownPrototype = Markdown.prototype as any;
+  const listPatchKey = Symbol.for("pretty-tui.list-bullets");
+  if (!markdownPrototype[listPatchKey]) {
+    const originalRenderList = markdownPrototype.renderList;
+    const patchedRenderList = function (
+      this: any,
+      token: any,
+      depth: number,
+      width: number,
+      styleContext?: any,
+    ): string[] {
+      const originalListBullet = this.theme.listBullet;
+      this.theme.listBullet = (marker: string) =>
+        originalListBullet(marker.replace(/^- /, "• "));
+      try {
+        return originalRenderList.call(this, token, depth, width, styleContext);
+      } finally {
+        this.theme.listBullet = originalListBullet;
+      }
+    };
+
+    markdownPrototype[listPatchKey] = { originalRenderList, patchedRenderList };
+    markdownPrototype.renderList = patchedRenderList;
+
+    pi.on("session_shutdown", () => {
+      const patch = markdownPrototype[listPatchKey];
+      if (patch?.patchedRenderList === markdownPrototype.renderList) {
+        markdownPrototype.renderList = patch.originalRenderList;
+      }
+      if (patch) delete markdownPrototype[listPatchKey];
+    });
+  }
+
+  const textContent = (result: any): string =>
+    result.content
+      ?.filter((item: any) => item.type === "text")
+      .map((item: any) => item.text)
+      .join("\n") ?? "";
+
+  const nonEmptyLines = (value: string): number =>
+    value ? value.split("\n").filter((line) => line.length > 0).length : 0;
+
+  type DisplayValue = string | (() => string);
+  type DisplayRow = {
+    prefix: DisplayValue;
+    continuation?: DisplayValue;
+    content: DisplayValue;
+  };
+
+  /**
+   * Wrap content separately from its prefix. Text's normal word wrapping can
+   * leave a bullet by itself and drops tree guides on continuation lines.
+   */
+  const block = (rows: DisplayRow[]): Component => ({
+    render(width: number): string[] {
+      const rendered: string[] = [];
+
+      for (const row of rows) {
+        const prefix = typeof row.prefix === "function" ? row.prefix() : row.prefix;
+        const content = typeof row.content === "function" ? row.content() : row.content;
+        const rawContinuation = row.continuation ?? " ".repeat(visibleWidth(prefix));
+        const continuation = typeof rawContinuation === "function" ? rawContinuation() : rawContinuation;
+        const prefixWidth = Math.max(visibleWidth(prefix), visibleWidth(continuation));
+        const contentWidth = Math.max(1, width - prefixWidth);
+        const wrapped = wrapTextWithAnsi(content || " ", contentWidth);
+
+        rendered.push(prefix + (wrapped[0] ?? ""));
+        for (const line of wrapped.slice(1)) rendered.push(continuation + line);
+      }
+
+      return rendered;
+    },
+    invalidate() {},
+  });
+
+  type ToolStatus = "running" | "success" | "error";
+  const setStatus = (context: any, status: ToolStatus) => {
+    context.state.compactToolStatus = status;
+  };
+
+  const call = (theme: any, name: string, detail: string, state: any) =>
+    block([{
+      prefix: () => {
+        const status = (state.compactToolStatus ?? "running") as ToolStatus;
+        const color = status === "success" ? "success" : status === "error" ? "error" : "dim";
+        return theme.fg(color, "● ");
+      },
+      continuation: "  ",
+      content:
+        theme.fg("accent", theme.bold(name)) +
+        theme.fg("dim", "(") +
+        theme.fg("text", detail) +
+        theme.fg("dim", ")"),
+    }]);
+
+  const result = (
+    theme: any,
+    summary: string,
+    output = "",
+    expanded = false,
+    error = false,
+    summaryIsStyled = false,
+    outputStyle: (line: string) => string = (line) => theme.fg("dim", line),
+  ) => {
+    const rows: DisplayRow[] = [{
+      prefix: theme.fg("dim", "└  "),
+      continuation: "   ",
+      content: summaryIsStyled ? summary : theme.fg(error ? "error" : "toolOutput", summary),
+    }];
+
+    if (expanded && output) {
+      const lines = output.split("\n");
+      const shown = lines.slice(0, 40);
+      for (const line of shown) {
+        rows.push({
+          prefix: theme.fg("dim", "   │ "),
+          continuation: theme.fg("dim", "   │ "),
+          content: outputStyle(line || " "),
+        });
+      }
+      if (lines.length > shown.length) {
+        rows.push({
+          prefix: theme.fg("muted", "   └ "),
+          continuation: "     ",
+          content: theme.fg("muted", `… ${lines.length - shown.length} more lines`),
+        });
+      }
+    }
+
+    return block(rows);
+  };
+
+  const isError = (renderContext: any, output: string): boolean =>
+    Boolean(renderContext?.isError) || /^(error|failed|access denied)\b/i.test(output.trim());
+
+  const partialResult = (context: any, theme: any, label: string): Component => {
+    setStatus(context, "running");
+    return result(theme, label);
+  };
+
+  const completeStatus = (context: any, output: string): boolean => {
+    const failed = isError(context, output);
+    setStatus(context, failed ? "error" : "success");
+    return failed;
+  };
+
+  const read = createReadTool(cwd);
+  pi.registerTool({
+    ...read,
+    renderShell: "self",
+    renderCall(args: any, theme: any, context: any) {
+      const range = args.offset || args.limit
+        ? ` · lines ${args.offset ?? 1}${args.limit ? `–${(args.offset ?? 1) + args.limit - 1}` : "+"}`
+        : "";
+      return call(theme, "Read", `${args.path}${range}`, context.state);
+    },
+    renderResult(toolResult: any, options: any, theme: any, context: any) {
+      if (options.isPartial) return partialResult(context, theme, "Reading…");
+      const output = textContent(toolResult);
+      const image = toolResult.content?.find((item: any) => item.type === "image");
+      const failed = completeStatus(context, output);
+      if (image) return result(theme, "Read image", "", false, failed);
+      const lines = nonEmptyLines(output);
+      const truncated = toolResult.details?.truncation?.truncated ? " · truncated" : "";
+      return result(
+        theme,
+        failed ? (output.split("\n")[0] || "Read failed") : `Read ${lines} ${lines === 1 ? "line" : "lines"}${truncated}`,
+        output,
+        options.expanded,
+        failed,
+      );
+    },
+  } as any);
+
+  const bash = createBashTool(cwd);
+  pi.registerTool({
+    ...bash,
+    renderShell: "self",
+    renderCall(args: any, theme: any, context: any) {
+      const command = String(args.command).replace(/\s*\n\s*/g, " ↵ ");
+      return call(theme, "Bash", command, context.state);
+    },
+    renderResult(toolResult: any, options: any, theme: any, context: any) {
+      if (options.isPartial) return partialResult(context, theme, "Running…");
+      const output = textContent(toolResult);
+      const failed = completeStatus(context, output);
+      const lines = nonEmptyLines(output);
+      const summary = failed
+        ? output.split("\n")[0] || "Command failed"
+        : output
+          ? `Done · ${lines} output ${lines === 1 ? "line" : "lines"}`
+          : "Done";
+      return result(theme, summary, output, options.expanded, failed);
+    },
+  } as any);
+
+  const edit = createEditTool(cwd);
+  pi.registerTool({
+    ...edit,
+    renderShell: "self",
+    renderCall(args: any, theme: any, context: any) {
+      const count = Array.isArray(args.edits) ? ` · ${args.edits.length} changes` : "";
+      return call(theme, "Edit", `${args.path}${count}`, context.state);
+    },
+    renderResult(toolResult: any, options: any, theme: any, context: any) {
+      if (options.isPartial) return partialResult(context, theme, "Editing…");
+      const output = textContent(toolResult);
+      const failed = completeStatus(context, output);
+      const diff = toolResult.details?.diff ?? "";
+      const additions = diff.split("\n").filter((line: string) => line.startsWith("+") && !line.startsWith("+++")).length;
+      const removals = diff.split("\n").filter((line: string) => line.startsWith("-") && !line.startsWith("---")).length;
+      const summary = failed
+        ? output.split("\n")[0] || "Edit failed"
+        : diff
+          ? theme.fg("toolOutput", "Updated · ") +
+            theme.fg("success", `+${additions}`) +
+            theme.fg("toolOutput", " ") +
+            theme.fg("error", `-${removals}`)
+          : "Updated";
+      return result(
+        theme,
+        summary,
+        diff || output,
+        options.expanded,
+        failed,
+        !failed && Boolean(diff),
+        (line) => {
+          if (line.startsWith("+") && !line.startsWith("+++")) return theme.fg("toolDiffAdded", line);
+          if (line.startsWith("-") && !line.startsWith("---")) return theme.fg("toolDiffRemoved", line);
+          return theme.fg("toolDiffContext", line);
+        },
+      );
+    },
+  } as any);
+
+  const write = createWriteTool(cwd);
+  pi.registerTool({
+    ...write,
+    renderShell: "self",
+    renderCall(args: any, theme: any, context: any) {
+      const content = String(args.content ?? "");
+      return call(theme, "Write", `${args.path} · ${nonEmptyLines(content)} lines`, context.state);
+    },
+    renderResult(toolResult: any, options: any, theme: any, context: any) {
+      if (options.isPartial) return partialResult(context, theme, "Writing…");
+      const output = textContent(toolResult);
+      const failed = completeStatus(context, output);
+      return result(
+        theme,
+        failed ? output.split("\n")[0] || "Write failed" : "Written",
+        output,
+        options.expanded,
+        failed,
+      );
+    },
+  } as any);
+
+  const grep = createGrepTool(cwd);
+  pi.registerTool({
+    ...grep,
+    renderShell: "self",
+    renderCall(args: any, theme: any, context: any) {
+      const where = args.path ? ` · ${args.path}` : "";
+      const glob = args.glob ? ` · ${args.glob}` : "";
+      return call(theme, "Grep", `${args.pattern}${where}${glob}`, context.state);
+    },
+    renderResult(toolResult: any, options: any, theme: any, context: any) {
+      if (options.isPartial) return partialResult(context, theme, "Searching…");
+      const output = textContent(toolResult);
+      const failed = completeStatus(context, output);
+      const matches = nonEmptyLines(output);
+      return result(theme, failed ? output.split("\n")[0] : `Found ${matches} matches`, output, options.expanded, failed);
+    },
+  } as any);
+
+  const find = createFindTool(cwd);
+  pi.registerTool({
+    ...find,
+    renderShell: "self",
+    renderCall(args: any, theme: any, context: any) {
+      return call(theme, "Find", `${args.pattern}${args.path ? ` · ${args.path}` : ""}`, context.state);
+    },
+    renderResult(toolResult: any, options: any, theme: any, context: any) {
+      if (options.isPartial) return partialResult(context, theme, "Searching…");
+      const output = textContent(toolResult);
+      const failed = completeStatus(context, output);
+      const matches = nonEmptyLines(output);
+      return result(theme, failed ? output.split("\n")[0] : `Found ${matches} paths`, output, options.expanded, failed);
+    },
+  } as any);
+
+  const ls = createLsTool(cwd);
+  pi.registerTool({
+    ...ls,
+    renderShell: "self",
+    renderCall(args: any, theme: any, context: any) {
+      return call(theme, "List", args.path ?? ".", context.state);
+    },
+    renderResult(toolResult: any, options: any, theme: any, context: any) {
+      if (options.isPartial) return partialResult(context, theme, "Listing…");
+      const output = textContent(toolResult);
+      const failed = completeStatus(context, output);
+      const entries = nonEmptyLines(output);
+      return result(theme, failed ? output.split("\n")[0] : `Listed ${entries} entries`, output, options.expanded, failed);
+    },
+  } as any);
+}

package/package.json

@@ -0,0 +1,35 @@
+{
+  "name": "pi-pretty-tui",
+  "version": "0.1.0",
+  "description": "Polished tool calls and Markdown rendering for the Pi coding agent TUI",
+  "license": "MIT",
+  "author": "Kainan Yang <ykn0309@whu.edu.cn>",
+  "type": "module",
+  "keywords": [
+    "pi-package",
+    "pi-extension",
+    "pi-coding-agent",
+    "tui",
+    "terminal-ui"
+  ],
+  "files": [
+    "extensions",
+    "README.md",
+    "LICENSE"
+  ],
+  "engines": {
+    "node": ">=20"
+  },
+  "peerDependencies": {
+    "@earendil-works/pi-coding-agent": "*",
+    "@earendil-works/pi-tui": "*"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "pi": {
+    "extensions": [
+      "./extensions/pretty-tui.ts"
+    ]
+  }
+}