agent-sh 0.14.0 → 0.14.2

package/examples/extensions/ashi/src/components.ts

@@ -6,7 +6,6 @@ import {
   Text,
 } from "@earendil-works/pi-tui";
 import { markdownTheme, theme } from "./theme.js";
-import type { ToolResultMode } from "./display-config.js";
 
 const OSC133_ZONE_START = "\x1b]133;A\x07";
 const OSC133_ZONE_END = "\x1b]133;B\x07";
@@ -94,115 +93,6 @@ export class ThinkingBlock extends Container {
   }
 }
 
-export class ToolResultBody extends Container {
-  private outputText: Text;
-  private bodyText: Text;
-  private outputBuffer = "";
-  private diffRenderer: ((width: number) => string[]) | null = null;
-  private lastDiffWidth = -1;
-  private mode: ToolResultMode;
-  private previewLines: number;
-  private finalized = false;
-  private expanded = false;
-  private exitCode: number | null | undefined;
-
-  constructor(mode: ToolResultMode, previewLines: number) {
-    super();
-    this.mode = mode;
-    this.previewLines = previewLines;
-    this.outputText = new Text("", 1, 0);
-    this.bodyText = new Text("", 0, 0);
-    this.addChild(this.outputText);
-    this.addChild(this.bodyText);
-  }
-
-  appendChunk(chunk: string): void {
-    this.outputBuffer += chunk;
-    this.repaint();
-  }
-
-  setDiffRenderer(fn: (width: number) => string[]): void {
-    this.diffRenderer = fn;
-    this.lastDiffWidth = -1;
-    this.repaint();
-  }
-
-  finalize(opts: { exitCode: number | null; summary?: string }): void {
-    this.finalized = true;
-    this.exitCode = opts.exitCode;
-    this.repaint();
-  }
-
-  toggleExpanded(): void {
-    this.expanded = !this.expanded;
-    this.repaint();
-  }
-
-  override render(width: number): string[] {
-    if (this.diffRenderer && width !== this.lastDiffWidth) {
-      this.lastDiffWidth = width;
-      const showDiff = this.expanded || this.mode === "preview";
-      this.bodyText.setText(showDiff ? this.diffRenderer(width).join("\n") : "");
-    }
-    return super.render(width);
-  }
-
-  private repaint(): void {
-    const hasDiff = this.diffRenderer !== null;
-    const showDiff = hasDiff && (this.expanded || this.mode === "preview");
-    if (showDiff && this.lastDiffWidth >= 0 && this.diffRenderer) {
-      this.bodyText.setText(this.diffRenderer(this.lastDiffWidth).join("\n"));
-    } else if (!showDiff) {
-      this.bodyText.setText("");
-    }
-
-    // When a diff exists, the textual output ("Edited /path (+12 -3)") just
-    // restates the call line — suppress its line-count hint to keep edits quiet.
-    if (hasDiff && !this.expanded) {
-      this.outputText.setText("");
-      return;
-    }
-    if (!this.outputBuffer) {
-      this.outputText.setText("");
-      return;
-    }
-    if (this.expanded) {
-      this.outputText.setText(theme.fg("toolOutput", this.outputBuffer));
-      return;
-    }
-    if (this.mode === "hidden") {
-      if (!this.finalized) { this.outputText.setText(""); return; }
-      this.outputText.setText(lineCountHint(this.outputBuffer, this.exitCode));
-      return;
-    }
-    if (this.mode === "summary") {
-      if (!this.finalized) {
-        // Brief tail while streaming; collapses to a line count on finalize.
-        const tail = this.outputBuffer.split("\n").slice(-2).join("\n");
-        this.outputText.setText(theme.fg("muted", tail));
-        return;
-      }
-      this.outputText.setText(lineCountHint(this.outputBuffer, this.exitCode));
-      return;
-    }
-    const lines = this.outputBuffer.split("\n");
-    const trimmed = lines.slice(-this.previewLines).join("\n");
-    const remaining = Math.max(0, lines.length - this.previewLines);
-    const overflow = remaining > 0
-      ? `\n${theme.fg("muted", `... (${remaining} more ${remaining === 1 ? "line" : "lines"})`)}`
-      : "";
-    this.outputText.setText(`${theme.fg("toolOutput", trimmed)}${overflow}`);
-  }
-}
-
-function lineCountHint(buffer: string, exitCode: number | null | undefined): string {
-  const lines = buffer.split("\n").filter((l) => l.length > 0);
-  const label = lines.length === 1 ? "1 line" : `${lines.length} lines`;
-  const ok = exitCode === null || exitCode === 0;
-  const arrow = ok ? theme.fg("muted", "↳ ") : theme.fg("error", "↳ ");
-  return `${arrow}${theme.fg("muted", label)}`;
-}
-
 export const GROUP_ICONS: Record<string, string> = { read: "◆", search: "⌕" };
 
 interface GroupChild {
@@ -222,85 +112,95 @@ function shortToolName(name: string): string {
   return SHORT_TOOL_NAMES[name] ?? name;
 }
 
-/** A batch of parallel same-kind tool calls. Renders one header, per-call
- *  child branch lines that each carry their own summary on completion, and
- *  a final aggregate. Mirrors ash's grouping (read_file/ls → "read";
- *  grep/glob → "search"). */
+/** An open-ended run of same-kind tool calls. Grows by tail-merge: the caller
+ *  extends an existing group when its `kind` matches the next call and the
+ *  group is still the chat's tail. Trailing child renders with └, others ├.
+ *
+ *  When `maxVisible` is finite and exceeded, the oldest children collapse to
+ *  a summary line ("⋯ N earlier ✓") and the last (maxVisible − 1) stay
+ *  visible. `toggleExpanded()` reveals all; `maxVisible = Infinity` disables
+ *  eviction. */
 export class ToolGroup extends Container {
   private headerText: Text;
+  private summaryText: Text;
   private childContainer: Container;
-  private aggregateText: Text;
-  private kind: string;
-  private total: number;
+  readonly kind: string;
   private maxVisible: number;
-  private visibleChildren = new Map<string, GroupChild>();
-  private hiddenSummaries: string[] = [];
-  private addedCount = 0;
-  private renderedCount = 0;
-  private completedCount = 0;
-  private allOk = true;
+  private allChildren: GroupChild[] = [];
+  private callsById = new Map<string, GroupChild>();
+  private expanded = false;
 
-  constructor(kind: string, total: number, maxVisible = 5) {
+  constructor(kind: string, maxVisible: number = Infinity) {
     super();
     this.kind = kind;
-    this.total = total;
     this.maxVisible = maxVisible;
     this.headerText = new Text("", 1, 0);
+    this.summaryText = new Text("", 1, 0);
     this.childContainer = new Container();
-    this.aggregateText = new Text("", 1, 0);
     this.addChild(new Spacer(1));
     this.addChild(this.headerText);
+    this.addChild(this.summaryText);
     this.addChild(this.childContainer);
-    this.addChild(this.aggregateText);
     this.repaintHeader();
   }
 
   addCall(toolCallId: string, name: string, detail: string): void {
-    this.addedCount++;
-    if (this.renderedCount < this.maxVisible && toolCallId) {
-      const text = new Text("", 1, 0);
-      const child: GroupChild = { name: shortToolName(name), detail: detail || "…", text };
-      this.visibleChildren.set(toolCallId, child);
-      this.childContainer.addChild(text);
-      this.renderedCount++;
-      this.repaintChild(child);
-    }
+    const text = new Text("", 1, 0);
+    const child: GroupChild = { name: shortToolName(name), detail: detail || "…", text };
+    if (toolCallId) this.callsById.set(toolCallId, child);
+    this.allChildren.push(child);
+    this.repaint();
   }
 
   recordCompletion(toolCallId: string, exitCode: number | null, summary?: string): void {
-    this.completedCount++;
-    if (exitCode !== null && exitCode !== 0) this.allOk = false;
-    const child = this.visibleChildren.get(toolCallId);
-    if (child) {
-      child.status = { exitCode, summary };
-      this.repaintChild(child);
-    } else if (summary) {
-      this.hiddenSummaries.push(summary);
-    }
-    if (this.completedCount >= this.total) this.finalize();
+    const child = this.callsById.get(toolCallId);
+    if (!child) return;
+    child.status = { exitCode, summary };
+    this.repaint();
   }
 
-  finalize(): void {
-    const collapsed = this.addedCount - this.renderedCount;
-    // No overflow ⇒ no aggregate; close the tree by promoting the last
-    // visible child's ├ to a └.
-    if (collapsed === 0) {
-      this.aggregateText.setText("");
-      const last = [...this.visibleChildren.values()].pop();
-      if (last) this.repaintChild(last, true);
-      return;
-    }
-    const mark = this.allOk ? theme.fg("success", "✓") : theme.fg("error", "✗");
-    const more = theme.fg("muted", `+${collapsed} more`);
-    const sumText = this.hiddenSummaries.length > 0
-      ? ` ${theme.fg("muted", this.hiddenSummaries.join(", "))}`
-      : "";
-    this.aggregateText.setText(`${theme.fg("muted", "└")} ${more} ${mark}${sumText}`);
+  toggleExpanded(): void {
+    this.expanded = !this.expanded;
+    this.repaint();
+  }
+
+  /** How many children at the tail are visible right now. When collapsed and
+   *  over the cap, this is maxVisible − 1 (one line goes to the summary). */
+  private visibleSliceStart(): number {
+    if (this.expanded || !Number.isFinite(this.maxVisible)) return 0;
+    if (this.allChildren.length <= this.maxVisible) return 0;
+    return this.allChildren.length - (this.maxVisible - 1);
   }
 
-  isComplete(): boolean { return this.completedCount >= this.total; }
+  private repaint(): void {
+    const start = this.visibleSliceStart();
+    const evicted = this.allChildren.slice(0, start);
+    const visible = this.allChildren.slice(start);
+
+    if (evicted.length === 0) {
+      this.summaryText.setText("");
+    } else {
+      const allOk = evicted.every(
+        (c) => !c.status || c.status.exitCode === null || c.status.exitCode === 0,
+      );
+      const mark = allOk ? theme.fg("success", "✓") : theme.fg("error", "✗");
+      const noun = evicted.length === 1 ? "earlier call" : "earlier calls";
+      this.summaryText.setText(
+        `${theme.fg("muted", "├")} ${theme.fg("muted", "⋯")} ${theme.fg("muted", `${evicted.length} ${noun}`)} ${mark}`,
+      );
+    }
+
+    // Reconcile childContainer to exactly the `visible` slice, in order. We
+    // rebuild rather than diff because group sizes are small.
+    this.childContainer.clear();
+    visible.forEach((child, idx) => {
+      const isLast = idx === visible.length - 1;
+      this.repaintChild(child, isLast);
+      this.childContainer.addChild(child.text);
+    });
+  }
 
-  private repaintChild(child: GroupChild, isLast = false): void {
+  private repaintChild(child: GroupChild, isLast: boolean): void {
     let tail: string;
     if (!child.status) {
       tail = ` ${theme.fg("muted", "…")}`;
@@ -311,8 +211,6 @@ export class ToolGroup extends Container {
       tail = ` ${mark}${sum}`;
     }
     const connector = isLast ? "└" : "├";
-    // Tool name omitted when it duplicates the kind header (e.g. read_file
-    // children under "◆ read").
     const namePart = child.name !== this.kind
       ? `${theme.bold(theme.fg("toolTitle", child.name))} `
       : "";

package/examples/extensions/ashi/src/default-schema-renderers.ts

@@ -0,0 +1,229 @@
+// Default schema-style renderers shipped with ashi. Each model below could
+// equally well live in an external extension — they use only the public
+// "@guanyilun/ashi/render" surface, proving the schema covers ashi's own
+// variety.
+
+import type { ExtensionContext } from "agent-sh/types";
+import type { RenderModel, Segment, ToolDisplay, TitleIcon } from "./schema.js";
+
+function parseRaw(raw: unknown): Record<string, unknown> {
+  if (typeof raw === "string") {
+    try { return JSON.parse(raw) as Record<string, unknown>; } catch { return {}; }
+  }
+  if (raw && typeof raw === "object") return raw as Record<string, unknown>;
+  return {};
+}
+
+const str = (v: unknown): string | undefined =>
+  typeof v === "string" && v.length > 0 ? v : undefined;
+const num = (v: unknown): number | undefined =>
+  typeof v === "number" && Number.isFinite(v) ? v : undefined;
+
+function compact(s: string, max = 80): string {
+  const c = s.replace(/\s+/g, " ").trim();
+  return c.length > max ? c.slice(0, max - 1) + "…" : c;
+}
+
+function relativize(fp: string): string {
+  const home = process.env.HOME;
+  const cwd = process.cwd();
+  if (fp.startsWith(`${cwd}/`)) return fp.slice(cwd.length + 1);
+  if (home && fp.startsWith(`${home}/`)) return `~/${fp.slice(home.length + 1)}`;
+  return fp;
+}
+
+const nameSeg = (text: string): Segment => ({ text, style: { bold: true, color: "toolTitle" } });
+const accentSeg = (text: string): Segment => ({ text, style: { color: "accent" } });
+const mutedSeg = (text: string): Segment => ({ text, style: { color: "muted" } });
+const warnSeg = (text: string): Segment => ({ text, style: { color: "warning" } });
+
+// ---------------------------------------------------------------------------
+// bash — full command toggle on Ctrl+O, syntax-highlighted, streaming output.
+
+interface BashInit { command: string; timeout?: number }
+
+const bashModel: RenderModel<BashInit> = {
+  initial: ({ rawInput }) => {
+    const r = parseRaw(rawInput);
+    return { command: str(r.command) ?? "…", timeout: num(r.timeout) };
+  },
+  view: (s, env): ToolDisplay => {
+    const title: Segment[] = [
+      nameSeg("$ "),
+      { text: env.expanded ? s.command : compact(s.command), highlight: "bash" },
+    ];
+    if (s.timeout !== undefined) title.push(mutedSeg(` (timeout ${s.timeout}s)`));
+    return {
+      title,
+      status: s.status,
+      body: { kind: "stream", text: s.output },
+      expandable: true,
+    };
+  },
+};
+
+// ---------------------------------------------------------------------------
+// read — file path + optional offset:limit range.
+
+interface ReadInit { path: string; range?: string }
+
+const readModel: RenderModel<ReadInit> = {
+  initial: ({ rawInput }) => {
+    const r = parseRaw(rawInput);
+    const path = str(r.file_path) ?? str(r.path);
+    const offset = num(r.offset);
+    const limit = num(r.limit);
+    let range: string | undefined;
+    if (offset !== undefined || limit !== undefined) {
+      const from = offset ?? 1;
+      const to = limit !== undefined ? from + limit - 1 : undefined;
+      range = to ? `:${from}-${to}` : `:${from}`;
+    }
+    return { path: path ? relativize(path) : "…", range };
+  },
+  view: (s) => ({
+    titleIcon: "read",
+    title: [
+      nameSeg("read "),
+      accentSeg(s.path),
+      ...(s.range ? [warnSeg(s.range)] : []),
+    ],
+    status: s.status,
+    body: { kind: "stream", text: s.output },
+    expandable: true,
+  }),
+};
+
+// ---------------------------------------------------------------------------
+// grep / glob / ls — pattern + scope.
+
+interface GrepInit { pattern: string; scope: string; extras: string }
+
+const grepModel: RenderModel<GrepInit> = {
+  initial: ({ rawInput }) => {
+    const r = parseRaw(rawInput);
+    const glob = str(r.glob);
+    const limit = num(r.limit);
+    const extras = [glob ? `(${glob})` : "", limit !== undefined ? `limit ${limit}` : ""]
+      .filter(Boolean).join(" ");
+    return {
+      pattern: str(r.pattern) ?? "…",
+      scope: relativize(str(r.path) ?? "."),
+      extras,
+    };
+  },
+  view: (s) => ({
+    titleIcon: "search",
+    title: [
+      nameSeg("grep "),
+      accentSeg(`/${s.pattern}/`),
+      { text: " " },
+      mutedSeg(`in ${s.scope}`),
+      ...(s.extras ? [mutedSeg(` ${s.extras}`)] : []),
+    ],
+    status: s.status,
+    body: { kind: "stream", text: s.output },
+    expandable: true,
+  }),
+};
+
+interface PathPatternInit { pattern: string; scope: string }
+
+const globModel: RenderModel<PathPatternInit> = {
+  initial: ({ rawInput }) => {
+    const r = parseRaw(rawInput);
+    return { pattern: str(r.pattern) ?? "…", scope: relativize(str(r.path) ?? ".") };
+  },
+  view: (s) => ({
+    titleIcon: "search",
+    title: [nameSeg("glob "), accentSeg(s.pattern), { text: " " }, mutedSeg(`in ${s.scope}`)],
+    status: s.status,
+    body: { kind: "stream", text: s.output },
+    expandable: true,
+  }),
+};
+
+interface LsInit { path: string }
+
+const lsModel: RenderModel<LsInit> = {
+  initial: ({ rawInput }) => {
+    const r = parseRaw(rawInput);
+    return { path: relativize(str(r.path) ?? ".") };
+  },
+  view: (s) => ({
+    titleIcon: "read",
+    title: [nameSeg("ls "), accentSeg(s.path)],
+    status: s.status,
+    body: { kind: "stream", text: s.output },
+    expandable: true,
+  }),
+};
+
+// ---------------------------------------------------------------------------
+// edit_file / write_file — path + framework-supplied diff body. The "Edited
+// /path (+N -M)" streaming text is suppressed because the diff body already
+// shows that information; per-line output reappears via expand on Ctrl+O.
+
+interface EditInit { path: string; verb: string }
+
+function editLikeModel(verb: string): RenderModel<EditInit> {
+  return {
+    initial: ({ rawInput }) => {
+      const r = parseRaw(rawInput);
+      const path = str(r.file_path) ?? str(r.path);
+      return { path: path ? relativize(path) : "…", verb };
+    },
+    view: (s, env) => ({
+      titleIcon: "edit",
+      title: [nameSeg(`${s.verb} `), accentSeg(s.path)],
+      status: s.status,
+      // Collapsed-with-diff: diff only (the "Edited /path (+N -M)" stream line
+      // restates the call line). Expanded-with-diff: diff + stream output.
+      body: s.hasDiff
+        ? (env.expanded
+            ? { kind: "compound", parts: [{ kind: "diff" }, { kind: "stream", text: s.output }] }
+            : { kind: "diff" })
+        : { kind: "stream", text: s.output },
+      expandable: true,
+    }),
+  };
+}
+
+// ---------------------------------------------------------------------------
+// default — fallback for any tool without a specific renderer.
+
+interface DefaultInit { title: string; detail?: string; icon: TitleIcon }
+
+const defaultModel: RenderModel<DefaultInit> = {
+  initial: ({ title, displayDetail }) => ({
+    title,
+    detail: displayDetail,
+    icon: "generic",
+  }),
+  view: (s) => ({
+    titleIcon: s.icon,
+    title: [
+      nameSeg(s.title),
+      ...(s.detail ? [{ text: " " }, mutedSeg(s.detail)] : []),
+    ],
+    status: s.status,
+    body: { kind: "stream", text: s.output },
+    expandable: true,
+  }),
+};
+
+// ---------------------------------------------------------------------------
+
+export function registerDefaultSchemaRenderers(ctx: ExtensionContext): void {
+  ctx.define("ashi:render-tool:bash", () => bashModel);
+  ctx.define("ashi:render-tool:read_file", () => readModel);
+  ctx.define("ashi:render-tool:read", () => readModel);
+  ctx.define("ashi:render-tool:grep", () => grepModel);
+  ctx.define("ashi:render-tool:glob", () => globModel);
+  ctx.define("ashi:render-tool:ls", () => lsModel);
+  ctx.define("ashi:render-tool:edit_file", () => editLikeModel("edit"));
+  ctx.define("ashi:render-tool:edit", () => editLikeModel("edit"));
+  ctx.define("ashi:render-tool:write_file", () => editLikeModel("write"));
+  ctx.define("ashi:render-tool:write", () => editLikeModel("write"));
+  ctx.define("ashi:render-tool:default", () => defaultModel);
+}

package/examples/extensions/ashi/src/display-config.ts

@@ -7,12 +7,11 @@ export interface ToolEntryConfig {
   previewLines: number;
 }
 
-export interface ToolDisplayConfig {
-  default: ToolEntryConfig;
-  [toolName: string]: ToolEntryConfig;
+export interface DisplayResolver {
+  resolve(name: string, modelDisplay?: Partial<ToolEntryConfig>): ToolEntryConfig;
 }
 
-const DEFAULT_ENTRY: ToolEntryConfig = { result: "preview", previewLines: 8 };
+const DEFAULT_ENTRY: ToolEntryConfig = { result: "preview", previewLines: 5 };
 
 const BUILTIN_OVERRIDES: Record<string, Partial<ToolEntryConfig>> = {
   read: { result: "hidden" },
@@ -20,7 +19,7 @@ const BUILTIN_OVERRIDES: Record<string, Partial<ToolEntryConfig>> = {
   grep: { result: "summary" },
   find: { result: "summary" },
   glob: { result: "summary" },
-  bash: { result: "preview", previewLines: 12 },
+  bash: { result: "preview" },
   edit: { result: "preview" },
   edit_file: { result: "preview" },
   write: { result: "preview" },
@@ -29,6 +28,14 @@ const BUILTIN_OVERRIDES: Record<string, Partial<ToolEntryConfig>> = {
 
 interface AshiSettings extends Record<string, unknown> {
   display?: Record<string, Partial<ToolEntryConfig>>;
+  groupMaxVisible?: number;
+}
+
+export function loadGroupMaxVisible(): number {
+  const ashi = getExtensionSettings<AshiSettings>("ashi", {});
+  const v = ashi.groupMaxVisible;
+  if (typeof v !== "number" || !Number.isFinite(v) || v < 2) return Infinity;
+  return Math.floor(v);
 }
 
 function mergeEntry(base: ToolEntryConfig, patch?: Partial<ToolEntryConfig>): ToolEntryConfig {
@@ -39,24 +46,16 @@ function mergeEntry(base: ToolEntryConfig, patch?: Partial<ToolEntryConfig>): To
   };
 }
 
-export function loadToolDisplayConfig(): ToolDisplayConfig {
+export function loadDisplayResolver(): DisplayResolver {
   const ashi = getExtensionSettings<AshiSettings>("ashi", {});
   const userDisplay = ashi.display ?? {};
   const userDefault = mergeEntry(DEFAULT_ENTRY, userDisplay.default);
-  const config: ToolDisplayConfig = { default: userDefault };
-  const names = new Set([
-    ...Object.keys(BUILTIN_OVERRIDES),
-    ...Object.keys(userDisplay).filter((k) => k !== "default"),
-  ]);
-  for (const name of names) {
-    config[name] = mergeEntry(
-      mergeEntry(userDefault, BUILTIN_OVERRIDES[name]),
-      userDisplay[name],
-    );
-  }
-  return config;
-}
-
-export function entryFor(config: ToolDisplayConfig, name: string): ToolEntryConfig {
-  return config[name] ?? config.default;
+  return {
+    resolve(name, modelDisplay) {
+      let entry = mergeEntry(userDefault, BUILTIN_OVERRIDES[name]);
+      if (modelDisplay) entry = mergeEntry(entry, modelDisplay);
+      if (userDisplay[name]) entry = mergeEntry(entry, userDisplay[name]);
+      return entry;
+    },
+  };
 }