agent-sh 0.10.3 → 0.12.0

package/dist/shell/shell.d.ts

@@ -34,11 +34,8 @@ export declare class Shell implements InputContext {
     isAgentActive(): boolean;
     writeToPty(data: string): void;
     /**
-     * Lightweight redraw: ask the shell to redraw its own prompt via a hidden
-     * ZLE widget (zsh) bound to \e[9999~. The shell knows how to draw its
-     * prompt correctly — we don't try to replay captured bytes.
-     *
-     * For bash, falls back to sending \n for a fresh prompt cycle.
+     * Ask the shell to redraw its own prompt in place via \e[9999~, which both
+     * zsh (ZLE widget) and bash (readline redraw-current-line) bind to repaint.
      */
     redrawPrompt(): void;
     /**

package/dist/shell/shell.js

@@ -87,7 +87,15 @@ export class Shell {
                 `[ -f "${userHome}/.bashrc" ] && source "${userHome}/.bashrc"`,
                 "",
                 "# agent-sh hooks (invisible OSC sequences for cwd + prompt detection)",
-                `PROMPT_COMMAND="\${PROMPT_COMMAND:+\$PROMPT_COMMAND;}__agent_sh_preexec_ran=0; ${osc7Cmd}; ${promptMarker}${showIndicator ? `; ${titleCmd}` : ""}"`,
+                "# Wrapped in a function because inlining printf \"...\" into",
+                "# PROMPT_COMMAND=\"...\" breaks the outer quoting.",
+                "__agent_sh_precmd() {",
+                `  ${osc7Cmd}`,
+                `  ${promptMarker}`,
+                ...(showIndicator ? [`  ${titleCmd}`] : []),
+                "  __agent_sh_preexec_ran=0",
+                "}",
+                `PROMPT_COMMAND="\${PROMPT_COMMAND:+\$PROMPT_COMMAND;}__agent_sh_precmd"`,
                 "",
                 "# Preexec hook via DEBUG trap: emit actual command text so agent-sh",
                 "# can track history-recalled and tab-completed commands accurately",
@@ -104,6 +112,12 @@ export class Shell {
                 "",
                 "# End-of-prompt marker: append to PS1 (\\[...\\] marks it zero-width)",
                 'case "$PS1" in *9998*) ;; *) PS1="${PS1}\\[\\e]9998;READY\\a\\]";; esac',
+                "",
+                "# Mirrors the zsh \\e[9999~ reset-prompt widget — used by agent-sh",
+                "# to repaint the prompt in place. All keymaps so `set -o vi` works.",
+                `bind -m emacs '"\\e[9999~":redraw-current-line' 2>/dev/null`,
+                `bind -m vi-insert '"\\e[9999~":redraw-current-line' 2>/dev/null`,
+                `bind -m vi-command '"\\e[9999~":redraw-current-line' 2>/dev/null`,
             ];
             fs.writeFileSync(path.join(this.tmpDir, ".bashrc"), bashrcLines.join("\n") + "\n");
             shellArgs = ["--rcfile", path.join(this.tmpDir, ".bashrc")];
@@ -190,16 +204,12 @@ export class Shell {
         this.ptyProcess.write(data);
     }
     /**
-     * Lightweight redraw: ask the shell to redraw its own prompt via a hidden
-     * ZLE widget (zsh) bound to \e[9999~. The shell knows how to draw its
-     * prompt correctly — we don't try to replay captured bytes.
-     *
-     * For bash, falls back to sending \n for a fresh prompt cycle.
+     * Ask the shell to redraw its own prompt in place via \e[9999~, which both
+     * zsh (ZLE widget) and bash (readline redraw-current-line) bind to repaint.
      */
     redrawPrompt() {
-        // A stale echoSkip or paused flag (left over from handleProcessingDone
-        // re-entering a mode) would swallow the redrawn prompt and make the
-        // terminal appear frozen. Reset both before emitting.
+        // Stale echoSkip/paused from handleProcessingDone re-entering a mode
+        // would swallow the redraw and freeze the terminal visually.
         this.echoSkip = false;
         this.paused = false;
         const result = this.bus.emitPipe("shell:redraw-prompt", {
@@ -207,14 +217,7 @@ export class Shell {
             handled: false,
         });
         if (!result.handled) {
-            if (this.isZsh) {
-                // Trigger the hidden ZLE widget — zle reset-prompt redraws cleanly
-                this.ptyProcess.write("\x1b[9999~");
-            }
-            else {
-                // Bash: no zle reset-prompt equivalent, use fresh prompt cycle
-                this.ptyProcess.write("\n");
-            }
+            this.ptyProcess.write("\x1b[9999~");
         }
     }
     /**

package/dist/types.d.ts

@@ -49,6 +49,31 @@ export interface AgentMode {
     /** Provider supports the reasoning_effort parameter. */
     supportsReasoningEffort?: boolean;
 }
+/**
+ * Backend-agnostic LLM interface exposed via `ctx.llm`. Backends fulfill it
+ * by defining an `llm:invoke` handler; those without an LLM leave
+ * `available` false and calls reject.
+ */
+export interface LlmMessage {
+    role: "system" | "user" | "assistant";
+    content: string;
+}
+export interface LlmSession {
+    send(message: string): Promise<string>;
+    history(): ReadonlyArray<LlmMessage>;
+}
+export interface LlmInterface {
+    readonly available: boolean;
+    ask(opts: {
+        query: string;
+        system?: string;
+        maxTokens?: number;
+    }): Promise<string>;
+    session(opts?: {
+        system?: string;
+        maxTokens?: number;
+    }): LlmSession;
+}
 export interface AgentShellConfig {
     shell?: string;
     model?: string;
@@ -102,6 +127,7 @@ export interface ExtensionContext {
     registerSkill: (name: string, description: string, filePath: string) => void;
     /** Remove a registered skill by name. */
     removeSkill: (name: string) => void;
+    llm: LlmInterface;
     /** Register a named handler. */
     define: (name: string, fn: (...args: any[]) => any) => void;
     /** Wrap a named handler. Receives `next` (original) + args. Returns an unadvise function. */

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

@@ -0,0 +1,7 @@
+/**
+ * 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;

package/dist/utils/llm-facade.js

@@ -0,0 +1,33 @@
+export function createLlmFacade(handlers) {
+    const invoke = (messages, maxTokens) => {
+        const result = handlers.call("llm:invoke", messages, { maxTokens });
+        if (result === undefined)
+            return Promise.reject(new Error("ctx.llm: no LLM backend available"));
+        return result;
+    };
+    return {
+        get available() { return handlers.list().includes("llm:invoke"); },
+        ask: ({ query, system, maxTokens }) => {
+            const messages = [];
+            if (system)
+                messages.push({ role: "system", content: system });
+            messages.push({ role: "user", content: query });
+            return invoke(messages, maxTokens);
+        },
+        session: (opts = {}) => {
+            const messages = [];
+            if (opts.system)
+                messages.push({ role: "system", content: opts.system });
+            const session = {
+                async send(message) {
+                    messages.push({ role: "user", content: message });
+                    const reply = await invoke(messages, opts.maxTokens);
+                    messages.push({ role: "assistant", content: reply });
+                    return reply;
+                },
+                history: () => messages.slice(),
+            };
+            return session;
+        },
+    };
+}

package/examples/extensions/wire-log.ts

@@ -0,0 +1,35 @@
+/**
+ * Dumps every LLM request + streamed chunk to $AGENT_SH_WIRE_DIR
+ * (default ~/.agent-sh/wire) for offline replay via curl. Paired files
+ * per turn: <stamp>.request.json and <stamp>.chunks.jsonl.
+ */
+import * as fs from "node:fs";
+import * as path from "node:path";
+import * as os from "node:os";
+import type { ExtensionContext } from "agent-sh/types";
+
+export default function activate(ctx: ExtensionContext): void {
+  const dir = process.env.AGENT_SH_WIRE_DIR
+    ?? path.join(os.homedir(), ".agent-sh", "wire");
+  fs.mkdirSync(dir, { recursive: true });
+
+  // llm:chunk has no back-pointer to its request, so anchor both on
+  // the timestamp set when llm:request fires.
+  let currentStamp: string | null = null;
+
+  ctx.bus.on("llm:request", (req) => {
+    currentStamp = new Date().toISOString().replace(/[:.]/g, "-");
+    fs.writeFileSync(
+      path.join(dir, `${currentStamp}.request.json`),
+      JSON.stringify(req, null, 2),
+    );
+  });
+
+  ctx.bus.on("llm:chunk", ({ chunk }) => {
+    if (!currentStamp) return;
+    fs.appendFileSync(
+      path.join(dir, `${currentStamp}.chunks.jsonl`),
+      JSON.stringify(chunk) + "\n",
+    );
+  });
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "agent-sh",
-  "version": "0.10.3",
+  "version": "0.12.0",
   "description": "A shell-first terminal where AI is one keystroke away",
   "type": "module",
   "main": "dist/core.js",
@@ -95,7 +95,7 @@
     "dev": "tsx src/index.ts",
     "build": "tsc",
     "start": "node dist/index.js",
-    "prepublishOnly": "npm run build"
+    "prepare": "npm run build"
   },
   "keywords": [
     "terminal",

package/dist/extensions/command-suggest.d.ts

@@ -1,10 +0,0 @@
-/**
- * Command suggestion extension (fast-path LLM feature).
- *
- * After a shell command fails (non-zero exit), uses LlmClient.complete()
- * to suggest a fix. Shows the suggestion below the prompt.
- *
- * Only active when an LLM client is available (registered by agent-backend).
- */
-import type { ExtensionContext } from "../types.js";
-export default function activate({ bus, call }: ExtensionContext): void;

package/dist/extensions/command-suggest.js

@@ -1,42 +0,0 @@
-export default function activate({ bus, call }) {
-    let suggesting = false;
-    bus.on("shell:command-done", ({ command, output, exitCode, cwd }) => {
-        if (exitCode === null || exitCode === 0)
-            return;
-        if (!command.trim())
-            return;
-        if (suggesting)
-            return; // don't stack suggestions
-        const llmClient = call("llm:get-client");
-        if (!llmClient)
-            return;
-        suggesting = true;
-        // Truncate output to avoid blowing up the prompt
-        const truncated = output.length > 1000
-            ? output.slice(-1000)
-            : output;
-        llmClient.complete({
-            messages: [
-                {
-                    role: "system",
-                    content: "You are a shell assistant. The user's command failed. " +
-                        "Suggest a fix as a single command. Just the command, no explanation, no backticks, no prefix. " +
-                        "If you can't suggest anything useful, reply with an empty string.",
-                },
-                {
-                    role: "user",
-                    content: `cwd: ${cwd}\n$ ${command}\n${truncated}\nexit code: ${exitCode}`,
-                },
-            ],
-            max_tokens: 150,
-        }).then((suggestion) => {
-            suggesting = false;
-            const trimmed = suggestion.trim().replace(/^`+|`+$/g, ""); // strip backticks
-            if (trimmed && trimmed.length < 500) {
-                bus.emit("ui:suggestion", { text: trimmed });
-            }
-        }).catch(() => {
-            suggesting = false;
-        });
-    });
-}