agent-sh 0.14.1 → 0.14.2

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

@@ -25,6 +25,7 @@ import {
 } from "./components.js";
 import type { ToolCallView, ToolResultView } from "./hooks.js";
 import { createToolHookResolver } from "./hooks.js";
+import { loadGroupMaxVisible } from "./display-config.js";
 
 const GROUPABLE_KINDS = new Set(["read", "search"]);
 const TOOL_KIND: Record<string, string> = {
@@ -120,6 +121,10 @@ function detailFromArgs(argsJson: string | undefined): string {
     if (typeof args.path === "string") return relativize(args.path);
     if (typeof args.file_path === "string") return relativize(args.file_path);
     if (typeof args.query === "string") return `"${args.query}"`;
+    if (typeof args.source === "string") {
+      const compact = args.source.replace(/\s+/g, " ").trim();
+      return compact.length > 80 ? compact.slice(0, 77) + "…" : compact;
+    }
   } catch { /* fall through */ }
   return "";
 }
@@ -229,10 +234,22 @@ export function mountAshi(
   let activeAssistant: AssistantMessage | null = null;
   let activeThinking: ThinkingBlock | null = null;
   const activeTools = new Map<string, LiveToolEntry>();
-  /** Per-batch state from agent:tool-batch — the group is created lazily on
-   *  the first member's tool-started so the chat insertion order is correct. */
-  const batchGroups = new Map<string, { total: number; group: ToolGroup | null }>();
-  let lastToolResult: ToolResultView | null = null;
+  const groupMaxVisible = loadGroupMaxVisible();
+
+  /** Find a same-kind ToolGroup at the chat tail. ThinkingBlocks are
+   *  visually-neutral only when hidden — visible thinking is a hard separator,
+   *  so toggling thinking on splits previously-merged groups at iteration
+   *  boundaries. */
+  const findMergeableGroup = (kind: string): ToolGroup | null => {
+    for (let i = chat.children.length - 1; i >= 0; i--) {
+      const c = chat.children[i]!;
+      if (c instanceof ToolGroup) return c.kind === kind ? c : null;
+      if (c instanceof ThinkingBlock && hideThinking) continue;
+      if (c instanceof AssistantMessage && !c.hasContent()) continue;
+      return null;
+    }
+    return null;
+  };
   let loader: Loader | null = null;
   let processing = false;
   const queuedQueries: string[] = [];
@@ -252,7 +269,7 @@ export function mountAshi(
     invalidate: () => tui.requestRender(),
   });
 
-  const tools = createToolHookResolver(ctx, renderState);
+  const tools = createToolHookResolver(ctx);
 
   const renderUserMessage = (text: string): Component =>
     ctx.call("ashi:render-user-message", { text, ...renderState() }) as Component;
@@ -343,32 +360,18 @@ export function mountAshi(
         chat.addChild(renderAssistantFinal(text));
       }
       if (m.tool_calls) {
-        const calls = m.tool_calls;
-        let i = 0;
-        while (i < calls.length) {
-          const startName = calls[i]!.function?.name ?? "";
-          const startKind = TOOL_KIND[startName];
-          if (startKind && GROUPABLE_KINDS.has(startKind)) {
-            let j = i;
-            while (j < calls.length && TOOL_KIND[calls[j]!.function?.name ?? ""] === startKind) j++;
-            const runLen = j - i;
-            if (runLen > 1) {
-              const group = new ToolGroup(startKind, runLen);
-              chat.addChild(group);
-              for (let k = i; k < j; k++) {
-                const c = calls[k]!;
-                const cid = c.id ?? "";
-                const cname = c.function?.name ?? "tool";
-                group.addCall(cid, cname, detailFromArgs(c.function?.arguments));
-                if (cid) toolMap.set(cid, { kind: "group", group, name: cname });
-              }
-              i = j;
-              continue;
-            }
-          }
-          const tc = calls[i]!;
+        for (const tc of m.tool_calls) {
           const id = tc.id ?? "";
           const name = tc.function?.name ?? "tool";
+          const kind = TOOL_KIND[name];
+          if (kind && GROUPABLE_KINDS.has(kind)) {
+            const mergeable = findMergeableGroup(kind);
+            const group = mergeable
+              ?? (() => { const g = new ToolGroup(kind, groupMaxVisible); chat.addChild(g); return g; })();
+            group.addCall(id, name, detailFromArgs(tc.function?.arguments));
+            if (id) toolMap.set(id, { kind: "group", group, name });
+            continue;
+          }
           const pair = renderToolPair({
             toolCallId: id, name, title: name, kind: undefined,
             displayDetail: detailFromArgs(tc.function?.arguments),
@@ -377,8 +380,6 @@ export function mountAshi(
           chat.addChild(pair.call);
           chat.addChild(pair.result);
           if (id) toolMap.set(id, { kind: "pair", pair, name });
-          lastToolResult = pair.result;
-          i++;
         }
       }
     } else if (m.role === "tool") {
@@ -411,8 +412,6 @@ export function mountAshi(
     activeAssistant = null;
     activeThinking = null;
     activeTools.clear();
-    batchGroups.clear();
-    lastToolResult = null;
     chat.clear();
     const branch = getStore().current().getBranch();
     const toolMap = new Map<string, ReplayEntry>();
@@ -480,13 +479,6 @@ export function mountAshi(
     tui.requestRender();
   });
 
-  bus.on("agent:tool-batch", (e) => {
-    batchGroups.clear();
-    for (const g of e.groups) {
-      batchGroups.set(g.kind, { total: g.tools.length, group: null });
-    }
-  });
-
   bus.on("agent:tool-started", (e) => {
     finalizeThinking();
     if (activeAssistant) {
@@ -495,34 +487,29 @@ export function mountAshi(
     }
     const id = e.toolCallId ?? `${e.title}-${Date.now()}`;
     const title = e.title.split(":")[0]!.trim();
+    const lookupName = e.name ?? title;
     const detail = e.displayDetail || detailFromArgs(
       typeof e.rawInput === "string" ? e.rawInput : JSON.stringify(e.rawInput ?? {})
     );
 
     const kind = e.kind ?? "";
-    const batchEntry = batchGroups.get(kind);
-    const shouldGroup = !!batchEntry && batchEntry.total > 1 && GROUPABLE_KINDS.has(kind);
-    if (shouldGroup) {
-      if (!batchEntry!.group) {
-        batchEntry!.group = new ToolGroup(kind, batchEntry!.total);
-        chat.addChild(batchEntry!.group);
-      }
-      batchEntry!.group.addCall(id, title, detail);
-      activeTools.set(id, { kind: "group", group: batchEntry!.group });
-      // Grouped tools have no individual result body — Ctrl+O wouldn't have
-      // anything to expand, so leave lastToolResult pointing at the prior tool.
+    if (GROUPABLE_KINDS.has(kind)) {
+      const mergeable = findMergeableGroup(kind);
+      const group = mergeable
+        ?? (() => { const g = new ToolGroup(kind, groupMaxVisible); chat.addChild(g); return g; })();
+      group.addCall(id, lookupName, detail);
+      activeTools.set(id, { kind: "group", group });
       tui.requestRender();
       return;
     }
 
     const pair = renderToolPair({
-      toolCallId: id, name: title, title, kind: e.kind,
+      toolCallId: id, name: lookupName, title, kind: e.kind,
       displayDetail: detail, rawInput: e.rawInput,
     });
     activeTools.set(id, { kind: "pair", pair });
     chat.addChild(pair.call);
     chat.addChild(pair.result);
-    lastToolResult = pair.result;
     tui.requestRender();
   });
 
@@ -743,14 +730,21 @@ export function mountAshi(
   // ── Keybindings ────────────────────────────────────────────────
   const toggleThinking = (): void => {
     hideThinking = !hideThinking;
-    const walk = (node: Container): void => {
-      for (const child of node.children) {
-        if (child instanceof ThinkingBlock) child.setHidden(hideThinking);
-        else if (child instanceof Container) walk(child);
-      }
-    };
-    walk(chat);
-    tui.requestRender();
+    if (processing) {
+      // Mid-turn: in-place show/hide only. Past groups stay as they merged
+      // under the old flag; future tool calls in this turn respect the new
+      // flag via findMergeableGroup. Next idle rebuild reflows everything.
+      const walk = (node: Container): void => {
+        for (const child of node.children) {
+          if (child instanceof ThinkingBlock) child.setHidden(hideThinking);
+          else if (child instanceof Container) walk(child);
+        }
+      };
+      walk(chat);
+      tui.requestRender();
+      return;
+    }
+    void rebuildChat();
   };
 
   tui.addInputListener((data) => {
@@ -807,10 +801,15 @@ export function mountAshi(
       return { consume: true };
     }
     if (matchesKey(data, "ctrl+o")) {
-      if (lastToolResult) {
-        lastToolResult.toggleExpanded();
-        tui.requestRender();
-      }
+      const toggle = (node: Container): void => {
+        for (const child of node.children) {
+          const fn = (child as unknown as { toggleExpanded?: () => void }).toggleExpanded;
+          if (typeof fn === "function") fn.call(child);
+          if (child instanceof Container) toggle(child);
+        }
+      };
+      toggle(chat);
+      tui.requestRender();
       return { consume: true };
     }
     return undefined;

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

@@ -1,12 +1,8 @@
 import type { Component } from "@earendil-works/pi-tui";
 import type { ExtensionContext } from "agent-sh/types";
-import {
-  AssistantMessage,
-  ThinkingBlock,
-  ToolResultBody,
-  UserMessage,
-} from "./components.js";
-import { entryFor, loadToolDisplayConfig, type ToolResultMode } from "./display-config.js";
+import { AssistantMessage, ThinkingBlock, UserMessage } from "./components.js";
+import { loadDisplayResolver, type ToolResultMode } from "./display-config.js";
+import { isRenderModel, mountCall, mountResult, type RenderModel } from "./schema.js";
 
 export interface RenderState {
   state: Record<string, unknown>;
@@ -14,41 +10,19 @@ export interface RenderState {
 }
 
 export interface UserMessageArgs extends RenderState { text: string }
-
 export interface AssistantArgs extends RenderState { text: string }
-
 export interface ThinkingArgs extends RenderState { text: string; hidden: boolean }
 
-export interface ToolCallArgs extends RenderState {
-  toolCallId: string;
-  name: string;
-  title: string;
-  kind?: string;
-  displayDetail?: string;
-  rawInput?: unknown;
-}
-
-export interface ToolResultArgs extends RenderState {
-  toolCallId: string;
-  name: string;
-  kind?: string;
-  rawInput?: unknown;
-  /** Resolved from ashi.display.{name} (or .default) in settings.json. */
-  mode: ToolResultMode;
-  previewLines: number;
-}
-
-/** Mutated by ashi when the tool completes. Renderers may ignore setStatus
- *  if they encode status differently (e.g. a sigil in the call line). */
+/** The contract ashi's frontend mutates on the call-side component. Schema
+ *  renderers satisfy this via SchemaCallComponent — extension authors don't
+ *  implement it directly. */
 export interface ToolCallView extends Component {
   setStatus(opts: { exitCode: number | null; elapsedMs: number; summary?: string }): void;
+  toggleExpanded?(): void;
 }
 
-/** Mutated by ashi as output streams in and when the tool completes.
- *  setDiffRenderer is optional behavior — renderers may no-op if they don't
- *  show diffs. The renderer is called on each terminal-width change so diffs
- *  reflow on resize. toggleExpanded flips the view's internal expansion state
- *  (Ctrl+O). */
+/** Result-side counterpart. setDiffRenderer receives the width-aware diff
+ *  closure produced by the edit/write tool at finalize. */
 export interface ToolResultView extends Component {
   appendChunk(chunk: string): void;
   setDiffRenderer(fn: (width: number) => string[]): void;
@@ -56,12 +30,8 @@ export interface ToolResultView extends Component {
   toggleExpanded(): void;
 }
 
-const CALL_PREFIX = "ashi:render-tool-call:";
-const RESULT_PREFIX = "ashi:render-tool-result:";
+const SCHEMA_PREFIX = "ashi:render-tool:";
 
-/** Register the default render-* handlers. Per-tool overrides are advised by
- *  name (e.g. `ashi:render-tool-call:bash`); unknown tools fall back to
- *  `:default`. */
 export function registerRenderDefaults(ctx: ExtensionContext): void {
   ctx.define("ashi:render-user-message", (args: UserMessageArgs): Component => {
     return new UserMessage(args.text);
@@ -85,54 +55,68 @@ export function registerRenderDefaults(ctx: ExtensionContext): void {
     tb.setHidden(args.hidden);
     return tb;
   });
+}
 
-  ctx.define(`${RESULT_PREFIX}default`, (args: ToolResultArgs): ToolResultView => {
-    return new ToolResultBody(args.mode, args.previewLines);
-  });
+export interface ToolCallResolveArgs {
+  toolCallId: string;
+  name: string;
+  title: string;
+  kind?: string;
+  displayDetail?: string;
+  rawInput?: unknown;
+}
+
+export interface ToolResultResolveArgs {
+  toolCallId: string;
+  name: string;
+  kind?: string;
+  rawInput?: unknown;
 }
 
 export interface ToolHookResolver {
-  call: (args: Omit<ToolCallArgs, "state" | "invalidate"> & Partial<RenderState>) => ToolCallView;
-  result: (args: Omit<ToolResultArgs, "mode" | "previewLines" | "state" | "invalidate"> & Partial<RenderState>) => ToolResultView;
+  call: (args: ToolCallResolveArgs) => ToolCallView;
+  result: (args: ToolResultResolveArgs) => ToolResultView;
   modeFor: (name: string) => { mode: ToolResultMode; previewLines: number };
 }
 
-/** Resolves :{name} → :default for tool render hooks and looks up each tool's
- *  display mode from ashi.display. Cache the registered-handler set; callers
- *  can `refresh()` after extensions register new tool-specific renderers. */
+/** Resolves a tool name to a schema RenderModel — :{name} first, then :default.
+ *  Cache the registered-handler set; callers can `refresh()` after extensions
+ *  register new tool-specific renderers. */
 export function createToolHookResolver(
   ctx: ExtensionContext,
-  renderState: () => RenderState,
 ): ToolHookResolver & { refresh: () => void } {
-  const config = loadToolDisplayConfig();
+  const resolver = loadDisplayResolver();
   let registered = new Set(ctx.list());
 
-  const pick = (prefix: string, name: string): string => {
-    const specific = `${prefix}${name}`;
-    return registered.has(specific) ? specific : `${prefix}default`;
+  const schemaModel = (name: string): RenderModel<unknown> => {
+    for (const candidate of [`${SCHEMA_PREFIX}${name}`, `${SCHEMA_PREFIX}default`]) {
+      if (!registered.has(candidate)) continue;
+      const v = ctx.call(candidate, {}) as unknown;
+      if (isRenderModel(v)) return v;
+    }
+    throw new Error(`no render model for tool "${name}" and no ${SCHEMA_PREFIX}default registered`);
   };
 
+  // SchemaResultComponent.render(width) corrects env.width on the first frame.
+  const initialWidth = (): number => process.stdout.columns ?? 80;
+
   return {
     refresh(): void {
       registered = new Set(ctx.list());
     },
     modeFor(name: string) {
-      const e = entryFor(config, name);
+      const e = resolver.resolve(name, schemaModel(name).display);
       return { mode: e.result, previewLines: e.previewLines };
     },
     call(args) {
-      const handler = pick(CALL_PREFIX, args.name);
-      return ctx.call(handler, { ...renderState(), ...args }) as ToolCallView;
+      const { mode, previewLines } = this.modeFor(args.name);
+      return mountCall(schemaModel(args.name), args,
+        { width: initialWidth(), mode, previewLines }) as ToolCallView;
     },
     result(args) {
       const { mode, previewLines } = this.modeFor(args.name);
-      const handler = pick(RESULT_PREFIX, args.name);
-      return ctx.call(handler, {
-        ...renderState(),
-        ...args,
-        mode,
-        previewLines,
-      }) as ToolResultView;
+      return mountResult(schemaModel(args.name), { ...args, title: args.name },
+        { width: initialWidth(), mode, previewLines }) as ToolResultView;
     },
   };
 }

package/examples/extensions/ashi/src/multi-session-store.ts

@@ -13,21 +13,62 @@ export interface SessionInfo {
 }
 
 /** Many sessions per cwd. Each is one .jsonl file under `dir/`. Constructor
- *  always opens a fresh session; /resume callers can `openSession(id)` to
- *  swap the current store to a past session file. */
+ *  always opens a fresh session unless `opts.resumeSessionId` is given and
+ *  points to an existing session file. /resume callers can `openSession(id)`
+ *  to swap the current store to a past session file. */
 export class MultiSessionStore {
   private dir: string;
   private cwd: string;
   private currentStore: SessionStore;
 
-  constructor(dir: string, cwd: string) {
+  constructor(dir: string, cwd: string, opts?: { resumeSessionId?: string }) {
     this.dir = dir;
     this.cwd = cwd;
     fs.mkdirSync(dir, { recursive: true });
     this.migrateLegacy();
+    if (opts?.resumeSessionId) {
+      const filePath = this.sessionFile(opts.resumeSessionId);
+      if (fs.existsSync(filePath)) {
+        this.currentStore = new SessionStore(filePath);
+        return;
+      }
+    }
     this.currentStore = this.createFreshSession();
   }
 
+  markLastSession(): void {
+    const lastFile = path.join(this.dir, ".last-session");
+    fs.writeFileSync(lastFile, this.currentStore.id);
+  }
+
+  static readLastSessionId(dir: string, opts?: { fallbackToLatest?: boolean }): string | undefined {
+    const lastFile = path.join(dir, ".last-session");
+    try {
+      const id = fs.readFileSync(lastFile, "utf-8").trim();
+      if (id && fs.existsSync(path.join(dir, `${id}.jsonl`))) return id;
+    } catch { /* no .last-session file yet */ }
+
+    if (opts?.fallbackToLatest) {
+      let best: { id: string; createdAt: number } | undefined;
+      let names: string[];
+      try { names = fs.readdirSync(dir); } catch { return undefined; }
+      for (const name of names) {
+        if (!name.endsWith(".jsonl")) continue;
+        const id = name.slice(0, -".jsonl".length);
+        try {
+          const raw = fs.readFileSync(path.join(dir, `${id}.jsonl.meta`), "utf-8");
+          const meta = JSON.parse(raw) as { createdAt?: number };
+          if (typeof meta.createdAt === "number" && (!best || meta.createdAt > best.createdAt)) {
+            best = { id, createdAt: meta.createdAt };
+          }
+        } catch { /* skip unreadable meta */ }
+      }
+      if (best) return best.id;
+    }
+
+    return undefined;
+  }
+
   /** One-time import from the previous storage format (sessions stored as
    *  directories with tree.jsonl + snapshots/). Each old session is replayed
    *  from its most recent snapshot into a new flat `.jsonl` file, then the