@pify/pretty 0.1.0 → 0.3.0

package/README.md

@@ -22,10 +22,34 @@ 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.
+
+## Settings (v0.3)
+
+Every cap in a renderer is somebody's taste, and the right number depends on your terminal. Put them in `.pi/pretty.json` (project) or `<agentDir>/pretty.json` (global — the project file wins):
+
+```json
+{
+  "collapsedLines": 12,
+  "expandedLines": 200,
+  "diffLines": 200,
+  "syntaxHighlight": true,
+  "summaryClip": 100
+}
+```
+
+Unknown keys, wrong types, and absurd numbers are reported at session start and fall back to the shipped defaults rather than taking the renderers down — a typo tells you it was a typo instead of quietly doing nothing. `/pretty` shows the settings in force and where they came from. (The case for making these configurable is [`pi-cc-extensions`](https://github.com/minuque/pi-cc-extensions)' `/ccstyle`, which does it with a whole settings panel.)
+
 ## 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

@@ -21,15 +21,27 @@ import {
   createLsTool,
   createReadTool,
   createWriteTool,
+  getAgentDir,
   getLanguageFromPath,
   highlightCode,
   type ExtensionAPI,
   type ExtensionContext,
 } from "@earendil-works/pi-coding-agent";
 import { Text } from "@earendil-works/pi-tui";
+import { readFileSync } from "node:fs";
+import { join } from "node:path";
 
-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 { limitsFrom, preview } from "../src/preview.ts";
+import { DEFAULT_SETTINGS, formatSettings, resolveSettings, type PrettySettings } from "../src/settings.ts";
 import {
   bashCall,
   bashSummary,
@@ -50,8 +62,6 @@ import {
   type ThemeLike,
 } from "../src/types.ts";
 
-const PREVIEW_LINES = 12;
-
 type AnyTool = {
   name: string;
   description: string;
@@ -62,19 +72,42 @@ type AnyTool = {
 
 export default function pretty(pi: ExtensionAPI) {
   let config: PrettyConfig = DEFAULT_CONFIG;
+  let settings: PrettySettings = DEFAULT_SETTINGS;
+  let settingsSource: string | null = null;
+  let settingsWarnings: string[] = [];
+
+  /** Project settings win over global ones; neither is required. */
+  function loadSettings(cwd: string): void {
+    const candidates = [join(cwd, ".pi", "pretty.json"), join(getAgentDir(), "pretty.json")];
+    for (const file of candidates) {
+      let raw: string;
+      try {
+        raw = readFileSync(file, "utf8");
+      } catch {
+        continue;
+      }
+      try {
+        const parsed = resolveSettings(JSON.parse(raw));
+        settings = parsed.settings;
+        settingsWarnings = parsed.warnings;
+        settingsSource = file;
+      } catch (err) {
+        settings = DEFAULT_SETTINGS;
+        settingsSource = null;
+        settingsWarnings = [`${file}: ${err instanceof Error ? err.message : String(err)}`];
+      }
+      return;
+    }
+    settings = DEFAULT_SETTINGS;
+    settingsSource = null;
+    settingsWarnings = [];
+  }
   let originals: Record<PrettyTool, AnyTool> | null = null;
 
   function isFailed(result: unknown): boolean {
     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 +166,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, limitsFrom(settings))}`, 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, limitsFrom(settings))}` : "";
             return new Text(summary + body, 0, 0);
           },
         };
@@ -159,7 +192,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, { collapsed: settings.collapsedLines, expanded: settings.diffLines }))}`, 0, 0);
           },
         };
       case "write":
@@ -200,7 +233,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, limitsFrom(settings))}`, 0, 0);
           },
         };
       case "ls":
@@ -216,7 +249,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, limitsFrom(settings))}`, 0, 0);
           },
         };
     }
@@ -242,8 +275,12 @@ export default function pretty(pi: ExtensionAPI) {
 
   pi.on("session_start", async (_event, ctx) => {
     originals = buildOriginals(ctx.cwd);
+    loadSettings(ctx.cwd);
     config = replayBranch(ctx.sessionManager.getBranch() as never);
     applyAll();
+    if (settingsWarnings.length > 0 && ctx.hasUI) {
+      ctx.ui.notify(`pretty settings: ${settingsWarnings.join("; ")}`, "warning");
+    }
   });
 
   pi.on("session_tree", async (_event, ctx) => {
@@ -254,23 +291,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.3.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,12 +45,16 @@
     "@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",
-    "@earendil-works/pi-tui": "^0.84.4",
+    "@earendil-works/pi-coding-agent": "^0.85.1",
+    "@earendil-works/pi-tui": "^0.85.1",
     "@types/node": "^22.10.2",
     "typescript": "^5.7.2"
   },

package/src/config.ts

@@ -33,6 +33,91 @@ 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",
+  "Settings: .pi/pretty.json (project) or <agentDir>/pretty.json",
+].join("\n");
+
+/** 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,26 @@
+/**
+ * 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 };
+
+/** Limits from user settings (v0.3); the caps themselves are unchanged. */
+export function limitsFrom(settings: { collapsedLines: number; expandedLines: number }): PreviewLimits {
+  return { collapsed: settings.collapsedLines, expanded: settings.expandedLines };
+}
+
+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"}`;
+}

package/src/settings.ts

@@ -0,0 +1,93 @@
+/**
+ * User settings for the renderers.
+ *
+ * pi-cc-extensions makes the case by example: every number in a renderer is
+ * someone's taste, and the ones that matter are the caps. A 200-line expanded
+ * body is right on a 4K monitor and absurd in a 24-row terminal, and nobody
+ * wants to fork a package to change an integer.
+ *
+ * Read from `.pi/pretty.json` in the project, else `<agentDir>/pretty.json`.
+ * Unknown keys are ignored and bad values fall back to the default, so an
+ * old or hand-edited file can never take the renderers down — the worst case
+ * is the shipped defaults, which is where everyone starts anyway.
+ */
+
+export interface PrettySettings {
+  /** Lines shown in a collapsed body (bash streaming, tool output). */
+  collapsedLines: number;
+  /** Lines shown after expanding, before "+N more lines". */
+  expandedLines: number;
+  /** Lines of an edit diff shown after expanding. */
+  diffLines: number;
+  /** Highlight expanded read results with pi's own highlighter. */
+  syntaxHighlight: boolean;
+  /** Longest path/command shown in a one-line summary. */
+  summaryClip: number;
+}
+
+export const DEFAULT_SETTINGS: PrettySettings = {
+  collapsedLines: 12,
+  expandedLines: 200,
+  diffLines: 200,
+  syntaxHighlight: true,
+  summaryClip: 100,
+};
+
+const LIMITS: Record<keyof PrettySettings, { min: number; max: number } | null> = {
+  collapsedLines: { min: 1, max: 200 },
+  expandedLines: { min: 5, max: 10_000 },
+  diffLines: { min: 5, max: 10_000 },
+  syntaxHighlight: null,
+  summaryClip: { min: 20, max: 500 },
+};
+
+/**
+ * Merge a parsed settings file over the defaults. Returns the settings that
+ * will actually be used plus a note for every value that was rejected —
+ * silently ignoring a typo is how someone spends an afternoon wondering why
+ * their config does nothing.
+ */
+export function resolveSettings(raw: unknown): { settings: PrettySettings; warnings: string[] } {
+  const settings: PrettySettings = { ...DEFAULT_SETTINGS };
+  const warnings: string[] = [];
+  if (raw === null || typeof raw !== "object" || Array.isArray(raw)) {
+    if (raw !== undefined && raw !== null) warnings.push("settings file is not an object — ignored");
+    return { settings, warnings };
+  }
+
+  for (const [key, value] of Object.entries(raw as Record<string, unknown>)) {
+    if (!(key in DEFAULT_SETTINGS)) {
+      warnings.push(`unknown setting "${key}"`);
+      continue;
+    }
+    const name = key as keyof PrettySettings;
+    const limit = LIMITS[name];
+    if (limit === null) {
+      if (typeof value !== "boolean") {
+        warnings.push(`"${key}" must be true or false — using ${String(DEFAULT_SETTINGS[name])}`);
+        continue;
+      }
+      (settings[name] as boolean) = value;
+      continue;
+    }
+    if (typeof value !== "number" || !Number.isFinite(value)) {
+      warnings.push(`"${key}" must be a number — using ${String(DEFAULT_SETTINGS[name])}`);
+      continue;
+    }
+    const clamped = Math.round(Math.min(limit.max, Math.max(limit.min, value)));
+    if (clamped !== value) {
+      warnings.push(`"${key}" clamped to ${clamped} (allowed ${limit.min}–${limit.max})`);
+    }
+    (settings[name] as number) = clamped;
+  }
+
+  return { settings, warnings };
+}
+
+export function formatSettings(settings: PrettySettings, source: string | null): string {
+  const width = Object.keys(settings).reduce((m, k) => Math.max(m, k.length), 0);
+  const lines = Object.entries(settings).map(
+    ([key, value]) => `  ${key.padEnd(width)}  ${String(value)}`,
+  );
+  return [source ? `Settings from ${source}` : "Settings (defaults — no pretty.json found)", ...lines].join("\n");
+}