agent-sh 0.14.1 → 0.14.2

package/examples/extensions/ash-scheme/package.json

@@ -0,0 +1,11 @@
+{
+  "name": "ash-scheme",
+  "version": "0.1.0",
+  "description": "LIPS Scheme as a cognitive substrate: a scheme_eval tool with host bindings to bash, read-file, grep, glob, etc.",
+  "type": "module",
+  "main": "index.ts",
+  "dependencies": {
+    "@jcubic/lips": "^0.20.3",
+    "agent-sh": "^0.14.0"
+  }
+}

package/examples/extensions/ash-scheme-render.ts

@@ -0,0 +1,58 @@
+// Schema-style renderer for the scheme_eval tool. No pi-tui import, no ANSI,
+// no highlighter dep. Status and streaming output are tracked by ashi; this
+// model only declares tool-specific state (the source string).
+
+import type { AgentContext } from "agent-sh/types";
+import type { RenderModel, Segment, ToolDisplay } from "@guanyilun/ashi/render";
+
+interface SchemeInit { source: string }
+
+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 {};
+}
+
+function source(rawInput: unknown): string {
+  const r = parseRaw(rawInput);
+  return typeof r.source === "string" ? r.source : "";
+}
+
+function compact(s: string, max = 80): string {
+  const c = s.replace(/\s+/g, " ").trim();
+  return c.length > max ? c.slice(0, max - 1) + "…" : c;
+}
+
+const model: RenderModel<SchemeInit> = {
+  initial: ({ rawInput }) => ({ source: source(rawInput) }),
+  view: (s, env): ToolDisplay => {
+    const failed = !!s.status && s.status.exitCode !== 0 && s.status.exitCode !== null;
+    const title: Segment[] = [
+      { text: "scheme ", style: { bold: true, color: "toolTitle" } },
+      { text: env.expanded ? s.source : compact(s.source), highlight: "scheme" },
+    ];
+    return {
+      titleIcon: "scheme",
+      title,
+      status: s.status,
+      body: failed
+        ? { kind: "compound", parts: [
+            { kind: "code", lang: "scheme", text: s.source },
+            { kind: "text", segments: [
+              { text: `✗ ${s.output.trim()}`, style: { color: "error" } },
+            ] },
+          ] }
+        : { kind: "code", lang: "scheme", text: s.source },
+      expandable: true,
+      defaultExpanded: failed,
+    };
+  },
+};
+
+export default function activate(ctx: AgentContext): void {
+  for (const n of ["scheme", "scheme_eval"]) {
+    ctx.define(`ashi:render-tool:${n}`, () => model);
+  }
+}

package/examples/extensions/ashi/README.md

@@ -68,7 +68,7 @@ Ctrl+C       Clear editor
 Ctrl+D       Quit (when editor is empty)
 Ctrl+T       Toggle thinking-block visibility (hidden by default)
 Shift+Tab    Cycle thinking level (off → low → medium → high → …)
-Ctrl+O       Expand/collapse the most recent tool result
+Ctrl+O       Expand/collapse all tool calls and results in chat
 ```
 
 The current thinking level is shown in the footer as `[level]` next to the model name.
@@ -122,11 +122,11 @@ Per-tool compactness lives under `ashi.display` in `~/.agent-sh/settings.json`:
 {
   "ashi": {
     "display": {
-      "default": { "result": "preview", "previewLines": 8 },
+      "default": { "result": "preview", "previewLines": 5 },
       "read":    { "result": "hidden" },
       "ls":      { "result": "hidden" },
       "grep":    { "result": "summary" },
-      "bash":    { "result": "preview", "previewLines": 12 },
+      "bash":    { "result": "preview" },
       "edit":    { "result": "preview" },
       "write":   { "result": "preview" }
     }
@@ -138,54 +138,64 @@ Per-tool compactness lives under `ashi.display` in `~/.agent-sh/settings.json`:
 
 - `"hidden"` — call line only while streaming; line count (`↳ 42 lines`) after completion.
 - `"summary"` — 2-line tail while streaming; line count after completion.
-- `"preview"` — last `previewLines` lines of output (default 8), with a `... (N more lines)` hint when content overflows.
+- `"preview"` — last `previewLines` lines of output (default 5), with a `... (N more lines)` hint when content overflows.
 
 For `edit_file` / `write_file`, the diff frame is treated as the output and follows the same gating: shown for `preview`, hidden for `hidden`/`summary` (the call line already carries `+12 -3` stats). The line-count hint is suppressed for diff-producing tools so edits stay quiet.
 
-Hit `Ctrl+O` to expand the most recent tool result inline regardless of mode. Press again to collapse.
+Hit `Ctrl+O` to toggle expansion across all tool entries in chat — result bodies show their full output regardless of mode, and call lines with truncated labels (e.g. long `bash` commands) reveal their full text. Press again to collapse.
 
 Each tool inherits from `default` and is overridden by its own block. Unknown tool names fall through to `default`.
 
 ## Extension surface
 
-Other extensions can override how chat entries and tool results render without forking ashi. Hooks are exposed via `ctx.define` (defaults) + `ctx.advise` (override).
-
-Components returned from these hooks are widgets from [`@earendil-works/pi-tui`](https://www.npmjs.com/package/@earendil-works/pi-tui) — the TUI framework ashi is built on.
+Other extensions can customize how chat entries and tool results render without forking ashi.
 
 ### Chat hooks
 
+These return [`@earendil-works/pi-tui`](https://www.npmjs.com/package/@earendil-works/pi-tui) components directly:
+
 | Hook | Args | Returns |
 |---|---|---|
 | `ashi:render-user-message` | `{ text, state, invalidate }` | `Component` |
 | `ashi:render-assistant` | `{ text, state, invalidate }` | `Component` |
 | `ashi:render-thinking` | `{ text, hidden, state, invalidate }` | `Component` |
 
-### Tool hooks (per-tool)
+### Tool hooks — declarative render schema
 
-Tool rendering is split into a call line (the input header) and a result body (streaming output + final state). Each side is dispatched by tool name with a `:default` fallback:
+Tool rendering uses a declarative schema so extensions don't import pi-tui or touch ashi internals. Register a `RenderModel` under `ashi:render-tool:{name}` (with `:default` as the fallback):
 
-| Hook | Args | Returns |
-|---|---|---|
-| `ashi:render-tool-call:{name}` | `{ toolCallId, name, title, kind, displayDetail, rawInput, state, invalidate }` | `ToolCallView` |
-| `ashi:render-tool-call:default` | (same) | `ToolCallView` |
-| `ashi:render-tool-result:{name}` | `{ toolCallId, name, kind, rawInput, mode, previewLines, state, invalidate }` | `ToolResultView` |
-| `ashi:render-tool-result:default` | (same) | `ToolResultView` |
+```ts
+import type { RenderModel, ToolDisplay } from "@guanyilun/ashi/render";
+
+const myModel: RenderModel<{ command: string }> = {
+  initial: ({ rawInput }) => ({ command: JSON.parse(String(rawInput)).command ?? "" }),
+  view: (s): ToolDisplay => ({
+    title: [
+      { text: "$ ", style: { bold: true, color: "toolTitle" } },
+      { text: s.command, highlight: "bash" },
+    ],
+    status: s.status,
+    body: { kind: "stream", text: s.output },
+    expandable: true,
+  }),
+};
 
-`state` is a per-call mutable bag; `invalidate()` requests a re-render.
+export default function activate(ctx) {
+  ctx.define("ashi:render-tool:bash", () => myModel);
+}
+```
 
-- `ToolCallView` extends `Component` with `setStatus({ exitCode, elapsedMs, summary })` — called once on completion.
-- `ToolResultView` extends `Component` with `appendChunk(chunk)`, `setDiff(lines)`, `finalize({ exitCode, summary })`, and `toggleExpanded()` — ashi mutates the result view as output streams in and when the user hits `Ctrl+O`.
+`view(state, env)` is a pure function returning a `ToolDisplay`. Ashi owns the pi-tui mapping, theming, streaming buffer policy (preview / summary / hidden modes from `ashi.display`), diff width memoization, and the Ctrl+O expand toggle. The framework auto-tracks `state.status`, `state.output` (streaming chunks), and `state.hasDiff` (for edit/write) — renderers read these without wiring their own reducers.
 
-`mode` and `previewLines` on result args come from `ashi.display.{name}` config so renderers can honor the user's compactness preference without re-implementing the resolution logic.
+`ToolDisplay` body kinds: `text`, `code` (with syntax highlighting via `lang`), `stream` (preview/summary/hidden policy applied by ashi), `diff` (closure pushed by the frontend orchestrator), `lines`, `compound`. Custom state transitions can be declared via an optional `reducers` map.
 
-Example: override how `bash` calls render.
+To ship a default display policy with your renderer (e.g. "this tool's output is large, default to `summary`"), set `display` on the model. User `settings.json` still wins:
 
 ```ts
-export default function activate(ctx) {
-  ctx.advise("ashi:render-tool-call:bash", (next, args) => {
-    return new MyFancyBashLine(args);  // must implement ToolCallView
-  });
-}
+const myModel: RenderModel<...> = {
+  initial, view,
+  display: { result: "summary", previewLines: 3 },
+};
 ```
 
 For non-render concerns (commands, settings, tools, providers) use the standard `agent-sh` extension API. See the [agent-sh extension docs](https://github.com/guanyilun/agent-sh/blob/main/docs/extensions.md).

package/examples/extensions/ashi/package.json

@@ -1,12 +1,19 @@
 {
   "name": "@guanyilun/ashi",
-  "version": "0.1.5",
+  "version": "0.1.6",
   "description": "Ash in an interactive TUI — agent-sh's built-in agent without the shell underneath",
   "type": "module",
   "main": "dist/cli.js",
   "bin": {
     "ashi": "dist/cli.js"
   },
+  "exports": {
+    ".": "./dist/cli.js",
+    "./render": {
+      "types": "./dist/schema.d.ts",
+      "import": "./dist/schema.js"
+    }
+  },
   "files": [
     "dist",
     "README.md"
@@ -16,6 +23,7 @@
     "clean": "rm -rf dist",
     "build": "npm run clean && tsc",
     "start": "node dist/cli.js",
+    "test": "node --import tsx --test $(find tests -name '*.test.ts' -type f)",
     "prepublishOnly": "npm run build"
   },
   "keywords": [

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

@@ -38,6 +38,7 @@ export function registerCapture(
     const newMessages = messages.slice(liveEntryIds.length).map(enrich);
     const newIds = await getStore().current().appendMessages(newMessages);
     liveEntryIds = [...liveEntryIds, ...newIds];
+    getStore().markLastSession();
   };
 
   ctx.bus.on("agent:processing-done", () => { void flush(); });

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

@@ -11,21 +11,22 @@ import type { AppConfig } from "agent-sh/types";
 
 import { mountAshi } from "./frontend.js";
 import { MultiSessionStore } from "./multi-session-store.js";
-import { registerForkCommands } from "./commands.js";
+import { registerForkCommands, applyBranchMessages } from "./commands.js";
 import { registerSessionCommands } from "./session-commands.js";
 import { registerCompaction } from "./compaction.js";
 import { registerCapture } from "./capture.js";
 import { registerRenderDefaults } from "./hooks.js";
-import { registerDefaultToolRenderers } from "./default-renderers.js";
+import { registerDefaultSchemaRenderers } from "./default-schema-renderers.js";
 import * as os from "node:os";
 import * as path from "node:path";
 
-function parseArgs(argv: string[]): AppConfig & { extensions?: string[] } {
+function parseArgs(argv: string[]): AppConfig & { extensions?: string[]; continueLast: boolean } {
   let model: string | undefined;
   let apiKey: string | undefined = process.env.OPENAI_API_KEY ?? process.env.OPENROUTER_API_KEY;
   let baseURL: string | undefined = process.env.OPENAI_BASE_URL;
   let provider: string | undefined;
   let backend: string | undefined;
+  let continueLast = false;
   const extensions: string[] = [];
 
   for (let i = 0; i < argv.length; i++) {
@@ -37,13 +38,15 @@ function parseArgs(argv: string[]): AppConfig & { extensions?: string[] } {
     else if (a === "--backend" && argv[i + 1]) backend = argv[++i];
     else if ((a === "-e" || a === "--extensions") && argv[i + 1]) {
       extensions.push(...argv[++i]!.split(",").map(s => s.trim()).filter(Boolean));
+    } else if (a === "-c" || a === "--continue") {
+      continueLast = true;
     } else if (a === "-h" || a === "--help") {
       process.stdout.write(MANAGEMENT_HELP + "\n");
       process.exit(0);
     }
   }
 
-  return { shell: "/bin/sh", model, apiKey, baseURL, provider, backend, extensions };
+  return { shell: "/bin/sh", model, apiKey, baseURL, provider, backend, extensions, continueLast };
 }
 
 const MANAGEMENT_HELP = `ashi — ash (agent-sh's built-in agent) in an interactive TUI
@@ -59,7 +62,9 @@ Management:
 
 Launch (default):
   ashi [--provider <name>] [--model <id>] [--api-key <key>] [--base-url <url>]
-       [--backend <name>] [-e <ext>[,<ext>...]]
+       [--backend <name>] [-e <ext>[,<ext>...]] [-c | --continue]
+
+  -c, --continue   Resume the last session in this cwd (fresh session if none)
 
 Reads ~/.agent-sh/settings.json for providers and defaults.`;
 
@@ -110,7 +115,10 @@ async function main(): Promise<void> {
   const cwd = process.cwd();
   const cwdSlug = cwd.replace(/\//g, "-").replace(/^-/, "");
   const sessionsDir = path.join(os.homedir(), ".agent-sh", "ashi", "history", cwdSlug, "sessions");
-  const store = new MultiSessionStore(sessionsDir, cwd);
+  const resumeId = config.continueLast
+    ? MultiSessionStore.readLastSessionId(sessionsDir, { fallbackToLatest: true })
+    : undefined;
+  const store = new MultiSessionStore(sessionsDir, cwd, { resumeSessionId: resumeId });
   const getStore = (): MultiSessionStore => store;
 
   const core = createCore({ ...config, history: new NoopHistory() });
@@ -145,7 +153,7 @@ async function main(): Promise<void> {
   const capture = registerCapture(ctx, getStore);
   registerCompaction(ctx, getStore, capture);
   registerRenderDefaults(ctx);
-  registerDefaultToolRenderers(ctx);
+  registerDefaultSchemaRenderers(ctx);
 
   ctx.advise("conversation:format-prior-history", () => null);
   ctx.advise("system-prompt:build", (next) => `${next()}\n\n<cwd>${process.cwd()}</cwd>`);
@@ -159,6 +167,12 @@ async function main(): Promise<void> {
     rebuildChat: handle.rebuildChat,
   });
 
+  if (resumeId) {
+    applyBranchMessages(ctx, getStore, capture);
+    await handle.rebuildChat();
+    ctx.bus.emit("ui:info", { message: `continued session ${resumeId.slice(0, 12)}…` });
+  }
+
   await core.activateBackend(config.backend ?? getSettings().defaultBackend);
 
   process.on("SIGTERM", cleanup);

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

@@ -1,93 +1,51 @@
 import type { ExtensionContext } from "agent-sh/types";
 import type { MultiSessionStore } from "./multi-session-store.js";
 import type { Capture } from "./capture.js";
-import type { AgentMessage, CompactionEntry } from "./session-store.js";
+import type { AgentMessage } from "./session-store.js";
 
 const KEEP_RECENT_TOKEN_BUDGET = 20_000;
+const FORCE_KEEP_RECENT_TOKEN_BUDGET = 4_000;
 const APPROX_TOKENS_PER_CHAR = 0.25;
 
-const SUMMARY_PROMPT = `You are compacting a coding-agent conversation so the agent can continue with limited context.
-
-Produce a Markdown summary using EXACTLY this structure:
-
-## Goal
-[What the user is trying to accomplish, one or two sentences]
-
-## Constraints & Preferences
-- [Bulleted user requirements / preferences expressed so far]
-
-## Progress
-### Done
-- [x] [Completed work]
-
-### In Progress
-- [ ] [Active work and current sub-goal]
-
-### Blocked
-- [Issues, or "None"]
-
-## Key Decisions
-- **[Decision]**: [Rationale]
-
-## Next Steps
-1. [What should happen next]
-
-## Critical Context
-- [Specific paths, names, identifiers, or data the agent must remember]
-
-Be concrete. Quote file paths, function names, error strings verbatim when relevant. Do not invent details that aren't in the conversation.`;
+export function pickBudget(opts: { force?: boolean; target?: number } | undefined): number {
+  if (opts?.force) return FORCE_KEEP_RECENT_TOKEN_BUDGET;
+  const target = opts?.target ?? 0;
+  if (target > 0) return Math.max(target, FORCE_KEEP_RECENT_TOKEN_BUDGET);
+  return KEEP_RECENT_TOKEN_BUDGET;
+}
 
 export function registerCompaction(
   ctx: ExtensionContext,
   getStore: () => MultiSessionStore,
   capture: Capture,
 ): void {
-  ctx.advise("conversation:compact", async (next: (...a: unknown[]) => unknown, opts: unknown) => {
-    const llm = ctx.agent?.llm;
-    if (!llm?.available) return next(opts);
+  ctx.define("ashi:compact:build-summary", (_evicted: AgentMessage[]): string | null => null);
 
+  ctx.advise("conversation:compact", async (_next: (...a: unknown[]) => unknown, opts: unknown) => {
     await capture.flush();
     const messages = ctx.call("conversation:get-messages") as AgentMessage[] | undefined;
-    if (!messages || messages.length < 6) return next(opts);
+    if (!messages || messages.length < 4) return null;
 
-    const cutIdx = findCutPoint(messages, KEEP_RECENT_TOKEN_BUDGET);
-    if (cutIdx < 2) return next(opts);
+    const o = (opts ?? {}) as { force?: boolean; target?: number };
+    const budget = pickBudget(o);
+    const minCut = o.force ? 1 : 2;
+    const cutIdx = findCutPoint(messages, budget);
+    if (cutIdx < minCut) return null;
 
     const firstKeptId = capture.getEntryIdAt(cutIdx);
     if (!firstKeptId) {
-      ctx.bus.emit("ui:error", { message: "compaction: kept-message has no on-disk entry; falling back" });
-      return next(opts);
+      ctx.bus.emit("ui:error", { message: "compaction: kept-message has no on-disk entry; aborting" });
+      return null;
     }
 
     const older = messages.slice(0, cutIdx);
     const kept = messages.slice(cutIdx);
-
-    const branch = getStore().current().getBranch();
-    const prevCompaction = [...branch].reverse().find((e) => e.type === "compaction") as CompactionEntry | undefined;
-    const prevSummary = prevCompaction?.summary;
-
     const tokensBefore = (ctx.call("conversation:estimate-prompt-tokens") as number) ?? 0;
+    const customSummary = (await ctx.call("ashi:compact:build-summary", older)) as string | null | undefined;
 
-    let summary: string;
-    try {
-      summary = await llm.ask({
-        system: SUMMARY_PROMPT,
-        query: buildQuery(older, prevSummary),
-        maxTokens: 16384,
-        reasoningEffort: "low",
-      });
-    } catch (e) {
-      ctx.bus.emit("ui:error", { message: `compaction: LLM failed (${(e as Error).message}); falling back` });
-      return next(opts);
-    }
-
-    await getStore().current().appendCompaction(summary.trim(), firstKeptId, tokensBefore);
-
-    const summaryMessage: AgentMessage = {
-      role: "user",
-      content: `[Compacted conversation summary]\n${summary.trim()}`,
-    };
-    ctx.call("conversation:replace-messages", [summaryMessage, ...kept]);
+    const store = getStore().current();
+    await store.appendCompaction(firstKeptId, tokensBefore, customSummary ?? undefined);
+    ctx.call("conversation:replace-messages", store.buildMessages());
 
     const keptIds = kept.map((_, i) => capture.getEntryIdAt(cutIdx + i));
     if (keptIds.some((id) => id === null)) {
@@ -96,13 +54,11 @@ export function registerCompaction(
     capture.resetTo([null, ...keptIds]);
 
     const tokensAfter = (ctx.call("conversation:estimate-prompt-tokens") as number) ?? 0;
-    ctx.bus.emit("ui:info", { message: `compacted ${older.length} messages: ${tokensBefore} → ${tokensAfter} tokens` });
-
     return { before: tokensBefore, after: tokensAfter, evictedCount: older.length };
   });
 }
 
-function findCutPoint(messages: AgentMessage[], tokenBudget: number): number {
+export function findCutPoint(messages: AgentMessage[], tokenBudget: number): number {
   let acc = 0;
   for (let i = messages.length - 1; i >= 0; i--) {
     acc += estimateMessageTokens(messages[i]!);
@@ -115,43 +71,16 @@ function findCutPoint(messages: AgentMessage[], tokenBudget: number): number {
   return 0;
 }
 
-function isSafeCutPoint(messages: AgentMessage[], idx: number): boolean {
+export function isSafeCutPoint(messages: AgentMessage[], idx: number): boolean {
   const m = messages[idx];
   if (!m) return true;
   if (m.role === "tool") return false;
   return !(m.role === "assistant" && m.tool_calls && m.tool_calls.length > 0);
 }
 
-function estimateMessageTokens(m: AgentMessage): number {
+export function estimateMessageTokens(m: AgentMessage): number {
   let chars = 0;
   if (typeof m.content === "string") chars += m.content.length;
   if (m.tool_calls) for (const t of m.tool_calls) chars += (t.function?.arguments?.length ?? 0);
   return Math.ceil(chars * APPROX_TOKENS_PER_CHAR) + 20;
 }
-
-function buildQuery(messages: AgentMessage[], prevSummary?: string): string {
-  const lines: string[] = [];
-  if (prevSummary) lines.push("Previous compaction summary (continue iteratively):\n", prevSummary, "\n---\n");
-  lines.push("Conversation to summarize:");
-  for (const m of messages) {
-    const text = typeof m.content === "string" ? m.content : "";
-    if (m.role === "user") lines.push(`[User]: ${text}`);
-    else if (m.role === "assistant") {
-      if (text) lines.push(`[Assistant]: ${text}`);
-      if (m.tool_calls) {
-        for (const t of m.tool_calls) {
-          const args = t.function?.arguments ?? "";
-          lines.push(`[Assistant tool call]: ${t.function?.name ?? "?"}(${truncate(args, 400)})`);
-        }
-      }
-    } else if (m.role === "tool") {
-      lines.push(`[Tool result]: ${truncate(text, 2000)}`);
-    }
-  }
-  return lines.join("\n");
-}
-
-function truncate(s: string, max: number): string {
-  if (s.length <= max) return s;
-  return s.slice(0, max) + `\n[…truncated ${s.length - max} chars…]`;
-}