agent-sh 0.12.27 → 0.13.1

package/dist/shell/tui-input-view.js

@@ -3,7 +3,7 @@
  * Owns screen state (cursor row/col, autocomplete line count) and the
  * ANSI redraw. The controller drives it via a small VM shape.
  */
-import { visibleLen } from "../utils/ansi.js";
+import { visibleLen, truncateToWidth } from "../utils/ansi.js";
 import { palette as p } from "../utils/palette.js";
 import { StdoutSurface } from "../utils/compositor.js";
 export class TuiInputView {
@@ -146,15 +146,26 @@ export class TuiInputView {
         if (vm.items.length === 0)
             return;
         this.autoFrame(() => {
+            // Truncate descriptions so each row fits one physical line — a wrapped
+            // row makes autocompleteLines undercount, clearAutocomplete leaves a
+            // residual row, and the next drawPrompt redraws below the original
+            // prompt (staircase).
+            const termW = this.surface.columns;
             const lines = [];
             for (let i = 0; i < vm.items.length; i++) {
                 const item = vm.items[i];
+                const nameW = Math.max(12, visibleLen(item.name));
+                const overhead = 5 + nameW;
+                const descBudget = Math.max(1, termW - overhead);
+                const desc = visibleLen(item.description) > descBudget
+                    ? truncateToWidth(item.description, descBudget)
+                    : item.description;
                 const selected = i === vm.selected;
                 if (selected) {
-                    lines.push(`  \x1b[7m ${p.accent}${item.name.padEnd(12)}${p.reset}\x1b[7m ${item.description} ${p.reset}`);
+                    lines.push(`  \x1b[7m ${p.accent}${item.name.padEnd(12)}${p.reset}\x1b[7m ${desc} ${p.reset}`);
                 }
                 else {
-                    lines.push(`   ${p.muted}${item.name.padEnd(12)} ${item.description}${p.reset}`);
+                    lines.push(`   ${p.muted}${item.name.padEnd(12)} ${desc}${p.reset}`);
                 }
             }
             this.emit("\n" + lines.join("\n"));

package/dist/{extensions → shell}/tui-renderer.d.ts

@@ -1,2 +1,2 @@
-import type { ExtensionContext } from "../types.js";
+import type { ExtensionContext } from "./host-types.js";
 export default function activate(ctx: ExtensionContext): void;

package/dist/{extensions → shell}/tui-renderer.js

@@ -18,7 +18,7 @@ import { palette as p } from "../utils/palette.js";
 import { renderToolCall, createSpinner, formatElapsed, SPINNER_FRAMES, } from "../utils/tool-display.js";
 import { renderDiff } from "../utils/diff-renderer.js";
 import { renderBoxFrame } from "../utils/box-frame.js";
-import { getSettings } from "../settings.js";
+import { getSettings } from "../core/settings.js";
 /** Encode a PNG buffer as a terminal inline image escape sequence. */
 function encodeImageForTerminal(data) {
     const b64 = data.toString("base64");
@@ -67,12 +67,11 @@ function createRenderState() {
         isThinking: false,
         showThinkingText: false,
         thinkingPending: false,
-        previewedDiffPending: false,
-        previewedDiffToolIds: new Set(),
     };
 }
 export default function activate(ctx) {
-    const { bus, define, compositor } = ctx;
+    const { bus, define } = ctx;
+    const compositor = ctx.shell.compositor;
     const s = createRenderState();
     /** Track the shell's cwd so path shortening is relative to where the user actually is. */
     let shellCwd = process.cwd();
@@ -273,10 +272,6 @@ export default function activate(ctx) {
         s.currentToolKind = e.kind;
         s.toolStartTime = Date.now();
         s.orphanContHeaderKind = undefined;
-        if (s.previewedDiffPending && e.toolCallId) {
-            s.previewedDiffToolIds.add(e.toolCallId);
-        }
-        s.previewedDiffPending = false;
         if (e.title === "user_shell") {
             finalizeToolGroup();
             closeToolLine();
@@ -340,13 +335,7 @@ export default function activate(ctx) {
         s.toolExitCode = e.exitCode;
         if (e.exitCode !== 0)
             s.toolGroupAllOk = false;
-        let resultDisplay = e.resultDisplay;
-        if (e.toolCallId && s.previewedDiffToolIds.has(e.toolCallId)) {
-            s.previewedDiffToolIds.delete(e.toolCallId);
-            if (resultDisplay?.body?.kind === "diff") {
-                resultDisplay = { ...resultDisplay, body: undefined };
-            }
-        }
+        const resultDisplay = e.resultDisplay;
         if (s.toolGroupKind) {
             // Grouped tool — track success/failure and summaries, show aggregate on ⎿ line.
             // Don't restart spinner between grouped tools — it's already running from group start.
@@ -411,46 +400,6 @@ export default function activate(ctx) {
         s.renderer.writeLine("");
         drain();
     });
-    bus.on("permission:request", (e) => {
-        if (!shouldRender())
-            return;
-        stopCurrentSpinner();
-        flushCommandOutput();
-        if (s.renderer) {
-            s.renderer.flush();
-            drain();
-        }
-        // Diff rendering is handled in the async pipe below so it can yield
-        // to the event loop between hunks (keeping the spinner responsive).
-    });
-    // Async pipe: render diffs via the tui:render-diff handler (extensions can
-    // advise to customize).  Runs after the sync `on` handler above (which
-    // flushes state) and before shell.ts's pipe (which pauses stdout).
-    bus.onPipeAsync("permission:request", async (e) => {
-        if (!shouldRender())
-            return e;
-        if (e.kind === "file-write" && e.metadata?.diff) {
-            showCollapsedThinking();
-            const lines = ctx.call("tui:render-diff", e.title, e.metadata.diff, cappedW());
-            if (lines.length > 0) {
-                if (!s.renderer)
-                    startAgentResponse();
-                contentGap("diff");
-                for (const line of lines)
-                    s.renderer.writeLine(line);
-                drain();
-            }
-            // The diff box IS the visual representation of the upcoming tool call.
-            // Mark lastContentKind as "tool" so the tool call line that follows
-            // doesn't inject an extra gap between the diff box and the checkmark.
-            s.lastContentKind = "tool";
-            s.previewedDiffPending = true;
-        }
-        // Don't endAgentResponse() here — permission requests that aren't
-        // file-write diffs are handled inline (auto-approved or by extensions).
-        // Closing the response prematurely causes double separator borders.
-        return e;
-    });
     bus.on("input:keypress", (e) => {
         if (e.key === "\x14")
             toggleThinkingDisplay(); // Ctrl+T
@@ -661,6 +610,25 @@ export default function activate(ctx) {
     define("tui:render-diff", (filePath, diff, width) => {
         return renderDiffBody(diff, filePath, width);
     });
+    /** Display a diff inline above the agent response (e.g. for pre-execute
+     *  preview from a gating advisor). Formats via `tui:render-diff` so
+     *  advisors can theme it. */
+    define("tui:show-diff", (filePath, diff) => {
+        if (!shouldRender())
+            return;
+        stopCurrentSpinner();
+        showCollapsedThinking();
+        const lines = ctx.call("tui:render-diff", filePath, diff, cappedW());
+        if (lines.length === 0)
+            return;
+        if (!s.renderer)
+            startAgentResponse();
+        contentGap("diff");
+        for (const line of lines)
+            s.renderer.writeLine(line);
+        drain();
+        s.lastContentKind = "tool";
+    });
     /** Render a diff as framed box lines (pure — no TUI state side effects). */
     function renderDiffBody(diff, filePath, width) {
         if (diff.isIdentical)
@@ -716,6 +684,10 @@ export default function activate(ctx) {
             return "";
         if (typeof raw.command === "string")
             return `$ ${raw.command}`;
+        if (typeof raw.source === "string") {
+            const firstLine = raw.source.split("\n").map((l) => l.trim()).find((l) => l.length > 0) ?? "";
+            return firstLine.length > 80 ? firstLine.slice(0, 77) + "…" : firstLine;
+        }
         if (typeof raw.pattern === "string")
             return raw.pattern;
         if (typeof raw.path === "string") {

package/dist/utils/box-frame.d.ts

@@ -12,6 +12,10 @@ export interface BoxFrameOptions {
     titleRight?: string;
     /** Footer lines shown below a divider, inside the box. */
     footer?: string[];
+    /** Raw bg ANSI open code (e.g. "\x1b[48;2;40;50;40m"). When set, fills
+     *  the frame interior with this bg and rewrites internal `\x1b[49m` /
+     *  `\x1b[0m` resets so per-cell colors in content don't punch holes. */
+    bgColor?: string;
 }
 /**
  * Render content lines inside a bordered frame.

package/dist/utils/box-frame.js

@@ -27,6 +27,7 @@ export function renderBoxFrame(content, opts) {
     const style = opts.style ?? "rounded";
     const b = BORDERS[style];
     const bc = borderColor;
+    const bg = opts.bgColor ?? "";
     // Content area width = total - 2 borders - 2 padding spaces
     const innerW = Math.max(1, width - 4);
     const output = [];
@@ -47,26 +48,36 @@ export function renderBoxFrame(content, opts) {
         const leftPart = title ? `${p.reset} ${title} ${bc}` : "";
         const rightPart = opts.titleRight ? `${p.reset} ${opts.titleRight} ${bc}` : "";
         const dashCount = Math.max(1, width - 2 - leftVis - rightVis);
-        output.push(`${bc}${b.tl}${leftPart}${b.h.repeat(dashCount)}${rightPart}${b.tr}${p.reset}`);
+        output.push(paintBg(`${bc}${b.tl}${leftPart}${b.h.repeat(dashCount)}${rightPart}${b.tr}${p.reset}`, bg));
     }
     else {
-        output.push(`${bc}${b.tl}${b.h.repeat(width - 2)}${b.tr}${p.reset}`);
+        output.push(paintBg(`${bc}${b.tl}${b.h.repeat(width - 2)}${b.tr}${p.reset}`, bg));
     }
     // Content lines
     for (const line of content) {
-        output.push(boxLine(line, innerW, b.v, bc));
+        output.push(paintBg(boxLine(line, innerW, b.v, bc), bg));
     }
     // Footer with divider
     if (opts.footer && opts.footer.length > 0) {
-        output.push(`${bc}${b.ml}${b.h.repeat(width - 2)}${b.mr}${p.reset}`);
+        output.push(paintBg(`${bc}${b.ml}${b.h.repeat(width - 2)}${b.mr}${p.reset}`, bg));
         for (const line of opts.footer) {
-            output.push(boxLine(line, innerW, b.v, bc));
+            output.push(paintBg(boxLine(line, innerW, b.v, bc), bg));
         }
     }
     // Bottom border
-    output.push(`${bc}${b.bl}${b.h.repeat(width - 2)}${b.br}${p.reset}`);
+    output.push(paintBg(`${bc}${b.bl}${b.h.repeat(width - 2)}${b.br}${p.reset}`, bg));
     return output;
 }
+/** Wrap a line with a uniform bg, rewriting internal `\x1b[49m` (bg-default)
+ *  and `\x1b[0m` (full-reset) so embedded colors don't punch through. */
+function paintBg(line, bg) {
+    if (!bg)
+        return line;
+    const fixed = line
+        .replaceAll("\x1b[49m", bg)
+        .replaceAll("\x1b[0m", "\x1b[0m" + bg);
+    return `${bg}${fixed}\x1b[49m`;
+}
 // ── Helpers ──────────────────────────────────────────────────────
 function boxLine(text, innerW, v, bc) {
     const textWidth = visibleLen(text);

package/dist/utils/compositor.d.ts

@@ -24,7 +24,7 @@
  *   compositor.redirect("agent:diff", diffPanelSurface);
  *   // "agent:text", "agent:tool" etc. still go to stdout
  */
-import type { EventBus } from "../event-bus.js";
+import type { EventBus } from "../core/event-bus.js";
 /**
  * A surface accepts rendered output.  Stdout is a surface.
  * A floating panel's content area is a surface.  A test buffer is a surface.

package/dist/utils/compositor.js

@@ -36,8 +36,9 @@ export const nullSurface = {
 export class StdoutSurface {
     write(text) {
         if (process.stdout.writable) {
+            // OPOST is cleared on the TTY; add CR to lone \n so we don't staircase.
             try {
-                process.stdout.write(text);
+                process.stdout.write(text.replace(/(?<!\r)\n/g, "\r\n"));
             }
             catch { /* ignore */ }
         }

package/dist/{executor.js → utils/executor.js}

@@ -1,6 +1,6 @@
 import { spawn, spawnSync } from "node:child_process";
 import { existsSync } from "node:fs";
-import { stripAnsi } from "./utils/ansi.js";
+import { stripAnsi } from "./ansi.js";
 // Node reports a missing cwd as `spawn <binary> ENOENT` — disambiguate.
 function explainSpawnError(err, cwd) {
     if (err.code === "ENOENT" && !existsSync(cwd)) {

package/dist/utils/floating-panel.d.ts

@@ -1,6 +1,6 @@
 import { TerminalBuffer } from "./terminal-buffer.js";
 import { HandlerRegistry } from "./handler-registry.js";
-import type { EventBus } from "../event-bus.js";
+import type { EventBus } from "../core/event-bus.js";
 import type { BorderStyle } from "./box-frame.js";
 import { type RenderSurface } from "./compositor.js";
 export interface FloatingPanelConfig {

package/dist/utils/floating-panel.js

@@ -916,11 +916,16 @@ export class FloatingPanel {
         }
         this.surface.write("\x1b[?1049l");
         if (!this.usedAltScreen) {
-            // Program exited mid-overlay; its reset bytes were eaten by
-            // stdout-hold. Reset modes serialize() doesn't track or the
-            // host stays in vim's modifyOtherKeys mode.
+            // Alt-screen TUI exited mid-overlay; its reset bytes were eaten
+            // by stdout-hold. Re-emit the modes commonly set by full-screen
+            // programs (vim, neovim, emacs -nw, less, htop, tmux, ssh→TUI):
+            // modifyOtherKeys, kitty kbd, bracketed paste, focus reporting,
+            // mouse, DECCKM cursor-key mode, application keypad, cursor
+            // blink. Without this, arrow keys / keypad digits / cursor state
+            // misbehave at the post-overlay shell prompt.
             this.surface.write("\x1b[>4;0m\x1b[<u\x1b[?2004l\x1b[?1004l" +
-                "\x1b[?1000l\x1b[?1002l\x1b[?1003l\x1b[?1006l");
+                "\x1b[?1000l\x1b[?1002l\x1b[?1003l\x1b[?1006l" +
+                "\x1b[?1l\x1b>\x1b[?12l");
         }
         this.bus.emit("shell:stdout-release", {});
         const serialized = this.buffer?.serialize();

package/dist/utils/llm-client.d.ts

@@ -24,30 +24,20 @@ export declare class LlmClient {
     constructor(config: LlmClientConfig);
     /** Swap the underlying client config at runtime (e.g. provider switch). */
     reconfigure(newConfig: LlmClientConfig): void;
-    /**
-     * Create a streaming chat completion.
-     * Returns an async iterable of chunks.
-     */
-    stream(opts: {
-        messages: ChatCompletionMessageParam[];
-        tools?: ChatCompletionTool[];
-        model?: string;
-        max_tokens?: number;
-        /** Reasoning effort: "off" | "low" | "medium" | "high". Provider-dependent;
-         *  "off" matches agent-loop's thinkingLevel and omits the field. */
-        reasoning_effort?: string;
-        signal?: AbortSignal;
-    }): import("openai").APIPromise<import("openai/core/streaming.mjs").Stream<OpenAI.Chat.Completions.ChatCompletionChunk>>;
-    /**
-     * Single-shot completion (no streaming) — for fast-path features.
-     * Returns the text content of the first choice.
-     */
-    complete(opts: {
-        messages: ChatCompletionMessageParam[];
-        model?: string;
-        max_tokens?: number;
-        /** Reasoning effort: "off" | "low" | "medium" | "high". Provider-dependent;
-         *  "off" matches agent-loop's thinkingLevel and omits the field. */
-        reasoning_effort?: string;
-    }): Promise<string>;
+    stream(opts: StreamOpts): import("openai").APIPromise<import("openai/core/streaming.mjs").Stream<OpenAI.Chat.Completions.ChatCompletionChunk>>;
+    complete(opts: CompleteOpts): Promise<string>;
 }
+/** Known fields are typed; extras are forwarded verbatim to the SDK so
+ *  provider hooks can ship non-standard params (thinking, reasoning, …). */
+export type StreamOpts = {
+    messages: ChatCompletionMessageParam[];
+    tools?: ChatCompletionTool[];
+    model?: string;
+    max_tokens?: number;
+    signal?: AbortSignal;
+} & Record<string, unknown>;
+export type CompleteOpts = {
+    messages: ChatCompletionMessageParam[];
+    model?: string;
+    max_tokens?: number;
+} & Record<string, unknown>;

package/dist/utils/llm-client.js

@@ -35,39 +35,28 @@ export class LlmClient {
         });
         this.model = newConfig.model;
     }
-    /**
-     * Create a streaming chat completion.
-     * Returns an async iterable of chunks.
-     */
     stream(opts) {
-        const sendEffort = opts.reasoning_effort && opts.reasoning_effort !== "off";
+        const { signal, messages, tools, model, max_tokens, ...rest } = opts;
         const body = {
-            model: opts.model ?? this.model,
-            messages: opts.messages,
-            tools: opts.tools?.length ? opts.tools : undefined,
-            max_tokens: opts.max_tokens ?? 65536,
+            ...rest,
+            model: model ?? this.model,
+            messages,
+            tools: tools?.length ? tools : undefined,
+            max_tokens: max_tokens ?? 65536,
             stream: true,
             stream_options: { include_usage: true },
-            ...(sendEffort
-                ? { reasoning_effort: opts.reasoning_effort }
-                : {}),
         };
-        return this.client.chat.completions.create(body, { signal: opts.signal });
+        return this.client.chat.completions.create(body, { signal });
     }
-    /**
-     * Single-shot completion (no streaming) — for fast-path features.
-     * Returns the text content of the first choice.
-     */
     async complete(opts) {
-        const sendEffort = opts.reasoning_effort && opts.reasoning_effort !== "off";
-        const response = await this.client.chat.completions.create({
-            model: opts.model ?? this.model,
-            messages: opts.messages,
-            max_tokens: opts.max_tokens ?? 1024,
-            ...(sendEffort
-                ? { reasoning_effort: opts.reasoning_effort }
-                : {}),
-        });
+        const { messages, model, max_tokens, ...rest } = opts;
+        const body = {
+            ...rest,
+            model: model ?? this.model,
+            messages,
+            max_tokens: max_tokens ?? 1024,
+        };
+        const response = await this.client.chat.completions.create(body);
         return response.choices[0]?.message?.content ?? "";
     }
 }

package/dist/utils/llm-facade.d.ts

@@ -2,6 +2,10 @@
  * ctx.llm facade — delegates to an `llm:invoke` handler registered by the
  * active backend. No handler → `available` is false and calls reject.
  */
-import type { HandlerRegistry } from "./handler-registry.js";
-import type { LlmInterface } from "../types.js";
-export declare function createLlmFacade(handlers: HandlerRegistry): LlmInterface;
+import type { LlmInterface } from "../agent/host-types.js";
+interface HandlerGate {
+    list: () => string[];
+    call: (name: string, ...args: unknown[]) => unknown;
+}
+export declare function createLlmFacade(handlers: HandlerGate): LlmInterface;
+export {};

package/dist/utils/stream-transform.d.ts

@@ -4,7 +4,7 @@
  * Handles the boilerplate of buffering across chunk boundaries,
  * pattern matching, and flush-on-done coordination.
  */
-import type { EventBus, ContentBlock } from "../event-bus.js";
+import type { EventBus, ContentBlock } from "../core/event-bus.js";
 export interface BlockTransformOptions {
     /** Opening delimiter (e.g. "$$") */
     open: string;

package/dist/utils/terminal-buffer.d.ts

@@ -1,4 +1,4 @@
-import type { EventBus } from "../event-bus.js";
+import type { EventBus } from "../core/event-bus.js";
 export interface TerminalBufferConfig {
     /** Terminal width in columns. Default: process.stdout.columns || 80. */
     cols?: number;

package/dist/utils/tool-display.js

@@ -79,6 +79,10 @@ export function renderToolCall(tool, width, cwd = process.cwd()) {
                 if (typeof raw.command === "string") {
                     detail = `$ ${raw.command}`;
                 }
+                else if (typeof raw.source === "string") {
+                    const firstLine = raw.source.split("\n").map((l) => l.trim()).find((l) => l.length > 0) ?? "";
+                    detail = firstLine.length > 80 ? firstLine.slice(0, 77) + "…" : firstLine;
+                }
                 else if (typeof raw.pattern === "string") {
                     // grep/glob — show the search pattern
                     const target = typeof raw.path === "string" ? ` ${shortenPath(raw.path, cwd)}` : "";

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

@@ -6,7 +6,7 @@
  * handles surface writing, input interception, shell pause/unpause,
  * and cleanup.
  */
-import type { EventBus } from "../event-bus.js";
+import type { EventBus } from "../core/event-bus.js";
 import type { RenderSurface } from "./compositor.js";
 import type { ToolUI } from "../agent/types.js";
 export declare function createToolUI(bus: EventBus, surface: RenderSurface): ToolUI;

package/dist/utils/tty.d.ts

@@ -0,0 +1,7 @@
+/**
+ * libuv's setRawMode(true) keeps OPOST on, so the kernel rewrites \n to
+ * \r\n. TUIs over ssh (e.g. emacs -nw) emit relative moves like "\n\n\n\b\b"
+ * assuming a raw path — with OPOST on, \n snaps the cursor to col 0 and
+ * subsequent text lands in the wrong column. Call after every setRawMode(true).
+ */
+export declare function clearOpost(): void;

package/dist/utils/tty.js

@@ -0,0 +1,15 @@
+import { execSync } from "child_process";
+/**
+ * libuv's setRawMode(true) keeps OPOST on, so the kernel rewrites \n to
+ * \r\n. TUIs over ssh (e.g. emacs -nw) emit relative moves like "\n\n\n\b\b"
+ * assuming a raw path — with OPOST on, \n snaps the cursor to col 0 and
+ * subsequent text lands in the wrong column. Call after every setRawMode(true).
+ */
+export function clearOpost() {
+    if (!process.stdin.isTTY)
+        return;
+    try {
+        execSync("stty -opost", { stdio: "inherit" });
+    }
+    catch { /* best effort */ }
+}

package/examples/extensions/ash-acp-bridge/README.md

@@ -36,4 +36,7 @@ The adapter translates between ACP methods and agent-sh's event bus:
 - `session/new` → create core, set cwd
 - `session/prompt` → `agent:submit` event
 - `session/update` notifications ← `agent:response-chunk`, `agent:tool-started`, etc.
-- `session/request_permission` ↔ `permission:request` async pipe
+- Permission gating is not bridged — agent-sh runs tools without confirmation
+  unless a gating extension (e.g. interactive-prompts) is also loaded. To
+  surface ACP's `session/request_permission`, register tool advisors here
+  that call back into the ACP client.