agent-sh 0.7.0 → 0.9.0

package/dist/index.js

@@ -1,16 +1,10 @@
 #!/usr/bin/env node
 import { spawn } from "node:child_process";
 import * as path from "node:path";
-import { Shell } from "./shell.js";
+import { Shell } from "./shell/shell.js";
 import { createCore } from "./core.js";
 import { palette as p } from "./utils/palette.js";
-import tuiRenderer from "./extensions/tui-renderer.js";
-import slashCommands from "./extensions/slash-commands.js";
-import fileAutocomplete from "./extensions/file-autocomplete.js";
-import shellRecall from "./extensions/shell-recall.js";
-import commandSuggest from "./extensions/command-suggest.js";
-import terminalBuffer from "./extensions/terminal-buffer.js";
-import overlayAgent from "./extensions/overlay-agent.js";
+import { loadBuiltinExtensions } from "./extensions/index.js";
 import { loadExtensions } from "./extension-loader.js";
 import { getSettings } from "./settings.js";
 import { discoverSkills } from "./agent/skills.js";
@@ -160,6 +154,13 @@ async function main() {
         const shellEnv = await captureShellEnvAsync(shellPath);
         if (Object.keys(shellEnv).length > 0) {
             Object.assign(baseEnv, mergeShellEnv(baseEnv, shellEnv));
+            // Expose captured env vars to process.env so extensions can read them.
+            // Only add vars not already present to avoid clobbering runtime state.
+            for (const [k, v] of Object.entries(baseEnv)) {
+                if (process.env[k] === undefined) {
+                    process.env[k] = v;
+                }
+            }
             if (process.env.DEBUG) {
                 console.error('[agent-sh] Shell environment captured');
             }
@@ -195,6 +196,7 @@ async function main() {
     await new Promise(resolve => setTimeout(resolve, 100));
     const shell = new Shell({
         bus,
+        handlers: core.handlers,
         cols,
         rows,
         shell: config.shell || process.env.SHELL || "/bin/bash",
@@ -203,9 +205,6 @@ async function main() {
             if (agentInfo) {
                 return { info: `${p.dim}${agentInfo.name}${agentInfo.model ? ` (${agentInfo.model})` : ""}${p.reset}` };
             }
-            if (core.llmClient) {
-                return { info: `${p.dim}agent-sh (${core.llmClient.model})${p.reset}` };
-            }
             return { info: "" };
         },
     });
@@ -229,13 +228,8 @@ async function main() {
         console.error('[agent-sh] Setting up extensions...');
     }
     const extCtx = core.extensionContext({ quit: cleanup });
-    tuiRenderer(extCtx);
-    slashCommands(extCtx);
-    fileAutocomplete(extCtx);
-    shellRecall(extCtx);
-    commandSuggest(extCtx);
-    terminalBuffer(extCtx);
-    overlayAgent(extCtx);
+    // Load built-in extensions (individually disableable via settings.disabledBuiltins)
+    await loadBuiltinExtensions(extCtx, getSettings().disabledBuiltins);
     // Load user extensions (may register alternative agent backends)
     if (process.env.DEBUG) {
         console.error('[agent-sh] Loading extensions...');
@@ -264,8 +258,8 @@ async function main() {
         const bannerW = Math.min(termW, 60);
         const productName = `${p.accent}${p.bold}agent-sh${p.reset}`;
         const info = agentInfo;
-        const backendName = info?.name ?? "agent-sh";
-        const model = info?.model ?? core.llmClient?.model;
+        const backendName = info?.name ?? "ash";
+        const model = info?.model;
         const provider = info?.provider;
         const modelValue = model
             ? provider ? `${model} [${provider}]` : model

package/dist/settings.d.ts

@@ -1,4 +1,13 @@
 export declare const CONFIG_DIR: string;
+/** Per-model capability overrides. */
+export interface ModelCapabilityConfig {
+    /** Model identifier. */
+    id: string;
+    /** Whether the model supports reasoning/thinking tokens. */
+    reasoning?: boolean;
+    /** Context window size in tokens for this specific model. */
+    contextWindow?: number;
+}
 /** Provider profile — a named LLM configuration. */
 export interface ProviderConfig {
     /** API key (supports $ENV_VAR syntax for runtime expansion). */
@@ -7,8 +16,8 @@ export interface ProviderConfig {
     baseURL?: string;
     /** Default model to use. Falls back to first entry in models list. */
     defaultModel?: string;
-    /** Models available for cycling. */
-    models?: string[];
+    /** Models available for cycling. Plain strings or objects with capabilities. */
+    models?: (string | ModelCapabilityConfig)[];
     /** Context window size in tokens (e.g. 128000). Used for usage display. */
     contextWindow?: number;
 }
@@ -35,18 +44,32 @@ export interface Settings {
     shellTailLines?: number;
     /** Max lines for recall expand before requiring line ranges. */
     recallExpandMaxLines?: number;
+    /** Fraction of content budget allocated to shell context (0-1, default 0.35). */
+    shellContextRatio?: number;
+    /** Max history file size in bytes (default: 102400 = 100KB). */
+    historyMaxBytes?: number;
+    /** Number of prior history entries to load on startup (default: 50). */
+    historyStartupEntries?: number;
+    /** Max nuclear entries kept in-context before flushing to history file (default: 200). */
+    nuclearMaxEntries?: number;
+    /** Auto-compact threshold as fraction of conversation budget (0-1, default 0.5). */
+    autoCompactThreshold?: number;
     /** Max command output lines shown inline in TUI. */
     maxCommandOutputLines?: number;
     /** Max read tool output lines shown inline in TUI (0 = hide). */
     readOutputMaxLines?: number;
     /** Max diff lines shown before "ctrl+o to expand". */
     diffMaxLines?: number;
+    /** Tool protocol: "api" (all tools), "deferred" (extensions via meta-tool), "inline" (text). */
+    toolMode?: "api" | "deferred" | "inline";
     /** Additional directories to scan for skills (supports ~ expansion). */
     skillPaths?: string[];
     /** Show a startup banner when agent-sh launches. */
     startupBanner?: boolean;
     /** Show a subtle agent-sh indicator in the shell prompt. */
     promptIndicator?: boolean;
+    /** Names of built-in extensions to disable (e.g. ["command-suggest"]). */
+    disabledBuiltins?: string[];
 }
 declare const DEFAULTS: Required<Settings>;
 /** Load settings from disk (cached after first call). */

package/dist/settings.js

@@ -14,19 +14,26 @@ const DEFAULTS = {
     historySize: 500,
     providers: {},
     defaultProvider: undefined,
-    defaultBackend: "agent-sh",
+    defaultBackend: "ash",
+    toolMode: "api",
     contextWindowSize: 20,
     contextBudget: 16384,
     shellTruncateThreshold: 10,
     shellHeadLines: 5,
     shellTailLines: 5,
     recallExpandMaxLines: 100,
+    shellContextRatio: 0.35,
+    historyMaxBytes: 102400,
+    historyStartupEntries: 50,
+    nuclearMaxEntries: 200,
+    autoCompactThreshold: 0.5,
     maxCommandOutputLines: 3,
     readOutputMaxLines: 10,
     diffMaxLines: 20,
     skillPaths: [],
     startupBanner: true,
     promptIndicator: true,
+    disabledBuiltins: [],
 };
 let cached = null;
 /** Load settings from disk (cached after first call). */
@@ -86,15 +93,29 @@ export function resolveProvider(name) {
     const provider = settings.providers?.[name];
     if (!provider)
         return null;
-    const models = provider.models ?? (provider.defaultModel ? [provider.defaultModel] : []);
-    const defaultModel = provider.defaultModel ?? models[0];
+    const rawModels = provider.models ?? (provider.defaultModel ? [provider.defaultModel] : []);
+    const modelIds = [];
+    const caps = new Map();
+    for (const m of rawModels) {
+        if (typeof m === "string") {
+            modelIds.push(m);
+        }
+        else {
+            modelIds.push(m.id);
+            if (m.reasoning !== undefined || m.contextWindow !== undefined) {
+                caps.set(m.id, { reasoning: m.reasoning, contextWindow: m.contextWindow });
+            }
+        }
+    }
+    const defaultModel = provider.defaultModel ?? modelIds[0];
     return {
         id: name,
         apiKey: provider.apiKey ? expandEnvVars(provider.apiKey) : undefined,
         baseURL: provider.baseURL,
         defaultModel,
-        models: models.length ? models : (defaultModel ? [defaultModel] : []),
+        models: modelIds.length ? modelIds : (defaultModel ? [defaultModel] : []),
         contextWindow: provider.contextWindow,
+        modelCapabilities: caps.size > 0 ? caps : undefined,
     };
 }
 /** Get all configured provider names. */

package/dist/{input-handler.d.ts → shell/input-handler.d.ts}

@@ -1,4 +1,4 @@
-import type { EventBus } from "./event-bus.js";
+import type { EventBus } from "../event-bus.js";
 /**
  * Narrow contract between InputHandler and its host (Shell).
  * InputHandler never touches the PTY or EventBus directly —

package/dist/{input-handler.js → shell/input-handler.js}

@@ -1,9 +1,9 @@
 import * as fs from "node:fs";
 import * as path from "node:path";
-import { visibleLen } from "./utils/ansi.js";
-import { palette as p } from "./utils/palette.js";
-import { LineEditor } from "./utils/line-editor.js";
-import { CONFIG_DIR, getSettings } from "./settings.js";
+import { visibleLen } from "../utils/ansi.js";
+import { palette as p } from "../utils/palette.js";
+import { LineEditor } from "../utils/line-editor.js";
+import { CONFIG_DIR, getSettings } from "../settings.js";
 const HISTORY_FILE = path.join(CONFIG_DIR, "history");
 export class InputHandler {
     ctx;
@@ -86,22 +86,24 @@ export class InputHandler {
         const icon = this.activeMode?.promptIcon ?? "❯";
         const promptPrefix = infoPrefix + p.warning + p.bold + icon + " " + p.reset;
         const promptVisLen = visibleLen(infoPrefix) + visibleLen(icon) + 1; // icon + space
-        if (!showBuffer || !this.editor.buffer.includes("\n")) {
+        const display = showBuffer ? this.editor.displayText : "";
+        const dCursor = showBuffer ? this.editor.displayCursor : 0;
+        if (!showBuffer || !display.includes("\n")) {
             // Single-line: simple rendering
-            const bufferText = showBuffer ? p.accent + this.editor.buffer + p.reset : "";
+            const bufferText = showBuffer ? p.accent + display + p.reset : "";
             process.stdout.write(promptPrefix + bufferText);
-            const bufferVisLen = showBuffer ? this.editor.buffer.length : 0;
+            const bufferVisLen = display.length;
             const totalVisLen = promptVisLen + bufferVisLen;
             this.promptWrappedLines = totalVisLen > 0 ? Math.floor((totalVisLen - 1) / termW) : 0;
             // Position cursor within the buffer
-            if (showBuffer && this.editor.cursor < this.editor.buffer.length) {
-                const charsAfterCursor = this.editor.buffer.length - this.editor.cursor;
+            if (showBuffer && dCursor < display.length) {
+                const charsAfterCursor = display.length - dCursor;
                 process.stdout.write(`\x1b[${charsAfterCursor}D`);
             }
         }
         else {
             // Multi-line: render each line with continuation indent
-            const lines = this.editor.buffer.split("\n");
+            const lines = display.split("\n");
             const indent = " ".repeat(promptVisLen);
             let totalTermLines = 0;
             for (let li = 0; li < lines.length; li++) {
@@ -116,8 +118,8 @@ export class InputHandler {
                 totalTermLines += lineVisLen > 0 ? Math.ceil(lineVisLen / termW) : 1;
             }
             this.promptWrappedLines = totalTermLines - 1;
-            // Position cursor: find which line and column the cursor is on
-            let charsRemaining = this.editor.cursor;
+            // Position cursor: find which display line and column the cursor is on
+            let charsRemaining = dCursor;
             let cursorLine = 0;
             for (let li = 0; li < lines.length; li++) {
                 if (charsRemaining <= lines[li].length) {
@@ -127,13 +129,31 @@ export class InputHandler {
                 charsRemaining -= lines[li].length + 1; // +1 for \n
                 cursorLine = li + 1;
             }
-            // Move from end position to cursor position
-            const linesFromEnd = lines.length - 1 - cursorLine;
-            if (linesFromEnd > 0) {
-                process.stdout.write(`\x1b[${linesFromEnd}A`);
+            // Compute terminal rows for cursor positioning (not logical lines)
+            // Each logical line may wrap across multiple terminal rows.
+            const cursorColAbs = promptVisLen + charsRemaining;
+            const cursorTermRow = Math.floor(cursorColAbs / termW);
+            // Count terminal rows occupied by lines after cursor's logical line
+            let termRowsAfterCursor = 0;
+            for (let li = cursorLine + 1; li < lines.length; li++) {
+                const lineVisLen = promptVisLen + lines[li].length;
+                termRowsAfterCursor += lineVisLen > 0 ? Math.ceil(lineVisLen / termW) : 1;
+            }
+            // Also count remaining terminal rows on cursor's own logical line
+            const cursorLineVisLen = promptVisLen + lines[cursorLine].length;
+            const cursorLineTotalRows = cursorLineVisLen > 0 ? Math.ceil(cursorLineVisLen / termW) : 1;
+            const rowsAfterCursorInLine = cursorLineTotalRows - 1 - cursorTermRow;
+            const totalRowsFromEnd = termRowsAfterCursor + rowsAfterCursorInLine;
+            if (totalRowsFromEnd > 0) {
+                process.stdout.write(`\x1b[${totalRowsFromEnd}A`);
+            }
+            const cursorCol = cursorColAbs % termW;
+            if (cursorCol > 0) {
+                process.stdout.write(`\r\x1b[${cursorCol}C`);
+            }
+            else {
+                process.stdout.write(`\r`);
             }
-            const cursorCol = (cursorLine === 0 ? promptVisLen : promptVisLen) + charsRemaining;
-            process.stdout.write(`\r\x1b[${cursorCol}C`);
         }
     }
     handleInput(data) {
@@ -249,16 +269,17 @@ export class InputHandler {
         this.activeMode = mode;
         this.editor.clear();
         // Enable kitty keyboard protocol (progressive enhancement flag 1)
-        // so Shift+Enter sends \x1b[13;2u instead of plain \r
-        process.stdout.write("\x1b[>1u");
+        // so Shift+Enter sends \x1b[13;2u instead of plain \r.
+        // Enable bracket paste mode so pasted text doesn't trigger submit.
+        process.stdout.write("\x1b[>1u\x1b[?2004h");
         this.writeModePromptLine(false);
     }
     exitMode() {
         this.dismissAutocomplete();
         this.activeMode = null;
         this.editor.clear();
-        // Disable kitty keyboard protocol
-        process.stdout.write("\x1b[<u");
+        // Disable kitty keyboard protocol and bracket paste mode
+        process.stdout.write("\x1b[<u\x1b[?2004l");
         this.clearPromptArea();
         this.printPrompt();
     }
@@ -294,7 +315,7 @@ export class InputHandler {
         this.updateAutocomplete();
     }
     updateAutocomplete() {
-        const buf = this.editor.buffer;
+        const buf = this.editor.text;
         let command = null;
         let commandArgs = null;
         if (buf.startsWith("/")) {
@@ -350,7 +371,7 @@ export class InputHandler {
             : `${indicator} `;
         const icon = this.activeMode?.promptIcon ?? "❯";
         const promptVisLen = visibleLen(infoPrefix) + visibleLen(icon) + 1;
-        const col = promptVisLen + this.editor.cursor;
+        const col = promptVisLen + this.editor.displayCursor;
         process.stdout.write(`\r\x1b[${col}C`);
     }
     applyAutocomplete() {
@@ -359,18 +380,16 @@ export class InputHandler {
         const selected = this.autocompleteItems[this.autocompleteIndex];
         if (!selected)
             return;
-        const atPos = this.editor.buffer.lastIndexOf("@");
+        const atPos = this.editor.text.lastIndexOf("@");
         const isFileAc = atPos >= 0 &&
-            (atPos === 0 || this.editor.buffer[atPos - 1] === " ") &&
-            !this.editor.buffer.slice(atPos + 1).includes(" ");
+            (atPos === 0 || this.editor.text[atPos - 1] === " ") &&
+            !this.editor.text.slice(atPos + 1).includes(" ");
         if (isFileAc) {
-            this.editor.buffer =
-                this.editor.buffer.slice(0, atPos) + "@" + selected.name;
+            this.editor.setText(this.editor.text.slice(0, atPos) + "@" + selected.name);
         }
         else {
-            this.editor.buffer = selected.name;
+            this.editor.setText(selected.name);
         }
-        this.editor.cursor = this.editor.buffer.length;
         this.clearAutocompleteLines();
         this.autocompleteActive = false;
         this.autocompleteItems = [];
@@ -419,8 +438,8 @@ export class InputHandler {
             switch (act.action) {
                 case "changed": {
                     // If the buffer is exactly a trigger char for a different mode, switch to it
-                    const switchMode = this.modes.get(this.editor.buffer);
-                    if (this.editor.buffer.length === 1 && switchMode && switchMode !== this.activeMode) {
+                    const switchMode = this.modes.get(this.editor.text);
+                    if (this.editor.text.length === 1 && switchMode && switchMode !== this.activeMode) {
                         this.dismissAutocomplete();
                         this.clearPromptArea();
                         this.activeMode = switchMode;
@@ -437,10 +456,10 @@ export class InputHandler {
                     if (this.autocompleteActive) {
                         this.applyAutocomplete();
                     }
-                    // Use editor.buffer (not act.buffer) so autocomplete selections
+                    // Use editor.text (not act.buffer) so autocomplete selections
                     // take effect — act.buffer is a stale snapshot from before
-                    // applyAutocomplete() updated the buffer.
-                    const query = this.editor.buffer.trim();
+                    // applyAutocomplete() updated the editor.
+                    const query = this.editor.text.trim();
                     if (query) {
                         // Add to history (avoid consecutive duplicates)
                         if (this.history.length === 0 || this.history[this.history.length - 1] !== query) {
@@ -452,7 +471,7 @@ export class InputHandler {
                     this.savedBuffer = "";
                     this.clearAutocompleteLines();
                     this.clearPromptArea();
-                    process.stdout.write("\x1b[<u"); // disable kitty keyboard protocol
+                    process.stdout.write("\x1b[<u\x1b[?2004l"); // disable kitty + bracket paste
                     const currentMode = this.activeMode;
                     this.activeMode = null;
                     this.editor.clear();
@@ -506,14 +525,13 @@ export class InputHandler {
                     }
                     else if (this.history.length > 0) {
                         if (this.historyIndex === -1) {
-                            this.savedBuffer = this.editor.buffer;
+                            this.savedBuffer = this.editor.text;
                             this.historyIndex = this.history.length - 1;
                         }
                         else if (this.historyIndex > 0) {
                             this.historyIndex--;
                         }
-                        this.editor.buffer = this.history[this.historyIndex];
-                        this.editor.cursor = this.editor.buffer.length;
+                        this.editor.setText(this.history[this.historyIndex]);
                         this.clearAutocompleteLines();
                         this.writeModePromptLine();
                     }
@@ -531,13 +549,12 @@ export class InputHandler {
                     else if (this.historyIndex !== -1) {
                         if (this.historyIndex < this.history.length - 1) {
                             this.historyIndex++;
-                            this.editor.buffer = this.history[this.historyIndex];
+                            this.editor.setText(this.history[this.historyIndex]);
                         }
                         else {
                             this.historyIndex = -1;
-                            this.editor.buffer = this.savedBuffer;
+                            this.editor.setText(this.savedBuffer);
                         }
-                        this.editor.cursor = this.editor.buffer.length;
                         this.clearAutocompleteLines();
                         this.writeModePromptLine();
                     }

package/dist/{output-parser.d.ts → shell/output-parser.d.ts}

@@ -1,4 +1,4 @@
-import type { EventBus } from "./event-bus.js";
+import type { EventBus } from "../event-bus.js";
 /**
  * Parses PTY output to detect command boundaries, track cwd,
  * and emit shell events. Owns the command lifecycle state.

package/dist/{output-parser.js → shell/output-parser.js}

@@ -1,4 +1,4 @@
-import { stripAnsi } from "./utils/ansi.js";
+import { stripAnsi } from "../utils/ansi.js";
 /**
  * Parses PTY output to detect command boundaries, track cwd,
  * and emit shell events. Owns the command lifecycle state.

package/dist/{shell.d.ts → shell/shell.d.ts}

@@ -1,8 +1,13 @@
-import type { EventBus } from "./event-bus.js";
+import type { EventBus } from "../event-bus.js";
 import { type InputContext } from "./input-handler.js";
+export interface ShellHandlers {
+    define: (name: string, fn: (...args: any[]) => any) => void;
+    call: (name: string, ...args: any[]) => any;
+}
 export declare class Shell implements InputContext {
     private ptyProcess;
     private bus;
+    private handlers;
     private inputHandler;
     private outputParser;
     private paused;
@@ -14,6 +19,7 @@ export declare class Shell implements InputContext {
     private tmpDir?;
     constructor(opts: {
         bus: EventBus;
+        handlers: ShellHandlers;
         onShowAgentInfo?: () => {
             info: string;
             model?: string;
@@ -43,7 +49,7 @@ export declare class Shell implements InputContext {
      * Routed through shell:redraw-prompt pipe so extensions (e.g. overlay)
      * can suppress it by setting `handled: true`.
      */
-    freshPrompt(): void;
+    freshPrompt(): boolean;
     onCommandEntered(command: string, cwd: string): void;
     private setupOutput;
     private setupInput;

package/dist/{shell.js → shell/shell.js}

@@ -4,11 +4,12 @@ import * as path from "path";
 import * as pty from "node-pty";
 import { InputHandler } from "./input-handler.js";
 import { OutputParser } from "./output-parser.js";
-import { getSettings } from "./settings.js";
-import { RefCounter } from "./utils/output-writer.js";
+import { getSettings } from "../settings.js";
+import { RefCounter } from "../utils/output-writer.js";
 export class Shell {
     ptyProcess;
     bus;
+    handlers;
     inputHandler;
     outputParser;
     paused = false;
@@ -139,6 +140,7 @@ export class Shell {
             }
         }
         this.bus = opts.bus;
+        this.handlers = opts.handlers;
         this.outputParser = new OutputParser(opts.bus, opts.cwd);
         // Ensure temp dir cleanup on abnormal exit (SIGKILL won't fire this,
         // but it covers uncaught exceptions and normal process.exit paths)
@@ -163,6 +165,10 @@ export class Shell {
         this.bus.on("shell:pty-write", ({ data }) => {
             this.ptyProcess.write(data);
         });
+        // Allow extensions to resize the PTY (sends SIGWINCH to child)
+        this.bus.on("shell:pty-resize", ({ cols, rows }) => {
+            this.ptyProcess.resize(cols, rows);
+        });
         // Ref-counted stdout hold — overlay extensions suppress PTY output
         this.bus.on("shell:stdout-hold", () => { this.stdoutHold.increment(); });
         this.bus.on("shell:stdout-release", () => { this.stdoutHold.decrement(); });
@@ -221,7 +227,9 @@ export class Shell {
         });
         if (!result.handled) {
             this.ptyProcess.write("\n");
+            return true;
         }
+        return false;
     }
     onCommandEntered(command, cwd) {
         this.outputParser.onCommandEntered(command, cwd);
@@ -261,18 +269,28 @@ export class Shell {
      * zero frontend knowledge; any frontend can subscribe to the same events.
      */
     setupAgentLifecycle() {
-        this.bus.on("agent:processing-start", () => {
+        // Default agent lifecycle: pause the shell while the agent works,
+        // then redraw the prompt when done. Extensions advise these handlers
+        // to change behavior (e.g. tmux split keeps the shell interactive).
+        this.handlers.define("shell:on-processing-start", () => {
             this.agentActive = true;
             this.paused = true;
         });
-        this.bus.on("agent:processing-done", () => {
+        this.handlers.define("shell:on-processing-done", () => {
             this.paused = false;
             this.agentActive = false;
-            this.echoSkip = true;
             if (!this.inputHandler.handleProcessingDone()) {
-                this.freshPrompt();
+                if (this.freshPrompt()) {
+                    this.echoSkip = true;
+                }
             }
         });
+        this.bus.on("agent:processing-start", () => {
+            this.handlers.call("shell:on-processing-start");
+        });
+        this.bus.on("agent:processing-done", () => {
+            this.handlers.call("shell:on-processing-done");
+        });
         // Permission prompts need stdout unpaused so the interactive UI renders,
         // then re-paused after the decision.
         this.bus.on("permission:request", () => {