agent-sh 0.3.1 → 0.5.0

package/dist/input-handler.js

@@ -8,7 +8,10 @@ const HISTORY_FILE = path.join(CONFIG_DIR, "history");
 export class InputHandler {
     ctx;
     lineBuffer = "";
-    agentInputMode = false;
+    activeMode = null;
+    pendingReturnMode = null; // mode id to return to after processing
+    modes = new Map(); // keyed by trigger char
+    modesById = new Map(); // keyed by id
     editor = new LineEditor();
     autocompleteActive = false;
     autocompleteIndex = 0;
@@ -28,9 +31,23 @@ export class InputHandler {
         this.loadHistory();
         // Re-render prompt when config changes (e.g. thinking level cycled)
         this.bus.on("config:changed", () => {
-            if (this.agentInputMode)
-                this.writeAgentPromptLine();
+            if (this.activeMode)
+                this.writeModePromptLine();
         });
+        // Listen for mode registrations from extensions
+        this.bus.on("input-mode:register", (config) => {
+            this.registerMode(config);
+        });
+    }
+    registerMode(config) {
+        if (this.modes.has(config.trigger)) {
+            this.bus.emit("ui:error", {
+                message: `Input mode "${config.id}" cannot register trigger "${config.trigger}" — already taken by "${this.modes.get(config.trigger).id}"`,
+            });
+            return;
+        }
+        this.modes.set(config.trigger, config);
+        this.modesById.set(config.id, config);
     }
     loadHistory() {
         try {
@@ -52,8 +69,8 @@ export class InputHandler {
             // Non-critical — ignore write failures
         }
     }
-    /** Write the agent prompt line with cursor at the correct position. */
-    writeAgentPromptLine(showBuffer = true) {
+    /** Write the mode prompt line with cursor at the correct position. */
+    writeModePromptLine(showBuffer = true) {
         const termW = process.stdout.columns || 80;
         // Move cursor to the start of the prompt area (first line of wrapped content)
         if (this.promptWrappedLines > 0) {
@@ -62,9 +79,13 @@ export class InputHandler {
         // Clear from here to end of screen — removes current + all wrapped lines below
         process.stdout.write("\r\x1b[J");
         const agentInfo = this.onShowAgentInfo();
-        const infoPrefix = agentInfo.info ? `${agentInfo.info} ` : "";
-        const promptPrefix = infoPrefix + p.warning + p.bold + "❯ " + p.reset;
-        const promptVisLen = visibleLen(infoPrefix) + 2; // "❯ "
+        const indicator = this.activeMode?.indicator ?? "●";
+        const infoPrefix = agentInfo.info
+            ? `${agentInfo.info} ${p.success}${indicator}${p.reset} `
+            : `${p.success}${indicator}${p.reset} `;
+        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")) {
             // Single-line: simple rendering
             const bufferText = showBuffer ? p.accent + this.editor.buffer + p.reset : "";
@@ -127,7 +148,7 @@ export class InputHandler {
             return;
         }
         // Intercept control chars for TUI (Ctrl+T, Ctrl+O) — don't pass to PTY
-        if (data.length === 1 && data.charCodeAt(0) < 32 && !this.agentInputMode) {
+        if (data.length === 1 && data.charCodeAt(0) < 32 && !this.activeMode) {
             const code = data.charCodeAt(0);
             // Keys consumed by TUI extensions
             if (code === 0x14 || code === 0x0f) { // Ctrl+T, Ctrl+O
@@ -139,9 +160,9 @@ export class InputHandler {
                 this.bus.emit("input:keypress", { key: data });
             }
         }
-        // If in agent input mode (typing a query after ">")
-        if (this.agentInputMode) {
-            this.handleAgentInput(data);
+        // If in an input mode (typing a query)
+        if (this.activeMode) {
+            this.handleModeInput(data);
             return;
         }
         for (let i = 0; i < data.length; i++) {
@@ -166,15 +187,52 @@ export class InputHandler {
                 this.lineBuffer = "";
                 this.ctx.writeToPty(ch);
             }
+            else if (ch === "\x1b") {
+                // Escape sequence — forward the entire sequence to the PTY but
+                // don't let it corrupt lineBuffer.  Skip CSI (ESC [ ... final)
+                // and SS3 (ESC O <char>) sequences; anything else: just ESC.
+                let seq = ch;
+                if (i + 1 < data.length) {
+                    const next = data[i + 1];
+                    if (next === "[") {
+                        // CSI: ESC [ (params) (intermediates) final_byte
+                        seq += next;
+                        i++;
+                        while (i + 1 < data.length && data[i + 1].charCodeAt(0) < 0x40) {
+                            i++;
+                            seq += data[i];
+                        }
+                        if (i + 1 < data.length) {
+                            i++;
+                            seq += data[i];
+                        } // final byte
+                    }
+                    else if (next === "O") {
+                        // SS3: ESC O <char>
+                        seq += next;
+                        i++;
+                        if (i + 1 < data.length) {
+                            i++;
+                            seq += data[i];
+                        }
+                    }
+                    else {
+                        // ESC + single char (alt-key, etc.)
+                        seq += next;
+                        i++;
+                    }
+                }
+                this.ctx.writeToPty(seq);
+            }
             else if (ch.charCodeAt(0) < 32 && ch !== "\t") {
-                this.lineBuffer = "";
                 this.ctx.writeToPty(ch);
             }
             else {
-                // Check if ">" at start of empty line → enter agent input mode
+                // Check if trigger char at start of empty line → enter that mode
                 // But not if a foreground process (ssh, vim, etc.) is running
-                if (this.lineBuffer === "" && ch === ">" && !this.ctx.isForegroundBusy()) {
-                    this.enterAgentInputMode();
+                const mode = this.modes.get(ch);
+                if (this.lineBuffer === "" && mode && !this.ctx.isForegroundBusy()) {
+                    this.enterMode(mode);
                     return; // don't process remaining chars
                 }
                 this.lineBuffer += ch;
@@ -182,17 +240,17 @@ export class InputHandler {
             }
         }
     }
-    enterAgentInputMode() {
-        this.agentInputMode = true;
+    enterMode(mode) {
+        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");
-        this.writeAgentPromptLine(false);
+        this.writeModePromptLine(false);
     }
-    exitAgentInputMode() {
+    exitMode() {
         this.dismissAutocomplete();
-        this.agentInputMode = false;
+        this.activeMode = null;
         this.editor.clear();
         // Disable kitty keyboard protocol
         process.stdout.write("\x1b[<u");
@@ -210,14 +268,41 @@ export class InputHandler {
     printPrompt() {
         this.ctx.redrawPrompt();
     }
-    renderAgentInput() {
+    /**
+     * Called when agent processing completes. Returns true if the input
+     * handler re-entered a mode (so caller should skip shell prompt).
+     */
+    handleProcessingDone() {
+        if (this.pendingReturnMode) {
+            const mode = this.modesById.get(this.pendingReturnMode);
+            this.pendingReturnMode = null;
+            if (mode) {
+                this.enterMode(mode);
+                return true;
+            }
+        }
+        return false;
+    }
+    renderModeInput() {
         this.clearAutocompleteLines();
-        this.writeAgentPromptLine();
+        this.writeModePromptLine();
         this.updateAutocomplete();
     }
     updateAutocomplete() {
+        const buf = this.editor.buffer;
+        let command = null;
+        let commandArgs = null;
+        if (buf.startsWith("/")) {
+            const spaceIdx = buf.indexOf(" ");
+            if (spaceIdx !== -1) {
+                command = buf.slice(0, spaceIdx);
+                commandArgs = buf.slice(spaceIdx + 1);
+            }
+        }
         const { items } = this.bus.emitPipe("autocomplete:request", {
-            buffer: this.editor.buffer,
+            buffer: buf,
+            command,
+            commandArgs,
             items: [],
         });
         if (items.length > 0) {
@@ -252,9 +337,15 @@ export class InputHandler {
         if (this.autocompleteLines > 0) {
             process.stdout.write(`\x1b[${this.autocompleteLines}A`);
         }
+        // Reposition cursor: must match the layout in writeModePromptLine()
         const agentInfo = this.onShowAgentInfo();
-        const infoLength = visibleLen(agentInfo.info);
-        const col = infoLength + 2 + this.editor.cursor;
+        const indicator = this.activeMode?.indicator ?? "●";
+        const infoPrefix = agentInfo.info
+            ? `${agentInfo.info} ${indicator} `
+            : `${indicator} `;
+        const icon = this.activeMode?.promptIcon ?? "❯";
+        const promptVisLen = visibleLen(infoPrefix) + visibleLen(icon) + 1;
+        const col = promptVisLen + this.editor.cursor;
         process.stdout.write(`\r\x1b[${col}C`);
     }
     applyAutocomplete() {
@@ -279,7 +370,7 @@ export class InputHandler {
         this.autocompleteActive = false;
         this.autocompleteItems = [];
         this.autocompleteIndex = 0;
-        this.writeAgentPromptLine();
+        this.writeModePromptLine();
         if (isFileAc)
             this.updateAutocomplete();
     }
@@ -299,7 +390,7 @@ export class InputHandler {
         process.stdout.write("\x1b8"); // restore cursor
         this.autocompleteLines = 0;
     }
-    handleAgentInput(data) {
+    handleModeInput(data) {
         // Clear any pending escape timer — new data arrived
         if (this.escapeTimer) {
             clearTimeout(this.escapeTimer);
@@ -313,24 +404,38 @@ export class InputHandler {
                 this.escapeTimer = null;
                 const flushed = this.editor.flushPendingEscape();
                 if (flushed.length > 0)
-                    this.processAgentActions(flushed);
+                    this.processModeActions(flushed);
             }, 50);
         }
-        this.processAgentActions(actions);
+        this.processModeActions(actions);
     }
-    processAgentActions(actions) {
+    processModeActions(actions) {
         for (const act of actions) {
             switch (act.action) {
-                case "changed":
+                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) {
+                        this.dismissAutocomplete();
+                        this.clearPromptArea();
+                        this.activeMode = switchMode;
+                        this.editor.clear();
+                        this.writeModePromptLine(false);
+                        break;
+                    }
                     this.historyIndex = -1;
                     this.autocompleteIndex = 0;
-                    this.renderAgentInput();
+                    this.renderModeInput();
                     break;
+                }
                 case "submit": {
                     if (this.autocompleteActive) {
                         this.applyAutocomplete();
                     }
-                    const query = act.buffer.trim();
+                    // Use editor.buffer (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();
                     if (query) {
                         // Add to history (avoid consecutive duplicates)
                         if (this.history.length === 0 || this.history[this.history.length - 1] !== query) {
@@ -343,7 +448,8 @@ export class InputHandler {
                     this.clearAutocompleteLines();
                     this.clearPromptArea();
                     process.stdout.write("\x1b[<u"); // disable kitty keyboard protocol
-                    this.agentInputMode = false;
+                    const currentMode = this.activeMode;
+                    this.activeMode = null;
                     this.editor.clear();
                     this.dismissAutocomplete();
                     if (query && query.startsWith("/")) {
@@ -351,28 +457,29 @@ export class InputHandler {
                         const name = spaceIdx === -1 ? query : query.slice(0, spaceIdx);
                         const args = spaceIdx === -1 ? "" : query.slice(spaceIdx + 1).trim();
                         this.bus.emit("command:execute", { name, args });
-                        this.ctx.redrawPrompt();
+                        this.ctx.freshPrompt();
                     }
                     else if (query) {
-                        this.bus.emit("agent:submit", { query });
+                        this.pendingReturnMode = currentMode.returnToSelf ? currentMode.id : null;
+                        currentMode.onSubmit(query, this.bus);
                     }
                     else {
-                        this.exitAgentInputMode();
+                        this.exitMode();
                     }
                     return;
                 }
                 case "cancel":
                     if (this.autocompleteActive) {
                         this.dismissAutocomplete();
-                        this.writeAgentPromptLine();
+                        this.writeModePromptLine();
                     }
                     else {
-                        this.exitAgentInputMode();
+                        this.exitMode();
                     }
                     return;
                 case "delete-empty":
                     this.dismissAutocomplete();
-                    this.exitAgentInputMode();
+                    this.exitMode();
                     return;
                 case "tab":
                     if (this.autocompleteActive) {
@@ -389,7 +496,7 @@ export class InputHandler {
                                 ? this.autocompleteItems.length - 1
                                 : this.autocompleteIndex - 1;
                         this.clearAutocompleteLines();
-                        this.writeAgentPromptLine();
+                        this.writeModePromptLine();
                         this.renderAutocomplete();
                     }
                     else if (this.history.length > 0) {
@@ -402,7 +509,7 @@ export class InputHandler {
                         }
                         this.editor.buffer = this.history[this.historyIndex];
                         this.editor.cursor = this.editor.buffer.length;
-                        this.renderAgentInput();
+                        this.renderModeInput();
                     }
                     break;
                 case "arrow-down":
@@ -412,7 +519,7 @@ export class InputHandler {
                                 ? 0
                                 : this.autocompleteIndex + 1;
                         this.clearAutocompleteLines();
-                        this.writeAgentPromptLine();
+                        this.writeModePromptLine();
                         this.renderAutocomplete();
                     }
                     else if (this.historyIndex !== -1) {
@@ -425,7 +532,7 @@ export class InputHandler {
                             this.editor.buffer = this.savedBuffer;
                         }
                         this.editor.cursor = this.editor.buffer.length;
-                        this.renderAgentInput();
+                        this.renderModeInput();
                     }
                     break;
             }

package/dist/output-parser.d.ts

@@ -19,6 +19,13 @@ export declare class OutputParser {
     isPromptReady(): boolean;
     isForegroundBusy(): boolean;
     getCwd(): string;
+    /**
+     * Detect preexec marker (OSC 9997) emitted by the shell's preexec hook.
+     * This carries the actual command text from the shell — more reliable than
+     * the InputHandler's lineBuffer which can't track history recall or tab
+     * completion. Returns data with the OSC stripped out.
+     */
+    private handlePreexec;
     private parseOSC7;
     /**
      * Detect our custom prompt marker (OSC 9999) in the PTY stream.

package/dist/output-parser.js

@@ -17,6 +17,7 @@ export class OutputParser {
     /** Process a chunk of PTY output data. */
     processData(data) {
         this.parseOSC7(data);
+        data = this.handlePreexec(data);
         this.parsePromptMarker(data);
         this.parsePromptEnd(data);
     }
@@ -41,6 +42,32 @@ export class OutputParser {
         return this.cwd;
     }
     // ── Parsing ─────────────────────────────────────────────────
+    /**
+     * Detect preexec marker (OSC 9997) emitted by the shell's preexec hook.
+     * This carries the actual command text from the shell — more reliable than
+     * the InputHandler's lineBuffer which can't track history recall or tab
+     * completion. Returns data with the OSC stripped out.
+     */
+    handlePreexec(data) {
+        const marker = "\x1b]9997;";
+        const idx = data.indexOf(marker);
+        if (idx === -1)
+            return data;
+        const endIdx = data.indexOf("\x07", idx + marker.length);
+        if (endIdx === -1)
+            return data; // incomplete OSC, wait for next chunk
+        const command = data.slice(idx + marker.length, endIdx);
+        // Authoritative command from the shell — override any lineBuffer guess
+        this.lastCommand = command;
+        this.currentOutputCapture = ""; // discard echoed text accumulated before preexec
+        if (!this.foregroundBusy) {
+            this.foregroundBusy = true;
+            this.bus.emit("shell:foreground-busy", { busy: true });
+        }
+        this.bus.emit("shell:command-start", { command, cwd: this.cwd });
+        // Return only data after the OSC — everything before was the echo
+        return data.slice(endIdx + 1);
+    }
     parseOSC7(data) {
         const match = data.match(/\x1b\]7;file:\/\/[^/]*(\/[^\x07\x1b]*)/);
         if (match?.[1]) {

package/dist/settings.d.ts

@@ -1,9 +1,28 @@
 export declare const CONFIG_DIR: string;
+/** Provider profile — a named LLM configuration. */
+export interface ProviderConfig {
+    /** API key (supports $ENV_VAR syntax for runtime expansion). */
+    apiKey?: string;
+    /** Base URL for OpenAI-compatible API. */
+    baseURL?: string;
+    /** Default model to use. Falls back to first entry in models list. */
+    defaultModel?: string;
+    /** Models available for cycling. */
+    models?: string[];
+    /** Context window size in tokens (e.g. 128000). Used for usage display. */
+    contextWindow?: number;
+}
 export interface Settings {
     /** Extensions to load (npm packages or file paths). */
     extensions?: string[];
     /** Max agent query history entries to keep. */
     historySize?: number;
+    /** Named provider configurations. */
+    providers?: Record<string, ProviderConfig>;
+    /** Which provider to use by default. */
+    defaultProvider?: string;
+    /** Preferred agent backend (extension name, e.g. "pi", "claude-code"). */
+    defaultBackend?: string;
     /** Recent exchanges included in agent context window. */
     contextWindowSize?: number;
     /** Context budget in bytes (~4 chars per token). */
@@ -22,8 +41,12 @@ export interface Settings {
     readOutputMaxLines?: number;
     /** Max diff lines shown before "ctrl+o to expand". */
     diffMaxLines?: number;
-    /** Register MCP server for bridge tools (shell_cwd, user_shell, shell_recall). Default true. */
-    enableMcp?: boolean;
+    /** 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;
 }
 declare const DEFAULTS: Required<Settings>;
 /** Load settings from disk (cached after first call). */
@@ -41,4 +64,32 @@ export declare function getSettings(): Settings & typeof DEFAULTS;
 export declare function getExtensionSettings<T extends Record<string, unknown>>(namespace: string, defaults: T): T;
 /** Reset cached settings (for testing or after external edit). */
 export declare function reloadSettings(): void;
+/**
+ * Expand $ENV_VAR references in a string.
+ * Supports $VAR and ${VAR} syntax.
+ */
+export declare function expandEnvVars(value: string): string;
+/** Resolved provider ready for use (env vars expanded, defaults applied). */
+export interface ResolvedProvider {
+    id: string;
+    apiKey?: string;
+    baseURL?: string;
+    defaultModel?: string;
+    models: string[];
+    contextWindow?: number;
+    /** Provider supports the reasoning_effort parameter. Default: true. */
+    supportsReasoningEffort?: boolean;
+    /** Per-model capabilities, keyed by model id. */
+    modelCapabilities?: Map<string, {
+        reasoning?: boolean;
+        contextWindow?: number;
+    }>;
+}
+/**
+ * Resolve a provider config by name from settings.
+ * Returns null if provider not found.
+ */
+export declare function resolveProvider(name: string): ResolvedProvider | null;
+/** Get all configured provider names. */
+export declare function getProviderNames(): string[];
 export {};

package/dist/settings.js

@@ -12,6 +12,9 @@ const SETTINGS_PATH = path.join(CONFIG_DIR, "settings.json");
 const DEFAULTS = {
     extensions: [],
     historySize: 500,
+    providers: {},
+    defaultProvider: undefined,
+    defaultBackend: "agent-sh",
     contextWindowSize: 20,
     contextBudget: 16384,
     shellTruncateThreshold: 10,
@@ -21,7 +24,9 @@ const DEFAULTS = {
     maxCommandOutputLines: 3,
     readOutputMaxLines: 0,
     diffMaxLines: 20,
-    enableMcp: true,
+    skillPaths: [],
+    startupBanner: true,
+    promptIndicator: true,
 };
 let cached = null;
 /** Load settings from disk (cached after first call). */
@@ -31,7 +36,10 @@ export function getSettings() {
             const raw = fs.readFileSync(SETTINGS_PATH, "utf-8");
             cached = JSON.parse(raw);
         }
-        catch {
+        catch (err) {
+            if (err instanceof SyntaxError) {
+                console.error(`[agent-sh] Warning: invalid JSON in ${SETTINGS_PATH}: ${err.message}`);
+            }
             cached = {};
         }
     }
@@ -59,3 +67,38 @@ export function getExtensionSettings(namespace, defaults) {
 export function reloadSettings() {
     cached = null;
 }
+/**
+ * Expand $ENV_VAR references in a string.
+ * Supports $VAR and ${VAR} syntax.
+ */
+export function expandEnvVars(value) {
+    return value.replace(/\$\{([^}]+)\}|\$([A-Za-z_][A-Za-z0-9_]*)/g, (_, braced, plain) => {
+        const name = braced || plain;
+        return process.env[name] ?? "";
+    });
+}
+/**
+ * Resolve a provider config by name from settings.
+ * Returns null if provider not found.
+ */
+export function resolveProvider(name) {
+    const settings = getSettings();
+    const provider = settings.providers?.[name];
+    if (!provider)
+        return null;
+    const models = provider.models ?? (provider.defaultModel ? [provider.defaultModel] : []);
+    const defaultModel = provider.defaultModel ?? models[0];
+    return {
+        id: name,
+        apiKey: provider.apiKey ? expandEnvVars(provider.apiKey) : undefined,
+        baseURL: provider.baseURL,
+        defaultModel,
+        models: models.length ? models : (defaultModel ? [defaultModel] : []),
+        contextWindow: provider.contextWindow,
+    };
+}
+/** Get all configured provider names. */
+export function getProviderNames() {
+    const settings = getSettings();
+    return Object.keys(settings.providers ?? {});
+}