agent-sh 0.12.26 → 0.13.0

package/dist/shell/strategies/zsh.js

@@ -0,0 +1,72 @@
+import * as fs from "fs";
+import * as path from "path";
+const OSC7_CMD = 'printf "\\e]7;file://%s%s\\a" "$(hostname)" "$PWD"';
+const TITLE_CMD = 'printf "\\e]0;⚡ agent-sh: %s\\a" "${PWD/#$HOME/~}"';
+export const zshStrategy = {
+    name: "zsh",
+    matches(shellPath) {
+        return path.basename(shellPath).includes("zsh");
+    },
+    prepareSpawn(opts) {
+        const { tmpDirRoot, instanceTag, showIndicator, env, userHome } = opts;
+        // Use ZDOTDIR to source user's real config, then append our hooks via
+        // precmd_functions (additive — doesn't clobber p10k/omz).
+        const tmpDir = fs.mkdtempSync(path.join(tmpDirRoot, "agent-sh-"));
+        const userZdotdir = env.ZDOTDIR || env.HOME || userHome;
+        const promptMarker = `printf "\\e]9999;${instanceTag};PROMPT\\a"`;
+        const lines = [
+            `ZDOTDIR="${userZdotdir}"`,
+            `[ -f "${userZdotdir}/.zshrc" ] && source "${userZdotdir}/.zshrc"`,
+            "",
+            "# agent-sh hooks (invisible OSC sequences for cwd + prompt detection)",
+            "__agent_sh_precmd() {",
+            `  ${OSC7_CMD}`,
+            `  ${promptMarker}`,
+            ...(showIndicator ? [`  ${TITLE_CMD}`] : []),
+            "}",
+            "precmd_functions+=(__agent_sh_precmd)",
+            "",
+            "# Preexec hook: emit actual command text so agent-sh can track",
+            "# history-recalled and tab-completed commands accurately",
+            "__agent_sh_preexec() {",
+            `  printf "\\e]9997;${instanceTag};%s\\a" "$1"`,
+            "}",
+            "preexec_functions+=(__agent_sh_preexec)",
+            "",
+            "# End-of-prompt marker via zle-line-init (fires after prompt is rendered)",
+            "# Chain onto existing widget (p10k uses zle-line-init) rather than clobbering",
+            'if (( ${+widgets[zle-line-init]} )); then',
+            "  zle -A zle-line-init __agent_sh_orig_line_init",
+            "  __agent_sh_line_init() {",
+            "    zle __agent_sh_orig_line_init",
+            `    printf "\\e]9998;${instanceTag};READY\\a"`,
+            "  }",
+            "else",
+            "  __agent_sh_line_init() {",
+            `    printf "\\e]9998;${instanceTag};READY\\a"`,
+            "  }",
+            "fi",
+            "zle -N zle-line-init __agent_sh_line_init",
+            "",
+            "# Hidden widget to trigger prompt redraw from Node.js side",
+            "# Bound to an unused escape sequence that no real key produces",
+            "__agent_sh_redraw() {",
+            "  zle reset-prompt",
+            "}",
+            "zle -N __agent_sh_redraw",
+            "bindkey '\\e[9999~' __agent_sh_redraw",
+        ];
+        fs.writeFileSync(path.join(tmpDir, ".zshrc"), lines.join("\n") + "\n");
+        return {
+            args: ["--no-globalrcs"],
+            envOverrides: { ZDOTDIR: tmpDir },
+            tmpDir,
+        };
+    },
+    envCaptureCommand() {
+        return "source ~/.zshrc 2>/dev/null; env -0";
+    },
+    redrawEscape() {
+        return "\x1b[9999~";
+    },
+};

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 {
@@ -147,7 +147,8 @@ export declare class FloatingPanel {
      *   - `{prefix}:render-border-bottom(ctx: FrameContext) -> string`
      *   - `{prefix}:composite-row(content: string, bgLine: string|null, boxLeft: number, boxW: number, cols: number) -> string`
      *   - `{prefix}:submit(query: string) -> void`
-     *   - `{prefix}:dismiss() -> void`
+     *   - `{prefix}:hide() -> void`    (screen down; conversation state preserved)
+     *   - `{prefix}:reset() -> void`   (conversation state cleared)
      *   - `{prefix}:show() -> void`
      *   - `{prefix}:input(data: string) -> boolean`
      *   - `{prefix}:build-row(content: string, width: number) -> string`
@@ -177,6 +178,9 @@ export declare class FloatingPanel {
     private wrapCacheWidth;
     private passthroughTimer;
     private prevSerialized;
+    private autocompleteItems;
+    private autocompleteIndex;
+    private autocompleteActive;
     constructor(bus: EventBus, config: FloatingPanelConfig, handlers?: HandlerRegistry);
     private registerDefaultHandlers;
     private wireEvents;
@@ -196,8 +200,10 @@ export declare class FloatingPanel {
     hide(): void;
     /** Show the panel again after hide(), preserving conversation. */
     show(): void;
-    /** Fully destroy the panel, resetting all state. */
-    dismiss(): void;
+    /** End the conversation: screen down and all buffered state cleared. */
+    reset(): void;
+    /** Screen-only teardown; conversation state is left untouched. */
+    private teardownToHidden;
     /** Common screen enter logic shared by open() and show(). */
     private enterScreen;
     appendText(text: string): void;
@@ -213,8 +219,14 @@ export declare class FloatingPanel {
     scrollDown(lines?: number): void;
     getInput(): string;
     requestRender(): void;
+    private updateAutocomplete;
+    private applyAutocomplete;
+    private clearAutocomplete;
     private handleIntercept;
-    /** Handle scroll input. Returns true if consumed. */
+    /**
+     * Handle scroll input. Returns true if consumed.
+     * Pass `includeArrows=false` in input phase so arrows reach the editor.
+     */
     private handleScroll;
     private handleInputKey;
     /** Compute box geometry from config + current viewport. */