@pify/pretty 0.1.0 → 0.2.0

package/README.md

@@ -22,10 +22,18 @@ Expand with pi's standard toggle (Ctrl+O on a tool block). Failures always show
 Each renderer toggles independently (persisted per session):
 
 ```
-/pretty            # show which renderers are on
-/pretty bash       # toggle one back to pi's default rendering
+/pretty                 # show which renderers are on
+/pretty bash            # toggle one back to pi's default rendering
+/pretty bash grep       # toggle several at once (v0.2)
+/pretty off             # everything back to pi's rendering (v0.2)
+/pretty on read         # explicit on/off instead of toggling (v0.2)
+/pretty reset           # all renderers back on (v0.2)
 ```
 
+Aliases are accepted where they're obvious: `list`/`dir` → `ls`, `search`/`rg` → `grep`, `cat` → `read`, `sh`/`shell` → `bash`.
+
+Expanded bodies are capped at 200 lines (v0.2) — a 5,000-line diff or grep result used to render in full and scroll the conversation away.
+
 ## How it works
 
 The official `built-in-tool-renderer` pattern: each tool is re-registered with `createReadTool()`/`createBashTool()`/… delegating `execute` untouched, overriding only `renderCall`/`renderResult`. Highlighting uses pi's exported `highlightCode` + `getLanguageFromPath` — zero extra dependencies, colors always match your theme.

package/extensions/pretty.ts

@@ -28,8 +28,16 @@ import {
 } from "@earendil-works/pi-coding-agent";
 import { Text } from "@earendil-works/pi-tui";
 
-import { PRETTY_CONFIG, isPrettyTool, replayBranch, statusLines, toggleTool } from "../src/config.ts";
+import {
+  PRETTY_CONFIG,
+  PRETTY_USAGE,
+  applyCommand,
+  parsePrettyCommand,
+  replayBranch,
+  statusLines,
+} from "../src/config.ts";
 import { colorizeDiff, diffStats, statsLabel } from "../src/diff.ts";
+import { preview } from "../src/preview.ts";
 import {
   bashCall,
   bashSummary,
@@ -50,8 +58,6 @@ import {
   type ThemeLike,
 } from "../src/types.ts";
 
-const PREVIEW_LINES = 12;
-
 type AnyTool = {
   name: string;
   description: string;
@@ -68,13 +74,6 @@ export default function pretty(pi: ExtensionAPI) {
     return isRecord(result) && result.isError === true;
   }
 
-  function clip(text: string, expanded: boolean): string {
-    if (expanded) return text;
-    const lines = text.split("\n");
-    if (lines.length <= PREVIEW_LINES) return text;
-    return `${lines.slice(0, PREVIEW_LINES).join("\n")}\n…`;
-  }
-
   function buildOriginals(cwd: string): Record<PrettyTool, AnyTool> {
     return {
       read: createReadTool(cwd) as unknown as AnyTool,
@@ -133,11 +132,11 @@ export default function pretty(pi: ExtensionAPI) {
           ) => {
             const output = textContent(result);
             if (options.isPartial) {
-              return new Text(`${theme.fg("warning", "Running…")}\n${clip(output, false)}`, 0, 0);
+              return new Text(`${theme.fg("warning", "Running…")}\n${preview(output, false)}`, 0, 0);
             }
             const failed = isFailed(result);
             const summary = bashSummary(theme, output, failed);
-            const body = output && (options.expanded || failed) ? `\n${clip(output, options.expanded === true)}` : "";
+            const body = output && (options.expanded || failed) ? `\n${preview(output, options.expanded === true)}` : "";
             return new Text(summary + body, 0, 0);
           },
         };
@@ -159,7 +158,7 @@ export default function pretty(pi: ExtensionAPI) {
                 : "";
             const stats = statsLabel(theme, diffStats(diff));
             if (!options.expanded) return new Text(stats, 0, 0);
-            return new Text(`${stats}\n${colorizeDiff(theme, diff)}`, 0, 0);
+            return new Text(`${stats}\n${colorizeDiff(theme, preview(diff, true))}`, 0, 0);
           },
         };
       case "write":
@@ -200,7 +199,7 @@ export default function pretty(pi: ExtensionAPI) {
               tool === "grep" ? { one: "match", many: "matches" } : { one: "result", many: "results" },
             );
             if (!options.expanded || failed || !output) return new Text(summary, 0, 0);
-            return new Text(`${summary}\n${clip(output, true)}`, 0, 0);
+            return new Text(`${summary}\n${preview(output, true)}`, 0, 0);
           },
         };
       case "ls":
@@ -216,7 +215,7 @@ export default function pretty(pi: ExtensionAPI) {
             const failed = isFailed(result);
             const summary = matchSummary(theme, output, failed, { one: "entry", many: "entries" });
             if (!options.expanded || failed) return new Text(summary, 0, 0);
-            return new Text(`${summary}\n${clip(output, true)}`, 0, 0);
+            return new Text(`${summary}\n${preview(output, true)}`, 0, 0);
           },
         };
     }
@@ -254,23 +253,31 @@ export default function pretty(pi: ExtensionAPI) {
   // ── Command ──────────────────────────────────────────────────────────
 
   pi.registerCommand("pretty", {
-    description: "Toggle pretty tool rendering: /pretty [read|bash|edit|write|grep|find|ls]",
+    description: "Pretty tool rendering: /pretty [status | on|off [tool…] | reset | <tool…>]",
     handler: async (args, ctx: ExtensionContext) => {
-      if (!ctx.hasUI) return;
-      const target = (args ?? "").trim().toLowerCase();
-      if (!target) {
-        ctx.ui.notify(`Pretty renderers\n${statusLines(config).join("\n")}\nToggle with /pretty <tool>`, "info");
+      const command = parsePrettyCommand(args ?? "");
+      if (command.kind === "error") {
+        if (ctx.hasUI) ctx.ui.notify(command.message, "warning");
         return;
       }
-      if (!isPrettyTool(target)) {
-        ctx.ui.notify(`Unknown tool "${target}". Tools: read, bash, edit, write, grep, find, ls`, "warning");
+      if (command.kind === "status") {
+        if (ctx.hasUI) {
+          ctx.ui.notify(`Pretty renderers\n${statusLines(config).join("\n")}\n${PRETTY_USAGE}`, "info");
+        }
         return;
       }
-      config = toggleTool(config, target);
+
+      const { config: next, changed } = applyCommand(config, command);
+      config = next;
       pi.appendEntry(PRETTY_CONFIG, config);
-      applyTool(target);
-      const on = !config.disabled.includes(target);
-      ctx.ui.notify(`pretty ${target}: ${on ? "on" : "off"}`, "info");
+      for (const tool of changed) applyTool(tool);
+      if (!ctx.hasUI) return;
+      ctx.ui.notify(
+        changed.length === 0
+          ? "Nothing changed."
+          : changed.map((t) => `pretty ${t}: ${config.disabled.includes(t) ? "off" : "on"}`).join("\n"),
+        "info",
+      );
     },
   });
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pify/pretty",
-  "version": "0.1.0",
+  "version": "0.2.0",
   "description": "Compact, theme-aware rendering for pi's built-in tools: one-line summaries, syntax-highlighted reads, colorized diffs — behavior untouched",
   "keywords": [
     "pi-package",
@@ -27,12 +27,13 @@
   "files": [
     "extensions",
     "src",
-    "skills",
     "README.md",
     "LICENSE"
   ],
   "pi": {
-    "extensions": ["./extensions/pretty.ts"]
+    "extensions": [
+      "./extensions/pretty.ts"
+    ]
   },
   "scripts": {
     "typecheck": "tsc --noEmit",
@@ -44,8 +45,12 @@
     "@earendil-works/pi-tui": "*"
   },
   "peerDependenciesMeta": {
-    "@earendil-works/pi-coding-agent": { "optional": true },
-    "@earendil-works/pi-tui": { "optional": true }
+    "@earendil-works/pi-coding-agent": {
+      "optional": true
+    },
+    "@earendil-works/pi-tui": {
+      "optional": true
+    }
   },
   "devDependencies": {
     "@earendil-works/pi-coding-agent": "^0.84.4",

package/src/config.ts

@@ -33,6 +33,88 @@ export function toggleTool(config: PrettyConfig, tool: PrettyTool): PrettyConfig
     : { disabled: [...config.disabled, tool] };
 }
 
+export const PRETTY_USAGE = "Usage: /pretty [status | on|off [tool…] | reset | <tool…>]  tools: read, bash, edit, write, grep, find, ls";
+
+/** Aliases the model or a hurried user is likely to type. */
+const ALIASES: Record<string, PrettyTool> = {
+  list: "ls",
+  dir: "ls",
+  search: "grep",
+  rg: "grep",
+  cat: "read",
+  shell: "bash",
+  sh: "bash",
+};
+
+export type PrettyCommand =
+  | { kind: "status" }
+  | { kind: "toggle"; tools: PrettyTool[] }
+  | { kind: "set"; tools: PrettyTool[]; on: boolean }
+  | { kind: "reset" }
+  | { kind: "error"; message: string };
+
+function resolveTools(words: string[]): { tools: PrettyTool[]; unknown: string[] } {
+  const tools: PrettyTool[] = [];
+  const unknown: string[] = [];
+  for (const word of words) {
+    if (word === "all") {
+      tools.push(...PRETTY_TOOLS);
+      continue;
+    }
+    const name = ALIASES[word] ?? word;
+    if (isPrettyTool(name)) {
+      if (!tools.includes(name)) tools.push(name);
+    } else {
+      unknown.push(word);
+    }
+  }
+  return { tools, unknown };
+}
+
+export function parsePrettyCommand(raw: string): PrettyCommand {
+  const words = (raw ?? "").trim().toLowerCase().split(/\s+/).filter(Boolean);
+  if (words.length === 0) return { kind: "status" };
+
+  const [head, ...rest] = words;
+  if (head === "status" || head === "list") return { kind: "status" };
+  if (head === "reset") return { kind: "reset" };
+
+  if (head === "on" || head === "off") {
+    const { tools, unknown } = resolveTools(rest.length > 0 ? rest : ["all"]);
+    if (unknown.length > 0) return { kind: "error", message: `Unknown tool "${unknown[0]}". ${PRETTY_USAGE}` };
+    return { kind: "set", tools, on: head === "on" };
+  }
+
+  const { tools, unknown } = resolveTools(words);
+  if (unknown.length > 0) return { kind: "error", message: `Unknown tool "${unknown[0]}". ${PRETTY_USAGE}` };
+  return { kind: "toggle", tools };
+}
+
+/** Apply a parsed command; returns the new config and the tools that changed. */
+export function applyCommand(
+  config: PrettyConfig,
+  command: PrettyCommand,
+): { config: PrettyConfig; changed: PrettyTool[] } {
+  switch (command.kind) {
+    case "toggle": {
+      let next = config;
+      for (const tool of command.tools) next = toggleTool(next, tool);
+      return { config: next, changed: command.tools };
+    }
+    case "set": {
+      const disabled = command.on
+        ? config.disabled.filter((t) => !command.tools.includes(t))
+        : [...new Set([...config.disabled, ...command.tools])];
+      const changed = command.tools.filter((t) => config.disabled.includes(t) !== disabled.includes(t));
+      return { config: { disabled }, changed };
+    }
+    case "reset":
+      return { config: DEFAULT_CONFIG, changed: [...config.disabled] };
+    default:
+      return { config, changed: [] };
+  }
+}
+
 export function statusLines(config: PrettyConfig): string[] {
   return PRETTY_TOOLS.map(
     (tool) => `${config.disabled.includes(tool) ? "○" : "●"} ${tool}`,

package/src/diff.ts

@@ -5,12 +5,21 @@ export interface DiffStats {
   removed: number;
 }
 
-/** Count +/− lines in a display diff (ignores headers like +++/---). */
+/**
+ * Count +/− lines in a display diff. File headers (+++/---) are skipped, but
+ * only where they can actually appear — before the first hunk. Inside a hunk,
+ * a removed line whose content starts with `--` is a real removal.
+ */
 export function diffStats(diff: string): DiffStats {
   let added = 0;
   let removed = 0;
+  let inHunk = false;
   for (const line of diff.split("\n")) {
-    if (line.startsWith("+++") || line.startsWith("---")) continue;
+    if (line.startsWith("@@")) {
+      inHunk = true;
+      continue;
+    }
+    if (!inHunk && (line.startsWith("+++") || line.startsWith("---"))) continue;
     if (line.startsWith("+")) added++;
     else if (line.startsWith("-")) removed++;
   }

package/src/preview.ts

@@ -0,0 +1,21 @@
+/**
+ * One capping primitive for every body the renderers print. Collapsed rows get
+ * a short peek; expanded rows get a generous but bounded view — a 5,000-line
+ * diff or grep result should not be able to scroll the whole conversation out
+ * of the terminal just because someone pressed expand.
+ */
+
+export interface PreviewLimits {
+  collapsed: number;
+  expanded: number;
+}
+
+export const DEFAULT_LIMITS: PreviewLimits = { collapsed: 12, expanded: 200 };
+
+export function preview(text: string, expanded: boolean, limits: PreviewLimits = DEFAULT_LIMITS): string {
+  const max = expanded ? limits.expanded : limits.collapsed;
+  const lines = text.split("\n");
+  if (lines.length <= max) return text;
+  const hidden = lines.length - max;
+  return `${lines.slice(0, max).join("\n")}\n… +${hidden} more line${hidden === 1 ? "" : "s"}`;
+}