agent-sh 0.5.0 → 0.6.0

package/dist/agent/types.d.ts

@@ -21,15 +21,36 @@ export interface ToolResult {
     exitCode: number | null;
     isError: boolean;
 }
+/** Structured result display — returned by formatResult or computed by defaults. */
+export interface ToolResultDisplay {
+    /** One-line summary shown next to ✓/✗ (e.g. "42 papers found", "+3/-1"). */
+    summary?: string;
+    /** Structured content to render below the status line. */
+    body?: ToolResultBody;
+}
+export type ToolResultBody = {
+    kind: "diff";
+    diff: unknown;
+    filePath: string;
+} | {
+    kind: "lines";
+    lines: string[];
+    maxLines?: number;
+};
 export interface ToolDisplayInfo {
-    kind: "read" | "write" | "execute" | "search";
+    kind: "read" | "write" | "execute" | "search" | "display";
     locations?: {
         path: string;
         line?: number | null;
     }[];
+    /** Custom icon character for TUI display (e.g., "◆", "⌕"). When set, the TUI shows
+     *  icon + detail only. When absent, the tool name is shown alongside the detail. */
+    icon?: string;
 }
 export interface ToolDefinition {
     name: string;
+    /** Short label for TUI display (e.g. "search" instead of "ads_search"). Defaults to name. */
+    displayName?: string;
     description: string;
     input_schema: Record<string, unknown>;
     execute(args: Record<string, unknown>, onChunk?: (chunk: string) => void): Promise<ToolResult>;
@@ -41,4 +62,17 @@ export interface ToolDefinition {
     requiresPermission?: boolean;
     /** Derive display metadata (icon kind, file paths) for the TUI. */
     getDisplayInfo?: (args: Record<string, unknown>) => ToolDisplayInfo;
+    /**
+     * Format a short display string for the TUI when this tool is called.
+     * Return a concise summary of the args (e.g. the query, the file path).
+     * When absent, the TUI derives the detail from common arg fields (command, path, pattern).
+     */
+    formatCall?: (args: Record<string, unknown>) => string;
+    /**
+     * Format result display for the TUI after execution completes.
+     * Return a summary string and/or structured body to render.
+     * When absent, defaults are computed based on tool kind.
+     * Extensions can further override via bus.onPipe("agent:tool-completed", ...).
+     */
+    formatResult?: (args: Record<string, unknown>, result: ToolResult) => ToolResultDisplay;
 }

package/dist/core.d.ts

@@ -36,9 +36,7 @@ export interface AgentShellCore {
     /** Activate the agent backend (call after extensions load). */
     activateBackend(): void;
     /** Convenience: emit agent:submit and await the response. */
-    query(text: string, opts?: {
-        mode?: string;
-    }): Promise<string>;
+    query(text: string): Promise<string>;
     /** Convenience: emit agent:cancel-request. */
     cancel(): void;
     /** Build an ExtensionContext for loading extensions against this core. */

package/dist/core.js

@@ -221,12 +221,14 @@ export function createCore(config) {
         contextManager,
         llmClient,
         activateBackend() {
+            // Silent — backend info is shown in the startup banner.
+            // Runtime switches (config:switch-backend) still emit ui:info.
             const preferred = settings.defaultBackend;
             if (preferred && backends.has(preferred)) {
-                activateByName(preferred);
+                activateByName(preferred, true);
             }
             else if (backends.size > 0 && !agentLoop) {
-                activateByName(backends.keys().next().value);
+                activateByName(backends.keys().next().value, true);
             }
             else if (agentLoop) {
                 agentLoop.wire();
@@ -234,13 +236,10 @@ export function createCore(config) {
                 bus.emit("agent:info", { name: "agent-sh", version: "0.4", model: llmClient?.model, provider: activeProvider?.id, contextWindow: activeProvider?.contextWindow });
             }
             else if (backends.size > 0) {
-                activateByName(backends.keys().next().value);
-            }
-            if (activeBackendName) {
-                bus.emit("ui:info", { message: `Backend: ${activeBackendName}` });
+                activateByName(backends.keys().next().value, true);
             }
         },
-        async query(text, opts) {
+        async query(text) {
             return new Promise((resolve, reject) => {
                 let response = "";
                 let settled = false;
@@ -271,10 +270,7 @@ export function createCore(config) {
                 bus.on("agent:response-chunk", onChunk);
                 bus.on("agent:processing-done", onDone);
                 bus.on("agent:error", onError);
-                bus.emit("agent:submit", {
-                    query: text,
-                    modeInstruction: opts?.mode,
-                });
+                bus.emit("agent:submit", { query: text });
             });
         },
         cancel() {

package/dist/event-bus.d.ts

@@ -1,4 +1,5 @@
 import type { AgentMode } from "./types.js";
+import type { ToolResultDisplay } from "./agent/types.js";
 /**
  * Typed event map — every event has a known payload shape.
  */
@@ -23,8 +24,6 @@ export interface ShellEvents {
     "shell:agent-exec-done": Record<string, never>;
     "agent:submit": {
         query: string;
-        modeInstruction?: string;
-        modeLabel?: string;
     };
     "agent:cancel-request": {
         silent?: boolean;
@@ -32,7 +31,6 @@ export interface ShellEvents {
     "input-mode:register": import("./types.js").InputModeConfig;
     "agent:query": {
         query: string;
-        modeLabel?: string;
     };
     "agent:thinking-chunk": {
         text: string;
@@ -63,21 +61,37 @@ export interface ShellEvents {
         output: string;
         exitCode: number | null;
     };
+    "agent:tool-batch": {
+        groups: Array<{
+            kind: string;
+            tools: Array<{
+                name: string;
+                displayDetail?: string;
+            }>;
+        }>;
+    };
     "agent:tool-started": {
         title: string;
         toolCallId?: string;
         kind?: string;
+        icon?: string;
         locations?: {
             path: string;
             line?: number | null;
         }[];
         rawInput?: unknown;
+        /** Pre-formatted display detail from tool's formatCall(). */
+        displayDetail?: string;
+        batchIndex?: number;
+        batchTotal?: number;
     };
     "agent:tool-completed": {
         toolCallId?: string;
         exitCode: number | null;
         rawOutput?: unknown;
         kind?: string;
+        /** Structured result display — set by formatResult or defaults, overridable via onPipe. */
+        resultDisplay?: ToolResultDisplay;
     };
     "agent:tool-output-chunk": {
         chunk: string;
@@ -123,6 +137,7 @@ export interface ShellEvents {
         command: string;
         output: string;
         cwd: string;
+        exitCode: number | null;
         done: boolean;
     };
     "agent:info": {

package/dist/extension-loader.d.ts

@@ -13,4 +13,4 @@ import type { ExtensionContext } from "./types.js";
  * Each module should export a default or named `activate(ctx)` function.
  * Errors are non-fatal — logged via ui:error and skipped.
  */
-export declare function loadExtensions(ctx: ExtensionContext, cliExtensions?: string[]): Promise<void>;
+export declare function loadExtensions(ctx: ExtensionContext, cliExtensions?: string[]): Promise<string[]>;

package/dist/extension-loader.js

@@ -102,9 +102,7 @@ export async function loadExtensions(ctx, cliExtensions) {
             });
         }
     }
-    if (loaded.length > 0) {
-        ctx.bus.emit("ui:info", { message: `Extensions: ${loaded.join(", ")}` });
-    }
+    return loaded;
 }
 /**
  * Find an index file in a directory extension.