agent-sh 0.1.0

package/dist/extensions/tui-renderer.js

@@ -0,0 +1,354 @@
+/**
+ * TUI renderer extension.
+ *
+ * Subscribes to EventBus events and renders agent output to the terminal:
+ * bordered markdown responses, spinner, tool call display, streaming
+ * command output, error/info messages.
+ *
+ * Without this extension loaded, agent-sh runs headlessly — PTY
+ * passthrough, agent queries, tool execution all function; output is
+ * silently dropped. Alternative renderers (web UI, logging, minimal)
+ * can subscribe to the same events.
+ */
+import { MarkdownRenderer } from "../utils/markdown.js";
+import { palette as p } from "../utils/palette.js";
+import { renderToolCall, renderToolResult, startSpinner, stopSpinner as stopToolSpinner, } from "../utils/tool-display.js";
+import { renderDiff } from "../utils/diff-renderer.js";
+import { renderBoxFrame } from "../utils/box-frame.js";
+const MAX_COMMAND_OUTPUT_LINES = 30;
+export default function activate({ bus }) {
+    let spinner = null;
+    let renderer = null;
+    let commandOutputBuffer = "";
+    let commandOutputLineCount = 0;
+    let commandOutputOverflow = 0;
+    let lastCommand = "";
+    let isThinking = false;
+    let showThinkingText = false;
+    let lastTruncatedDiff = null;
+    // ── Event subscriptions ─────────────────────────────────────
+    bus.on("agent:query", (e) => {
+        showUserQuery(e.query);
+        startAgentResponse();
+        startThinkingSpinner();
+    });
+    bus.on("agent:thinking-chunk", (e) => {
+        if (!isThinking) {
+            isThinking = true;
+            stopCurrentSpinner();
+            if (showThinkingText) {
+                if (!renderer)
+                    startAgentResponse();
+                renderer.writeLine(`${p.dim}${p.bold}💭 Thinking${p.reset}`);
+            }
+            else {
+                startThinkingSpinner("Thinking");
+            }
+        }
+        if (showThinkingText && e.text) {
+            if (!renderer)
+                startAgentResponse();
+            renderer.push(`${p.dim}${e.text}${p.reset}`);
+            flushOutput();
+        }
+    });
+    bus.on("agent:response-chunk", (e) => writeAgentText(e.text));
+    bus.on("agent:response-done", () => {
+        isThinking = false;
+        endAgentResponse();
+    });
+    bus.on("agent:tool-call", (e) => {
+        lastCommand = e.tool;
+    });
+    bus.on("agent:tool-started", (e) => {
+        stopCurrentSpinner();
+        showToolCall(e.title, lastCommand);
+        lastCommand = "";
+    });
+    bus.on("agent:tool-completed", (e) => showToolComplete(e.exitCode));
+    bus.on("agent:tool-output-chunk", (e) => writeCommandOutput(e.chunk));
+    bus.on("agent:tool-output", () => flushCommandOutput());
+    bus.on("agent:cancelled", () => {
+        isThinking = false;
+        stopCurrentSpinner();
+        showInfo("(cancelled)");
+        endAgentResponse();
+    });
+    bus.on("agent:error", (e) => showError(e.message));
+    // Flush rendering state and show inline diff for file writes
+    bus.on("permission:request", (e) => {
+        stopCurrentSpinner();
+        flushCommandOutput();
+        renderer?.flush();
+        if (e.kind === "file-write" && e.metadata?.diff) {
+            showFileDiff(e.title, e.metadata.diff);
+        }
+        else {
+            // Non-file permission (e.g. tool-call) — end response box
+            // so interactive extensions can render their own UI
+            endAgentResponse();
+        }
+    });
+    bus.on("input:keypress", (e) => {
+        if (e.key === "\x0f")
+            expandLastDiff(); // Ctrl+O
+        if (e.key === "\x14")
+            toggleThinkingDisplay(); // Ctrl+T
+    });
+    bus.on("ui:info", (e) => showInfo(e.message));
+    bus.on("ui:error", (e) => showError(e.message));
+    // ── Rendering functions ─────────────────────────────────────
+    function flushOutput() {
+        if (process.stdout.writable) {
+            try {
+                process.stdout.write("");
+            }
+            catch { }
+        }
+    }
+    function startAgentResponse() {
+        renderer = new MarkdownRenderer();
+        process.stdout.write("\n");
+        renderer.printTopBorder();
+    }
+    function endAgentResponse() {
+        if (renderer) {
+            renderer.flush();
+            renderer.printBottomBorder();
+            renderer = null;
+        }
+    }
+    function showUserQuery(query) {
+        const termW = process.stdout.columns || 80;
+        const boxW = Math.min(84, termW);
+        const contentW = boxW - 4; // inside box padding
+        // Wrap long queries to fit within box
+        const lines = [];
+        for (const raw of query.split("\n")) {
+            if (raw.length <= contentW) {
+                lines.push(`${p.accent}${raw}${p.reset}`);
+            }
+            else {
+                // Simple word wrap
+                let remaining = raw;
+                while (remaining.length > contentW) {
+                    let breakAt = remaining.lastIndexOf(" ", contentW);
+                    if (breakAt <= 0)
+                        breakAt = contentW;
+                    lines.push(`${p.accent}${remaining.slice(0, breakAt)}${p.reset}`);
+                    remaining = remaining.slice(breakAt).trimStart();
+                }
+                if (remaining)
+                    lines.push(`${p.accent}${remaining}${p.reset}`);
+            }
+        }
+        const framed = renderBoxFrame(lines, {
+            width: boxW,
+            style: "rounded",
+            borderColor: p.accent,
+            title: `${p.accent}${p.bold}❯${p.reset}`,
+        });
+        process.stdout.write("\n");
+        for (const line of framed) {
+            process.stdout.write(line + "\n");
+        }
+    }
+    function writeAgentText(text) {
+        if (isThinking) {
+            isThinking = false;
+            if (showThinkingText && renderer) {
+                renderer.flush();
+                const termW = process.stdout.columns || 80;
+                const w = Math.min(80, termW);
+                renderer.writeLine(`${p.dim}${"─".repeat(w)}${p.reset}`);
+            }
+        }
+        stopCurrentSpinner();
+        if (!renderer)
+            startAgentResponse();
+        renderer.push(text);
+        flushOutput();
+    }
+    function showToolCall(title, command) {
+        stopCurrentSpinner();
+        if (!renderer)
+            startAgentResponse();
+        renderer.flush();
+        const termW = process.stdout.columns || 80;
+        const lines = renderToolCall({ title, command: command || undefined }, termW);
+        for (const line of lines) {
+            renderer.writeLine(line);
+        }
+        // Reset output tracking for the new tool
+        commandOutputLineCount = 0;
+        commandOutputOverflow = 0;
+    }
+    function showToolComplete(exitCode) {
+        if (!renderer)
+            return;
+        const termW = process.stdout.columns || 80;
+        const lines = renderToolResult({ exitCode }, termW);
+        for (const line of lines) {
+            renderer.writeLine(line);
+        }
+    }
+    function startThinkingSpinner(label = "Thinking") {
+        stopCurrentSpinner();
+        spinner = startSpinner(label);
+    }
+    function stopCurrentSpinner() {
+        if (spinner) {
+            stopToolSpinner(spinner);
+            spinner = null;
+        }
+    }
+    function writeCommandOutput(chunk) {
+        if (!renderer)
+            return;
+        commandOutputBuffer += chunk;
+        const lines = commandOutputBuffer.split("\n");
+        commandOutputBuffer = lines.pop();
+        for (const line of lines) {
+            if (commandOutputLineCount < MAX_COMMAND_OUTPUT_LINES) {
+                renderer.writeLine(`${p.dim}  ${line}${p.reset}`);
+                commandOutputLineCount++;
+            }
+            else {
+                commandOutputOverflow++;
+            }
+        }
+    }
+    function flushCommandOutput() {
+        if (!renderer)
+            return;
+        if (commandOutputBuffer) {
+            if (commandOutputLineCount < MAX_COMMAND_OUTPUT_LINES) {
+                renderer.writeLine(`${p.dim}  ${commandOutputBuffer}${p.reset}`);
+                commandOutputLineCount++;
+            }
+            else {
+                commandOutputOverflow++;
+            }
+            commandOutputBuffer = "";
+        }
+        if (commandOutputOverflow > 0) {
+            renderer.writeLine(`${p.dim}  … ${commandOutputOverflow} more lines${p.reset}`);
+            commandOutputOverflow = 0;
+        }
+    }
+    const DIFF_MAX_LINES = 20;
+    function diffTitle(filePath, diff) {
+        const stats = diff.isNewFile
+            ? `${p.success}+${diff.added}${p.reset}`
+            : `${p.success}+${diff.added}${p.reset} ${p.error}-${diff.removed}${p.reset}`;
+        return `${p.dim}${filePath}${p.reset}  ${stats}`;
+    }
+    function showFileDiff(filePath, diff) {
+        if (diff.isIdentical)
+            return;
+        const termW = process.stdout.columns || 80;
+        const boxW = Math.min(84, termW);
+        const contentW = boxW - 4;
+        const diffLines = renderDiff(diff, {
+            width: contentW,
+            filePath,
+            maxLines: DIFF_MAX_LINES,
+            trueColor: true,
+            mode: "unified",
+        });
+        const lastLine = diffLines[diffLines.length - 1] ?? "";
+        const isTruncated = lastLine.includes("… ");
+        if (isTruncated) {
+            lastTruncatedDiff = { filePath, diff, expanded: false };
+        }
+        else {
+            lastTruncatedDiff = null;
+        }
+        const body = diffLines.length > 1 ? ["", ...diffLines.slice(1), ""] : diffLines;
+        const footer = isTruncated
+            ? [`  ${p.dim}ctrl+o to expand${p.reset}`]
+            : undefined;
+        const framed = renderBoxFrame(body, {
+            width: boxW,
+            style: "rounded",
+            borderColor: p.dim,
+            title: diffTitle(filePath, diff),
+            footer,
+        });
+        if (!renderer)
+            startAgentResponse();
+        for (const line of framed) {
+            renderer.writeLine(line);
+        }
+    }
+    function expandLastDiff() {
+        if (!lastTruncatedDiff)
+            return;
+        const entry = lastTruncatedDiff;
+        entry.expanded = !entry.expanded;
+        if (!entry.expanded) {
+            showFileDiffCached(entry);
+            return;
+        }
+        if (!entry.expandedLines) {
+            const { filePath, diff } = entry;
+            const termW = process.stdout.columns || 80;
+            const boxW = Math.min(120, termW);
+            const contentW = boxW - 4;
+            const diffLines = renderDiff(diff, {
+                width: contentW,
+                filePath,
+                maxLines: 500,
+                trueColor: true,
+            });
+            const body = diffLines.length > 1 ? ["", ...diffLines.slice(1), ""] : diffLines;
+            entry.expandedLines = renderBoxFrame(body, {
+                width: boxW,
+                style: "rounded",
+                borderColor: p.dim,
+                title: diffTitle(filePath, diff),
+                footer: [`  ${p.dim}ctrl+o to collapse${p.reset}`],
+            });
+        }
+        process.stdout.write("\n");
+        for (const line of entry.expandedLines) {
+            process.stdout.write(line + "\n");
+        }
+    }
+    function showFileDiffCached(entry) {
+        const { filePath, diff } = entry;
+        const termW = process.stdout.columns || 80;
+        const boxW = Math.min(84, termW);
+        const contentW = boxW - 4;
+        const diffLines = renderDiff(diff, {
+            width: contentW,
+            filePath,
+            maxLines: DIFF_MAX_LINES,
+            trueColor: true,
+            mode: "unified",
+        });
+        const body = diffLines.length > 1 ? ["", ...diffLines.slice(1), ""] : diffLines;
+        const framed = renderBoxFrame(body, {
+            width: boxW,
+            style: "rounded",
+            borderColor: p.dim,
+            title: diffTitle(filePath, diff),
+            footer: [`  ${p.dim}ctrl+o to expand${p.reset}`],
+        });
+        process.stdout.write("\n");
+        for (const line of framed) {
+            process.stdout.write(line + "\n");
+        }
+    }
+    function toggleThinkingDisplay() {
+        showThinkingText = !showThinkingText;
+        const state = showThinkingText ? "on" : "off";
+        process.stdout.write(`\n${p.dim}Thinking display: ${state}${p.reset}\n`);
+    }
+    function showError(message) {
+        process.stdout.write(`\n${p.error}Error: ${message}${p.reset}\n`);
+    }
+    function showInfo(message) {
+        process.stdout.write(`${p.muted}${message}${p.reset}\n`);
+    }
+}

package/dist/index.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/dist/index.js

@@ -0,0 +1,159 @@
+#!/usr/bin/env node
+import { Shell } from "./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 { loadExtensions } from "./extension-loader.js";
+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;
+    const shell = process.env.SHELL || "/bin/bash";
+    for (let i = 0; i < argv.length; i++) {
+        const arg = argv[i];
+        if (arg === "--agent" && argv[i + 1]) {
+            agentCommand = 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 === "--shell" && argv[i + 1]) {
+            return { agentCommand, agentArgs, shell: argv[++i], model, extensions };
+        }
+        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
+
+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
+
+Options:
+  --agent <cmd>       Agent command to launch (default: $AGENT_SH_AGENT or "pi-acp")
+  --agent-args <args> Arguments for the agent (space-separated, quoted)
+  --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")
+
+Examples:
+  npm start --agent pi-acp
+  npm start -- -e my-extension-package
+  npm start -- -e ./local-ext.ts -e another-package
+
+Inside the shell:
+  Type normally        Commands run in your real shell
+  > <query>           Send query to the AI agent
+  > /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) {
+    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}`;
+    }
+    return `${infoStr} ${p.success}●${p.reset}`;
+}
+async function main() {
+    const config = parseArgs(process.argv.slice(2));
+    // ── Core (frontend-agnostic) ──────────────────────────────────
+    const core = createCore(config);
+    const { bus, client } = core;
+    // ── Interactive frontend ──────────────────────────────────────
+    process.stdout.write(`\x1b]0;agent-sh\x07`);
+    const cols = process.stdout.columns || 80;
+    const rows = process.stdout.rows || 24;
+    const cleanup = () => {
+        core.kill();
+        shell.kill();
+        if (process.stdin.isTTY) {
+            process.stdin.setRawMode(false);
+        }
+        process.exit(0);
+    };
+    const shell = new Shell({
+        bus,
+        cols,
+        rows,
+        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) {
+                    return { info: formatAgentInfo(agentInfo, model) };
+                }
+            }
+            return { info: "" };
+        },
+    });
+    // ── Extensions ────────────────────────────────────────────────
+    const extCtx = core.extensionContext({ quit: cleanup });
+    tuiRenderer(extCtx);
+    slashCommands(extCtx);
+    fileAutocomplete(extCtx);
+    shellRecall(extCtx);
+    await loadExtensions(extCtx, config.extensions);
+    // ── Agent connection (async — don't block shell startup) ──────
+    core.start().catch((err) => {
+        console.error(`Failed to connect to ${config.agentCommand}:`, err);
+    });
+    // ── Terminal lifecycle ────────────────────────────────────────
+    process.on("SIGTERM", cleanup);
+    process.on("SIGHUP", cleanup);
+    process.stdout.on("resize", () => {
+        shell.resize(process.stdout.columns || 80, process.stdout.rows || 24);
+    });
+    shell.onExit((e) => {
+        core.kill();
+        if (process.stdin.isTTY) {
+            process.stdin.setRawMode(false);
+        }
+        process.exit(e.exitCode);
+    });
+    if (process.stdin.isTTY) {
+        process.stdin.setRawMode(true);
+    }
+    process.stdin.resume();
+}
+main().catch((err) => {
+    console.error("Fatal:", err);
+    process.exit(1);
+});

package/dist/input-handler.d.ts

@@ -0,0 +1,48 @@
+import type { EventBus } from "./event-bus.js";
+/**
+ * Narrow contract between InputHandler and its host (Shell).
+ * InputHandler never touches the PTY or EventBus directly —
+ * it goes through this interface for all cross-cutting concerns.
+ */
+export interface InputContext {
+    isForegroundBusy(): boolean;
+    getCwd(): string;
+    isAgentActive(): boolean;
+    writeToPty(data: string): void;
+    onCommandEntered(command: string, cwd: string): void;
+    redrawPrompt(): void;
+    freshPrompt(): void;
+}
+export declare class InputHandler {
+    private ctx;
+    private lineBuffer;
+    private agentInputMode;
+    private agentInputBuffer;
+    private autocompleteActive;
+    private autocompleteIndex;
+    private autocompleteItems;
+    private autocompleteLines;
+    private bus;
+    private onShowAgentInfo;
+    constructor(opts: {
+        ctx: InputContext;
+        bus: EventBus;
+        onShowAgentInfo: () => {
+            info: string;
+            model?: string;
+        };
+    });
+    /** Write the agent prompt line (clear + info prefix + ❯ + buffer text). */
+    private writeAgentPromptLine;
+    handleInput(data: string): void;
+    private enterAgentInputMode;
+    private exitAgentInputMode;
+    printPrompt(): void;
+    private renderAgentInput;
+    private updateAutocomplete;
+    private renderAutocomplete;
+    private clearAutocompleteLines;
+    private applyAutocomplete;
+    private dismissAutocomplete;
+    private handleAgentInput;
+}