agent-sh 0.3.1 → 0.5.0

package/dist/index.js

@@ -1,5 +1,6 @@
 #!/usr/bin/env node
 import { spawn } from "node:child_process";
+import * as path from "node:path";
 import { Shell } from "./shell.js";
 import { createCore } from "./core.js";
 import { palette as p } from "./utils/palette.js";
@@ -7,19 +8,23 @@ 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 shellExec from "./extensions/shell-exec.js";
+import commandSuggest from "./extensions/command-suggest.js";
 import { loadExtensions } from "./extension-loader.js";
+import { getSettings } from "./settings.js";
 /**
- * Capture the user's full shell environment asynchronously.
+ * Capture the user's full shell environment.
  * This picks up env vars exported in .zshrc/.bashrc that the
- * Node.js process doesn't have.
- *
- * Uses -l (login shell) instead of -i to avoid TTY blocking issues.
+ * Node.js process doesn't have (e.g. when launched from an IDE).
  */
 async function captureShellEnvAsync(shell) {
     return new Promise((resolve) => {
         try {
-            const child = spawn(shell, ["-l", "-c", "env -0"], {
+            const shellName = path.basename(shell);
+            const isZsh = shellName.includes("zsh");
+            const sourceRc = isZsh
+                ? 'source ~/.zshrc 2>/dev/null;'
+                : '[ -f ~/.bashrc ] && source ~/.bashrc 2>/dev/null;';
+            const child = spawn(shell, ["-l", "-c", `${sourceRc} env -0`], {
                 stdio: ["ignore", "pipe", "ignore"],
                 timeout: 5000,
             });
@@ -29,7 +34,7 @@ async function captureShellEnvAsync(shell) {
             });
             child.on("close", (code) => {
                 if (code !== 0 || !output) {
-                    resolve({}); // Return empty to trigger fallback
+                    resolve({});
                     return;
                 }
                 const env = {};
@@ -41,9 +46,8 @@ async function captureShellEnvAsync(shell) {
                 resolve(env);
             });
             child.on("error", () => {
-                resolve({}); // Return empty to trigger fallback
+                resolve({});
             });
-            // Safety timeout
             setTimeout(() => {
                 child.kill("SIGTERM");
                 resolve({});
@@ -54,14 +58,9 @@ async function captureShellEnvAsync(shell) {
         }
     });
 }
-/**
- * Merge captured shell env into base env, only adding keys that don't exist.
- * This preserves any runtime modifications while adding missing shell vars.
- */
 function mergeShellEnv(baseEnv, shellEnv) {
     const merged = { ...baseEnv };
     for (const [key, value] of Object.entries(shellEnv)) {
-        // Only add if key doesn't exist or is empty in base env
         if (!(key in merged) || !merged[key]) {
             merged[key] = value;
         }
@@ -69,127 +68,110 @@ function mergeShellEnv(baseEnv, shellEnv) {
     return merged;
 }
 function parseArgs(argv) {
-    // Priority: CLI args > Environment variables > Config file > Defaults
-    const defaultAgent = process.env.AGENT_SH_AGENT || "pi-acp";
-    let agentCommand = defaultAgent;
-    let agentArgs = [];
     let model;
     let extensions;
+    let provider;
     const shell = process.env.SHELL || "/bin/bash";
+    let apiKey = process.env.OPENAI_API_KEY;
+    let baseURL = process.env.OPENAI_BASE_URL;
     for (let i = 0; i < argv.length; i++) {
         const arg = argv[i];
-        if (arg === "--agent" && argv[i + 1]) {
-            agentCommand = argv[++i];
+        if (arg === "--model" && argv[i + 1]) {
+            model = argv[++i];
         }
-        else if (arg === "--agent-args" && argv[i + 1]) {
-            const argsString = argv[++i];
-            agentArgs = argsString.split(" ");
-            // Extract model from agent args if provided
-            const modelArgIndex = agentArgs.findIndex(a => a === "--model" || a === "-m");
-            if (modelArgIndex !== -1 && agentArgs[modelArgIndex + 1]) {
-                model = agentArgs[modelArgIndex + 1];
-            }
+        else if (arg === "--api-key" && argv[i + 1]) {
+            apiKey = argv[++i];
+        }
+        else if (arg === "--base-url" && argv[i + 1]) {
+            baseURL = argv[++i];
+        }
+        else if (arg === "--provider" && argv[i + 1]) {
+            provider = argv[++i];
         }
         else if (arg === "--shell" && argv[i + 1]) {
-            return { agentCommand, agentArgs, shell: argv[++i], model, extensions };
+            return { shell: argv[++i], model, extensions, apiKey, baseURL, provider };
         }
         else if ((arg === "--extensions" || arg === "-e") && argv[i + 1]) {
             const exts = argv[++i].split(",").map(s => s.trim());
             extensions = extensions ? [...extensions, ...exts] : exts;
         }
         else if (arg === "--help" || arg === "-h") {
-            console.log(`agent-sh — a shell-first terminal with ACP agent access
+            console.log(`agent-sh — a shell-first terminal where AI is one keystroke away
 
 Usage: agent-sh [options]
 
-Quick Start:
-  npm start           Start with default agent (pi-acp)
-  npm run pi          Start with pi-acp agent
-  npm run claude      Start with Claude agent
+Provider Profiles:
+  --provider <name>   Use a provider from ~/.agent-sh/settings.json
+  --model <name>      Override default model
 
-Options:
-  --agent <cmd>       Agent command to launch (default: $AGENT_SH_AGENT or "pi-acp")
-  --agent-args <args> Arguments for the agent (space-separated, quoted)
+Direct LLM API:
+  --api-key <key>     API key for OpenAI-compatible provider (or set OPENAI_API_KEY)
+  --base-url <url>    Base URL for API (or set OPENAI_BASE_URL)
+
+General Options:
   --shell <path>      Shell to use (default: $SHELL or /bin/bash)
   -e, --extensions    Extensions to load (comma-separated, repeatable)
   -h, --help          Show this help
 
-Extensions:
-  Extensions are loaded from (in order):
-    1. -e flags:  npm packages or file paths
-    2. settings:  ~/.agent-sh/settings.json → "extensions": [...]
-    3. directory:  ~/.agent-sh/extensions/ (files or dirs with index.ts)
-
 Environment Variables:
-  AGENT_SH_AGENT   Default agent to use (e.g., "pi-acp", "claude")
+  OPENAI_API_KEY     API key for LLM provider
+  OPENAI_BASE_URL    Base URL override (e.g., http://localhost:11434/v1 for Ollama)
 
 Examples:
-  npm start --agent pi-acp
-  npm start -- -e my-extension-package
-  npm start -- -e ./local-ext.ts -e another-package
+  # Use a configured provider
+  agent-sh --provider openai
+
+  # Direct API access
+  agent-sh --api-key "$KEY" --model gpt-4o
+
+  # Local model via Ollama
+  agent-sh --base-url http://localhost:11434/v1 --model llama3
 
 Inside the shell:
   Type normally        Commands run in your real shell
-  > <query>           Send query to the AI agent
+  > <query>           Ask the AI agent a question (execute mode)
+  ? <command>         Have the agent run a command in your shell (help mode)
   > /help             Show available slash commands
   Ctrl-C              Cancel agent response (or signal shell as usual)
 `);
             process.exit(0);
         }
     }
-    return { agentCommand, agentArgs, shell, model, extensions };
-}
-function formatAgentInfo(agentInfo, model, thoughtLevel) {
-    const name = agentInfo.name.replace(/-acp$/, "").replace(/-/g, " ");
-    let infoStr = `${p.dim}${name}${p.reset}`;
-    if (model) {
-        const cleanModel = model
-            .replace(/^openai\//i, "")
-            .replace(/^anthropic\//i, "")
-            .replace(/^google\//i, "");
-        infoStr += ` ${p.dim}(${cleanModel})${p.reset}`;
-    }
-    if (thoughtLevel) {
-        // Clean up verbose mode names like "Thinking: medium" → "medium"
-        const label = thoughtLevel.replace(/^Thinking:\s*/i, "");
-        infoStr += ` ${p.dim}[${label}]${p.reset}`;
-    }
-    return `${infoStr} ${p.success}●${p.reset}`;
+    return { shell, model, extensions, apiKey, baseURL, provider };
 }
 async function main() {
-    // Set up signal handlers before any terminal operations.
-    // Ignore SIGTTOU to prevent suspension when modifying terminal settings.
+    if (process.env.AGENT_SH) {
+        console.error("agent-sh: already running inside an agent-sh session (nested sessions are not supported).");
+        process.exit(1);
+    }
     process.on("SIGTTOU", () => { });
-    // Also ignore SIGTTIN which can occur when reading from terminal while backgrounded.
     process.on("SIGTTIN", () => { });
     const config = parseArgs(process.argv.slice(2));
-    // Start with current process environment (fast, non-blocking)
-    // We'll enrich it with shell env asynchronously in the background
+    // Capture user's full shell environment
     const baseEnv = {};
     for (const [k, v] of Object.entries(process.env)) {
         if (v !== undefined)
             baseEnv[k] = v;
     }
-    config.shellEnv = baseEnv;
-    // Asynchronously capture full shell environment without blocking startup
     const shellPath = config.shell || process.env.SHELL || "/bin/bash";
-    captureShellEnvAsync(shellPath).then((shellEnv) => {
+    try {
+        const shellEnv = await captureShellEnvAsync(shellPath);
         if (Object.keys(shellEnv).length > 0) {
-            const merged = mergeShellEnv(config.shellEnv, shellEnv);
-            config.shellEnv = merged;
+            Object.assign(baseEnv, mergeShellEnv(baseEnv, shellEnv));
             if (process.env.DEBUG) {
-                console.error('[agent-sh] Shell environment enriched asynchronously');
+                console.error('[agent-sh] Shell environment captured');
             }
         }
-    }).catch(() => {
+    }
+    catch {
         // Ignore errors, we already have process.env as fallback
-    });
-    if (process.env.DEBUG) {
-        console.error('[agent-sh] Using current process environment (async enrichment pending)');
     }
     // ── Core (frontend-agnostic) ──────────────────────────────────
     const core = createCore(config);
-    const { bus, client } = core;
+    const { bus } = core;
+    // Track agent info from bus events (populated by extension backends)
+    let agentInfo = null;
+    bus.on("agent:info", (info) => { agentInfo = info; });
     // ── Interactive frontend ──────────────────────────────────────
     if (process.env.DEBUG) {
         console.error('[agent-sh] Setting up interactive frontend...');
@@ -208,8 +190,6 @@ async function main() {
     if (process.env.DEBUG) {
         console.error('[agent-sh] Creating Shell...');
     }
-    // Small delay on macOS to ensure we're fully in the foreground process group
-    // before spawning the PTY. This prevents SIGTTOU suspension.
     await new Promise(resolve => setTimeout(resolve, 100));
     const shell = new Shell({
         bus,
@@ -218,13 +198,11 @@ async function main() {
         shell: config.shell || process.env.SHELL || "/bin/bash",
         cwd: process.cwd(),
         onShowAgentInfo: () => {
-            if (client.isConnected()) {
-                const agentInfo = client.getAgentInfo();
-                const model = client.getModel();
-                if (agentInfo) {
-                    const mode = client.getCurrentMode();
-                    return { info: formatAgentInfo(agentInfo, model, mode?.name ?? null) };
-                }
+            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: "" };
         },
@@ -232,6 +210,40 @@ async function main() {
     if (process.env.DEBUG) {
         console.error('[agent-sh] Shell created');
     }
+    // ── Input modes ──────────────────────────────────────────────
+    bus.emit("input-mode:register", {
+        id: "execute",
+        trigger: ">",
+        label: "execute",
+        promptIcon: "❯",
+        indicator: "●",
+        onSubmit(query, b) {
+            b.emit("agent:submit", { query, modeLabel: "Execute", modeInstruction: "[mode: execute]" });
+        },
+        returnToSelf: true,
+    });
+    bus.emit("input-mode:register", {
+        id: "help",
+        trigger: "?",
+        label: "help",
+        promptIcon: "❯",
+        indicator: "❓",
+        onSubmit(query, b) {
+            const onToolDone = (e) => {
+                if (e.kind === "execute") {
+                    b.emit("agent:cancel-request", { silent: true });
+                }
+            };
+            const cleanup = () => {
+                b.off("agent:tool-completed", onToolDone);
+                b.off("agent:processing-done", cleanup);
+            };
+            b.on("agent:tool-completed", onToolDone);
+            b.on("agent:processing-done", cleanup);
+            b.emit("agent:submit", { query, modeLabel: "Help", modeInstruction: "[mode: help]" });
+        },
+        returnToSelf: false,
+    });
     // ── Extensions ────────────────────────────────────────────────
     if (process.env.DEBUG) {
         console.error('[agent-sh] Setting up extensions...');
@@ -241,20 +253,12 @@ async function main() {
     slashCommands(extCtx);
     fileAutocomplete(extCtx);
     shellRecall(extCtx);
-    // Shell-exec: start the Unix domain socket bridge so agent extensions
-    // and MCP servers can route tool calls to the PTY via the EventBus.
-    const tmpDir = shell.getTmpDir();
-    if (tmpDir) {
-        if (process.env.DEBUG) {
-            console.error('[agent-sh] Starting shell-exec socket server...');
-        }
-        shellExec(extCtx, { socketPath: `${tmpDir}/shell.sock` });
-    }
-    // Load extensions with timeout to prevent blocking startup
+    commandSuggest(extCtx);
+    // Load user extensions (may register alternative agent backends)
     if (process.env.DEBUG) {
         console.error('[agent-sh] Loading extensions...');
     }
-    const loadExtensionsTimeoutMs = 10000; // 10 seconds
+    const loadExtensionsTimeoutMs = 10000;
     await Promise.race([
         loadExtensions(extCtx, config.extensions),
         new Promise((_, reject) => setTimeout(() => reject(new Error(`Extension loading timeout after ${loadExtensionsTimeoutMs}ms`)), loadExtensionsTimeoutMs)),
@@ -264,21 +268,28 @@ async function main() {
     if (process.env.DEBUG) {
         console.error('[agent-sh] Extensions loaded');
     }
-    // ── Agent connection (async — don't block shell startup) ──────
-    const agentStartTimeoutMs = 35000; // 35 seconds (slightly longer than internal timeouts)
-    Promise.race([
-        core.start(),
-        new Promise((_, reject) => setTimeout(() => reject(new Error(`Agent connection timeout`)), agentStartTimeoutMs)),
-    ]).catch((err) => {
-        console.error(`Failed to connect to ${config.agentCommand}:`, err);
-    });
+    // ── Activate agent backend ────────────────────────────────────
+    // Extensions had their chance to register via agent:register-backend.
+    // If none did, the built-in AgentLoop gets wired to bus events.
+    core.activateBackend();
+    // ── Startup banner ───────────────────────────────────────────
+    const settings = getSettings();
+    if (settings.startupBanner !== false) {
+        const title = core.llmClient
+            ? `${p.accent}${p.bold}agent-sh${p.reset}${p.dim} · ${core.llmClient.model}${p.reset}`
+            : `${p.accent}${p.bold}agent-sh${p.reset}`;
+        const hint = `${p.muted}Type ${p.warning}>${p.muted} to ask AI · ${p.warning}?${p.muted} to run in shell · ${p.warning}/help${p.muted} for commands${p.reset}`;
+        const termW = process.stdout.columns || 80;
+        const borderLine = `${p.muted}${"─".repeat(Math.min(termW, 60))}${p.reset}`;
+        process.stdout.write("\n" + borderLine + "\n" +
+            "  " + title + "\n" +
+            "  " + hint + "\n" +
+            borderLine + "\n\n");
+    }
     // ── Terminal lifecycle ────────────────────────────────────────
     process.on("SIGTERM", cleanup);
     process.on("SIGHUP", cleanup);
-    // Handle terminal stop/resume signals properly
     process.on("SIGTSTP", () => {
-        // Handle Ctrl+Z - suspend the entire process group
-        // Restore terminal state before suspending
         if (process.stdin.isTTY) {
             try {
                 process.stdin.setRawMode(false);
@@ -287,14 +298,11 @@ async function main() {
                 // Ignore
             }
         }
-        // Re-send SIGSTOP to actually suspend
         process.kill(process.pid, "SIGSTOP");
     });
     process.on("SIGCONT", () => {
-        // Re-acquire terminal when brought back to foreground
         if (process.stdin.isTTY) {
             try {
-                // Ensure we reacquire controlling terminal
                 process.stdin.setRawMode(true);
             }
             catch {
@@ -312,17 +320,14 @@ async function main() {
         }
         process.exit(e.exitCode);
     });
-    // Set up stdin - resume after all event listeners are in place
     if (process.env.DEBUG) {
         console.error('[agent-sh] Resuming stdin...');
     }
     process.stdin.resume();
-    // Set raw mode after resume to avoid SIGTTOU issues
     if (process.stdin.isTTY) {
         if (process.env.DEBUG) {
             console.error('[agent-sh] Setting raw mode...');
         }
-        // Use setImmediate to ensure we're in the next tick
         setImmediate(() => {
             try {
                 process.stdin.setRawMode(true);
@@ -334,7 +339,6 @@ async function main() {
                 if (process.env.DEBUG) {
                     console.error(`[agent-sh] Failed to set raw mode: ${err}`);
                 }
-                // May fail if process is in background; SIGTTOU handler prevents suspension
             }
         });
     }

package/dist/input-handler.d.ts

@@ -16,7 +16,10 @@ export interface InputContext {
 export declare class InputHandler {
     private ctx;
     private lineBuffer;
-    private agentInputMode;
+    private activeMode;
+    private pendingReturnMode;
+    private modes;
+    private modesById;
     private editor;
     private autocompleteActive;
     private autocompleteIndex;
@@ -37,22 +40,28 @@ export declare class InputHandler {
             model?: string;
         };
     });
+    private registerMode;
     private loadHistory;
     private saveHistory;
-    /** Write the agent prompt line with cursor at the correct position. */
-    private writeAgentPromptLine;
+    /** Write the mode prompt line with cursor at the correct position. */
+    private writeModePromptLine;
     handleInput(data: string): void;
-    private enterAgentInputMode;
-    private exitAgentInputMode;
+    private enterMode;
+    private exitMode;
     /** Move to the start of the prompt area and clear everything below. */
     private clearPromptArea;
     printPrompt(): void;
-    private renderAgentInput;
+    /**
+     * Called when agent processing completes. Returns true if the input
+     * handler re-entered a mode (so caller should skip shell prompt).
+     */
+    handleProcessingDone(): boolean;
+    private renderModeInput;
     private updateAutocomplete;
     private renderAutocomplete;
     private applyAutocomplete;
     private dismissAutocomplete;
     private clearAutocompleteLines;
-    private handleAgentInput;
-    private processAgentActions;
+    private handleModeInput;
+    private processModeActions;
 }