agent-sh 0.4.0 → 0.6.0

package/dist/utils/stream-transform.js

@@ -19,37 +19,23 @@
 export function createBlockTransform(bus, opts) {
     let buffer = "";
     bus.onPipe("agent:response-chunk", (e) => {
-        // Process text from e.text and from text blocks in e.blocks
         const outBlocks = [];
-        if (e.blocks) {
-            for (const block of e.blocks) {
-                if (block.type === "text") {
-                    // Run delimiter detection on text blocks
-                    buffer += block.text;
-                    const { blocks: parsed, pending } = processBuffer(buffer, opts);
-                    buffer = pending;
-                    outBlocks.push(...parsed);
-                }
-                else {
-                    // Pass through non-text blocks unchanged
-                    outBlocks.push(block);
-                }
+        for (const block of e.blocks) {
+            if (block.type === "text") {
+                buffer += block.text;
+                const { blocks: parsed, pending } = processBuffer(buffer, opts);
+                buffer = pending;
+                outBlocks.push(...parsed);
+            }
+            else {
+                outBlocks.push(block);
             }
         }
-        // Also process any raw text not yet in blocks
-        if (e.text) {
-            buffer += e.text;
-            const { blocks: parsed, pending } = processBuffer(buffer, opts);
-            buffer = pending;
-            outBlocks.push(...parsed);
-        }
-        return { ...e, text: "", blocks: outBlocks };
+        return { blocks: outBlocks };
     });
     bus.onPipe("agent:response-done", (e) => {
         if (buffer) {
-            // Unclosed pattern — flush as text
             bus.emitTransform("agent:response-chunk", {
-                text: buffer,
                 blocks: [{ type: "text", text: buffer }],
             });
             buffer = "";
@@ -66,35 +52,23 @@ export function createFencedBlockTransform(bus, opts) {
     bus.onPipe("agent:response-chunk", (e) => {
         if (flushing)
             return e; // pass through during flush to avoid re-buffering
-        // Collect text from blocks or raw text
+        // Separate text blocks (to buffer) from non-text blocks (pass through)
         let incoming = "";
-        if (e.blocks) {
-            // Process text blocks, pass through non-text blocks
-            const passthrough = [];
-            for (const block of e.blocks) {
-                if (block.type === "text") {
-                    incoming += block.text;
-                }
-                else {
-                    passthrough.push(block);
-                }
+        const passthrough = [];
+        for (const block of e.blocks) {
+            if (block.type === "text") {
+                incoming += block.text;
+            }
+            else {
+                passthrough.push(block);
             }
-            const { blocks, pending } = processFencedBuffer(buffer + incoming, opts, inFence, fenceMatch, fenceLines);
-            buffer = pending.text;
-            inFence = pending.inFence;
-            fenceMatch = pending.fenceMatch;
-            fenceLines = pending.fenceLines;
-            return { ...e, text: "", blocks: [...passthrough, ...blocks] };
         }
-        // No blocks yet — work with raw text
-        incoming = buffer + e.text;
-        const { blocks, pending } = processFencedBuffer(incoming, opts, inFence, fenceMatch, fenceLines);
+        const { blocks, pending } = processFencedBuffer(buffer + incoming, opts, inFence, fenceMatch, fenceLines);
         buffer = pending.text;
         inFence = pending.inFence;
         fenceMatch = pending.fenceMatch;
         fenceLines = pending.fenceLines;
-        const existing = e.blocks ?? [];
-        return { ...e, text: "", blocks: [...existing, ...blocks] };
+        return { blocks: [...passthrough, ...blocks] };
     });
     function flushBuffer() {
         if (!buffer && !inFence)
@@ -110,7 +84,6 @@ export function createFencedBlockTransform(bus, opts) {
         if (remaining) {
             flushing = true;
             bus.emitTransform("agent:response-chunk", {
-                text: "",
                 blocks: [{ type: "text", text: remaining }],
             });
             flushing = false;

package/dist/utils/tool-display.d.ts

@@ -6,6 +6,8 @@ export interface ToolCallRender {
     command?: string;
     /** Tool kind from ACP (read, edit, execute, search, etc.). */
     kind?: string;
+    /** Custom icon character — when set, tool name is omitted (icon implies tool). */
+    icon?: string;
     /** File locations affected by the tool call. */
     locations?: {
         path: string;
@@ -13,6 +15,8 @@ export interface ToolCallRender {
     }[];
     /** Raw input parameters sent to the tool. */
     rawInput?: unknown;
+    /** Pre-formatted display detail from tool's formatCall(). Takes precedence over rawInput extraction. */
+    displayDetail?: string;
 }
 export interface ToolResultRender {
     exitCode: number | null;

package/dist/utils/tool-display.js

@@ -39,6 +39,7 @@ const KIND_ICONS = {
     move: "↗",
     search: "⌕",
     execute: "▶",
+    display: "◇",
     think: "◇",
     fetch: "↓",
     switch_mode: "⇄",
@@ -49,7 +50,10 @@ function kindIcon(kind) {
 // ── Tool call rendering ──────────────────────────────────────────
 export function renderToolCall(tool, width) {
     const mode = selectToolDisplayMode(width);
-    const icon = kindIcon(tool.kind);
+    const icon = tool.icon ?? kindIcon(tool.kind);
+    // If the tool registered a custom icon, it's self-describing — omit the name.
+    // Otherwise, include the tool name so the user knows what ran.
+    const hasCustomIcon = !!tool.icon;
     if (mode === "summary") {
         const text = truncateVisible(`${icon} ${tool.title}`, width);
         return [`${p.warning}${text}${p.reset}`];
@@ -58,7 +62,10 @@ export function renderToolCall(tool, width) {
     // Build a compact detail string to append after the title
     let detail = "";
     const cwd = process.cwd();
-    if (mode === "full") {
+    if (mode === "full" && tool.displayDetail) {
+        detail = tool.displayDetail;
+    }
+    else if (mode === "full") {
         if (tool.command) {
             detail = `$ ${tool.command}`;
         }
@@ -73,6 +80,15 @@ export function renderToolCall(tool, width) {
                 if (typeof raw.command === "string") {
                     detail = `$ ${raw.command}`;
                 }
+                else if (typeof raw.pattern === "string") {
+                    // grep/glob — show the search pattern
+                    const target = typeof raw.path === "string" ? ` ${shortenPath(raw.path, cwd)}` : "";
+                    detail = `${raw.pattern}${target}`;
+                }
+                else if (typeof raw.path === "string") {
+                    // read_file, write_file, etc.
+                    detail = shortenPath(raw.path, cwd);
+                }
                 else if (typeof raw.operation === "string") {
                     detail = raw.operation;
                     if (raw.ids && Array.isArray(raw.ids)) {
@@ -83,20 +99,31 @@ export function renderToolCall(tool, width) {
                     }
                 }
                 else {
-                    detail = formatRawInput(tool.rawInput, width - tool.title.length - 6);
+                    detail = formatRawInput(tool.rawInput, width - 4);
                 }
             }
         }
     }
-    // Render as single line: ► title: detail
-    const maxDetailW = Math.max(1, width - tool.title.length - 6);
-    if (detail) {
+    // Render as single line: icon + kind + detail
+    const maxDetailW = Math.max(1, width - 4);
+    if (detail && hasCustomIcon && tool.kind) {
+        const combined = `${tool.kind} ${detail}`;
+        const truncated = combined.length > maxDetailW ? combined.slice(0, maxDetailW - 1) + "…" : combined;
+        lines.push(`${p.warning}${icon}${p.reset} ${p.dim}${truncated}${p.reset}`);
+    }
+    else if (detail && hasCustomIcon) {
         if (detail.length > maxDetailW)
             detail = detail.slice(0, maxDetailW - 1) + "…";
-        lines.push(`${p.warning}${p.bold}${icon} ${tool.title}${p.reset}${p.dim}: ${detail}${p.reset}`);
+        lines.push(`${p.warning}${icon}${p.reset} ${p.dim}${detail}${p.reset}`);
+    }
+    else if (detail) {
+        const prefix = `${tool.title}: `;
+        const combined = prefix + detail;
+        const truncated = combined.length > maxDetailW ? combined.slice(0, maxDetailW - 1) + "…" : combined;
+        lines.push(`${p.warning}${icon}${p.reset} ${p.dim}${truncated}${p.reset}`);
     }
     else {
-        lines.push(`${p.warning}${p.bold}${icon} ${tool.title}${p.reset}`);
+        lines.push(`${p.warning}${icon} ${tool.title}${p.reset}`);
     }
     // Show additional file locations on separate lines (if more than one)
     if (mode === "full" && tool.locations && tool.locations.length > 1) {

package/examples/extensions/claude-code-bridge/README.md

@@ -0,0 +1,35 @@
+# claude-code-bridge
+
+Runs Claude Code as an agent-sh backend using the official [@anthropic-ai/claude-agent-sdk](https://www.npmjs.com/package/@anthropic-ai/claude-agent-sdk).
+
+## Install
+
+```bash
+# Copy or symlink into your extensions directory
+cp -r examples/extensions/claude-code-bridge ~/.agent-sh/extensions/claude-code-bridge
+
+# Install dependencies
+cd ~/.agent-sh/extensions/claude-code-bridge
+npm install
+```
+
+## Configure
+
+Set as default backend in `~/.agent-sh/settings.json`:
+
+```json
+{
+  "defaultBackend": "claude-code"
+}
+```
+
+Or switch at runtime:
+
+```
+? /backend claude-code
+```
+
+## Requirements
+
+- `ANTHROPIC_API_KEY` must be set in your environment
+- Claude Code manages its own model selection — no model configuration needed in agent-sh

package/examples/extensions/claude-code-bridge/index.ts

@@ -0,0 +1,194 @@
+/**
+ * Claude Code bridge — runs Claude Code Agent SDK in-process as agent-sh's backend.
+ *
+ * Uses the official @anthropic-ai/claude-agent-sdk to spawn a Claude Code
+ * session with a custom user_shell MCP tool for PTY access. Claude Code
+ * handles its own model selection, tool execution, and permissions.
+ *
+ * Setup:
+ *   npm install @anthropic-ai/claude-agent-sdk
+ *
+ * Usage:
+ *   agent-sh -e examples/extensions/claude-code-bridge
+ *
+ * Requires: Claude Code CLI installed and authenticated (claude login).
+ */
+import {
+  query,
+  tool,
+  createSdkMcpServer,
+  type Query,
+} from "@anthropic-ai/claude-agent-sdk";
+import { z } from "zod";
+import type { ExtensionContext } from "../../src/types.js";
+import type { EventBus } from "../../src/event-bus.js";
+
+// ── user_shell MCP tool ───────────────────────────────────────────
+function createUserShellTool(bus: EventBus) {
+  let liveCwd = process.cwd();
+  bus.on("shell:cwd-change", ({ cwd }) => { liveCwd = cwd; });
+
+  return tool(
+    "user_shell",
+    "Run a command with lasting effects in the user's live shell (cd, export, " +
+    "install packages, start servers) or show output the user wants to see. " +
+    "Set return_output=true only if you need to inspect the result.",
+    {
+      command: z.string().describe("Command to execute in user's shell"),
+      return_output: z.boolean().optional().describe(
+        "Whether to return the command output. Default false.",
+      ),
+    },
+    async (args) => {
+      const result = await bus.emitPipeAsync("shell:exec-request", {
+        command: args.command,
+        output: "",
+        cwd: liveCwd,
+        done: false,
+      });
+
+      const text = args.return_output
+        ? result.output || "(no output)"
+        : "Command executed.";
+
+      return { content: [{ type: "text" as const, text }] };
+    },
+  );
+}
+
+// ── Extension entry point ─────────────────────────────────────────
+export default function activate(ctx: ExtensionContext): void {
+  const { bus } = ctx;
+
+  const shellTool = createUserShellTool(bus);
+  const shellServer = createSdkMcpServer({
+    name: "agent-sh",
+    version: "1.0.0",
+    tools: [shellTool],
+  });
+
+  let activeQuery: Query | null = null;
+  const listeners: Array<{ event: string; fn: Function }> = [];
+
+  const wireListeners = () => {
+    const onSubmit = async ({ query: userQuery }: any) => {
+      bus.emit("agent:query", { query: userQuery });
+      bus.emit("agent:processing-start", {});
+
+      let fullResponseText = "";
+      let streamed = false;
+
+      try {
+        activeQuery = query({
+          prompt: userQuery,
+          options: {
+            cwd: process.cwd(),
+            systemPrompt: {
+              type: "preset",
+              preset: "claude_code",
+              append:
+                "You are running inside agent-sh, a terminal wrapper.\n" +
+                "Use your standard tools (Read, Edit, Write, Bash, Glob, Grep) for investigation.\n" +
+                "Use mcp__agent-sh__user_shell to run commands in the user's live shell when they ask to see output or need lasting effects (cd, install, start servers).\n" +
+                "Default to standard tools. Use user_shell when the user is the intended audience for the output or the command has real effects.",
+            },
+            mcpServers: { "agent-sh": shellServer },
+            allowedTools: [
+              "mcp__agent-sh__user_shell",
+              "Read", "Edit", "Write", "Bash", "Glob", "Grep",
+            ],
+            permissionMode: "acceptEdits",
+            includePartialMessages: true,
+          },
+        });
+
+        for await (const message of activeQuery) {
+          switch (message.type) {
+            case "stream_event": {
+              streamed = true;
+              const event = message.event;
+              if (event.type === "content_block_delta") {
+                const delta = event.delta as any;
+                if (delta.type === "text_delta" && delta.text) {
+                  bus.emitTransform("agent:response-chunk", {
+                    blocks: [{ type: "text" as const, text: delta.text }],
+                  });
+                  fullResponseText += delta.text;
+                } else if (delta.type === "thinking_delta" && delta.thinking) {
+                  bus.emit("agent:thinking-chunk", { text: delta.thinking });
+                }
+              }
+              break;
+            }
+
+            case "assistant": {
+              const msg = message.message;
+              for (const block of msg.content) {
+                const b = block as any;
+                if (b.type === "text" && b.text && !streamed) {
+                  bus.emitTransform("agent:response-chunk", {
+                    blocks: [{ type: "text" as const, text: b.text }],
+                  });
+                  fullResponseText += b.text;
+                } else if (b.type === "tool_use") {
+                  bus.emit("agent:tool-started", {
+                    title: b.name,
+                    toolCallId: b.id,
+                    kind: b.name.includes("shell") || b.name === "Bash"
+                      ? "execute"
+                      : "read",
+                  });
+                }
+              }
+              break;
+            }
+
+            case "result":
+              break;
+          }
+        }
+
+        bus.emitTransform("agent:response-done", {
+          response: fullResponseText,
+        });
+      } catch (err) {
+        bus.emit("agent:error", {
+          message: err instanceof Error ? err.message : String(err),
+        });
+      } finally {
+        activeQuery = null;
+        bus.emit("agent:processing-done", {});
+      }
+    };
+
+    const onCancel = () => { activeQuery?.interrupt(); };
+    const onReset = () => { /* each query() is a new session */ };
+
+    bus.on("agent:submit", onSubmit);
+    bus.on("agent:cancel-request", onCancel);
+    bus.on("agent:reset-session", onReset);
+    listeners.push(
+      { event: "agent:submit", fn: onSubmit },
+      { event: "agent:cancel-request", fn: onCancel },
+      { event: "agent:reset-session", fn: onReset },
+    );
+  };
+
+  const unwireListeners = () => {
+    for (const { event, fn } of listeners) bus.off(event as any, fn as any);
+    listeners.length = 0;
+  };
+
+  // ── Register as backend ───────────────────────────────────────
+  bus.emit("agent:register-backend", {
+    name: "claude-code",
+    start: async () => {
+      wireListeners();
+      bus.emit("agent:info", { name: "claude-code", version: "1.0" });
+    },
+    kill: () => {
+      activeQuery?.interrupt();
+      unwireListeners();
+    },
+  });
+}

package/examples/extensions/claude-code-bridge/package.json

@@ -0,0 +1,11 @@
+{
+  "name": "agent-sh-claude-code-bridge",
+  "version": "0.1.0",
+  "description": "Claude Code agent backend for agent-sh",
+  "type": "module",
+  "main": "index.ts",
+  "dependencies": {
+    "@anthropic-ai/claude-agent-sdk": "^0.2.0",
+    "zod": "^4.0.0"
+  }
+}

package/examples/extensions/openrouter.ts

@@ -0,0 +1,87 @@
+/**
+ * OpenRouter provider extension.
+ *
+ * Registers OpenRouter as a provider and fetches its full model catalog
+ * at startup. Models appear in /model autocomplete as "model [openrouter]"
+ * and are available for cycling with Shift+Tab.
+ *
+ * Model capabilities (reasoning, context window) are read from the
+ * OpenRouter API response — no hardcoded model lists.
+ *
+ * Setup:
+ *   export OPENROUTER_API_KEY="your-key"
+ *
+ * Usage:
+ *   agent-sh -e ./examples/extensions/openrouter.ts
+ *
+ *   # Or add to settings.json:
+ *   { "extensions": ["./examples/extensions/openrouter.ts"] }
+ */
+import type { ExtensionContext } from "agent-sh/types";
+
+const BASE_URL = "https://openrouter.ai/api/v1";
+const API_KEY = process.env.OPENROUTER_API_KEY ?? "";
+
+/** Curated default models — used immediately while the full catalog loads. */
+const DEFAULT_MODELS = [
+  "anthropic/claude-sonnet-4",
+  "google/gemini-2.5-pro-preview",
+  "openai/gpt-4.1",
+  "deepseek/deepseek-r1",
+  "meta-llama/llama-4-maverick",
+];
+
+interface OpenRouterModel {
+  id: string;
+  name: string;
+  context_length?: number;
+  supported_parameters?: string[];
+  pricing?: { prompt: string; completion: string };
+}
+
+export default function activate({ bus }: ExtensionContext): void {
+  if (!API_KEY) {
+    bus.emit("ui:error", {
+      message: "OpenRouter extension: OPENROUTER_API_KEY not set. Skipping.",
+    });
+    return;
+  }
+
+  // Register provider immediately with curated defaults
+  bus.emit("provider:register", {
+    id: "openrouter",
+    apiKey: API_KEY,
+    baseURL: BASE_URL,
+    defaultModel: DEFAULT_MODELS[0],
+    models: DEFAULT_MODELS,
+  });
+
+  // Fetch full model catalog in background, re-register with capabilities
+  fetchModels().then((models) => {
+    if (models.length > 0) {
+      bus.emit("provider:register", {
+        id: "openrouter",
+        apiKey: API_KEY,
+        baseURL: BASE_URL,
+        defaultModel: DEFAULT_MODELS[0],
+        supportsReasoningEffort: true,
+        models: models.map((m) => ({
+          id: m.id,
+          reasoning: m.supported_parameters?.includes("reasoning") ?? false,
+          contextWindow: m.context_length,
+        })),
+      });
+    }
+  }).catch(() => {
+    // Silently fall back to curated defaults
+  });
+}
+
+async function fetchModels(): Promise<OpenRouterModel[]> {
+  const res = await fetch(`${BASE_URL}/models`, {
+    headers: { Authorization: `Bearer ${API_KEY}` },
+  });
+  if (!res.ok) return [];
+  const data = await res.json();
+  return (data.data ?? []) as OpenRouterModel[];
+}

package/examples/extensions/pi-bridge/README.md

@@ -0,0 +1,35 @@
+# pi-bridge
+
+Runs [pi](https://github.com/nickarora/pi)'s full coding agent as an agent-sh backend. Uses pi's own configuration, models, tools, and extensions — agent-sh just provides the terminal.
+
+## Install
+
+```bash
+# Copy or symlink into your extensions directory
+cp -r examples/extensions/pi-bridge ~/.agent-sh/extensions/pi-bridge
+
+# Install dependencies
+cd ~/.agent-sh/extensions/pi-bridge
+npm install
+```
+
+## Configure
+
+Set as default backend in `~/.agent-sh/settings.json`:
+
+```json
+{
+  "defaultBackend": "pi"
+}
+```
+
+Or switch at runtime:
+
+```
+? /backend pi
+```
+
+## Requirements
+
+- pi must be configured separately (`~/.pi/settings.json`) with API keys and model preferences
+- agent-sh does not override pi's configuration — it uses whatever pi is set up with