agent-sh 0.1.0

package/dist/acp-client.d.ts

@@ -0,0 +1,76 @@
+import type { EventBus } from "./event-bus.js";
+import type { ContextManager } from "./context-manager.js";
+import type { AgentShellConfig } from "./types.js";
+export declare class AcpClient {
+    private agentProcess;
+    private connection;
+    private sessionId;
+    private bus;
+    private contextManager;
+    private config;
+    private promptInProgress;
+    private currentResponseText;
+    private lastResponseText;
+    private terminalSessions;
+    private terminalDonePromises;
+    private terminalCounter;
+    private fileWatcher;
+    private pendingToolCalls;
+    private pendingToolCounter;
+    private agentInfo;
+    constructor(opts: {
+        bus: EventBus;
+        contextManager: ContextManager;
+        config: AgentShellConfig;
+    });
+    start(): Promise<void>;
+    /**
+     * Send a user query to the agent.
+     */
+    sendPrompt(query: string): Promise<void>;
+    /**
+     * Cancel the current prompt and force-recover shell mode.
+     */
+    cancel(): Promise<void>;
+    /**
+     * Start a new ACP session, clearing agent-side conversation history.
+     */
+    resetSession(): Promise<void>;
+    /**
+     * Get the text of the last agent response (for /copy).
+     */
+    getLastResponseText(): string;
+    /**
+     * Get agent information for display.
+     */
+    getAgentInfo(): {
+        name: string;
+        version: string;
+    } | null;
+    getModel(): string | undefined;
+    /**
+     * Check if agent is connected.
+     */
+    isConnected(): boolean;
+    private log;
+    /**
+     * Create the Client handler that responds to agent requests.
+     */
+    private createClientHandler;
+    private handleSessionUpdate;
+    private handleRequestPermission;
+    private handleCreateTerminal;
+    private handleTerminalOutput;
+    private handleWaitForTerminalExit;
+    private handleKillTerminal;
+    private handleReleaseTerminal;
+    private handleReadTextFile;
+    private handleWriteTextFile;
+    /**
+     * After the agent finishes, check all tracked files for changes
+     * made via the agent's own tools (not through fs/writeTextFile)
+     * and show interactive diff previews.
+     */
+    private showPendingFileChanges;
+    kill(): void;
+}

package/dist/acp-client.js

@@ -0,0 +1,507 @@
+import { spawn } from "node:child_process";
+import { Readable, Writable } from "node:stream";
+import * as fs from "node:fs/promises";
+import * as acp from "@agentclientprotocol/sdk";
+import { executeCommand, killSession } from "./executor.js";
+import { computeDiff } from "./utils/diff.js";
+import { FileWatcher } from "./utils/file-watcher.js";
+import * as path from "node:path";
+import { stripAnsi } from "./utils/ansi.js";
+export class AcpClient {
+    agentProcess = null;
+    connection = null;
+    sessionId = null;
+    bus;
+    contextManager;
+    config;
+    promptInProgress = false;
+    currentResponseText = "";
+    lastResponseText = "";
+    terminalSessions = new Map();
+    terminalDonePromises = new Map();
+    terminalCounter = 0;
+    fileWatcher;
+    pendingToolCalls = new Map();
+    pendingToolCounter = 0;
+    agentInfo = null;
+    constructor(opts) {
+        this.bus = opts.bus;
+        this.contextManager = opts.contextManager;
+        this.config = opts.config;
+        this.fileWatcher = new FileWatcher(process.cwd());
+    }
+    async start() {
+        this.log(`Starting agent: ${this.config.agentCommand} ${this.config.agentArgs.join(" ")}`);
+        // Spawn the agent subprocess
+        // Spawn the agent — wait briefly to catch ENOENT and other spawn errors
+        this.agentProcess = spawn(this.config.agentCommand, this.config.agentArgs, {
+            stdio: ["pipe", "pipe", process.env.DEBUG ? "inherit" : "ignore"],
+        });
+        // Catch spawn errors (ENOENT, EACCES, etc.) before proceeding
+        await new Promise((resolve, reject) => {
+            const onError = (err) => {
+                reject(new Error(`Failed to start agent "${this.config.agentCommand}": ${err.message}`));
+            };
+            this.agentProcess.on("error", onError);
+            // spawn errors fire on next tick — wait for that, then detach the listener
+            setTimeout(() => {
+                this.agentProcess.removeListener("error", onError);
+                resolve();
+            }, 100);
+        });
+        this.log("Agent process spawned");
+        this.agentProcess.on("exit", (code) => {
+            this.bus.emit("agent:error", { message: `Agent process exited with code ${code}` });
+            this.connection = null;
+            this.sessionId = null;
+        });
+        if (!this.agentProcess.stdin || !this.agentProcess.stdout) {
+            throw new Error("Failed to get agent process stdio");
+        }
+        // Create ACP stream from the agent's stdio
+        const output = Writable.toWeb(this.agentProcess.stdin);
+        const input = Readable.toWeb(this.agentProcess.stdout);
+        const stream = acp.ndJsonStream(output, input);
+        this.log("Creating ACP connection");
+        // Create the client-side connection, providing our Client handler
+        this.connection = new acp.ClientSideConnection((_agent) => this.createClientHandler(), stream);
+        // Initialize the connection
+        this.log("Sending initialize request");
+        const initResponse = await this.connection.initialize({
+            protocolVersion: acp.PROTOCOL_VERSION,
+            clientInfo: { name: "agent-sh", version: "0.1.0" },
+            clientCapabilities: {
+                terminal: true,
+                fs: {
+                    readTextFile: true,
+                    writeTextFile: true,
+                },
+            },
+        });
+        this.log("Initialize successful");
+        // Store agent info for display
+        if (initResponse.agentInfo) {
+            this.agentInfo = {
+                name: initResponse.agentInfo.name || this.config.agentCommand,
+                version: initResponse.agentInfo.version || "unknown"
+            };
+            this.log(`Agent info: ${this.agentInfo.name} v${this.agentInfo.version}`);
+        }
+        // Create a session
+        const cwd = this.contextManager.getCwd();
+        this.log(`Creating new session with cwd: ${cwd}`);
+        const sessionResponse = await this.connection.newSession({
+            cwd,
+            mcpServers: [],
+        });
+        this.sessionId = sessionResponse.sessionId;
+        this.log(`Session created: ${this.sessionId}`);
+    }
+    /**
+     * Send a user query to the agent.
+     */
+    async sendPrompt(query) {
+        if (!this.connection || !this.sessionId) {
+            this.bus.emit("agent:error", { message: "Not connected to agent" });
+            return;
+        }
+        this.promptInProgress = true;
+        this.bus.emit("agent:processing-start", {});
+        await this.fileWatcher.snapshot();
+        this.currentResponseText = "";
+        let cancelled = false;
+        // Emit agent query event (TUI renders echo+spinner, ContextManager records it)
+        this.bus.emit("agent:query", { query });
+        // Build structured context from ContextManager
+        const contextBlock = this.contextManager.getContext();
+        try {
+            this.log("sending prompt...");
+            const response = await this.connection.prompt({
+                sessionId: this.sessionId,
+                prompt: [
+                    {
+                        type: "text",
+                        text: contextBlock + "\n" + query,
+                    },
+                ],
+            });
+            this.log(`prompt resolved: stopReason=${response.stopReason}`);
+            if (response.stopReason === "cancelled") {
+                cancelled = true;
+                this.bus.emit("agent:cancelled", {});
+            }
+        }
+        catch (err) {
+            this.log(`prompt error: ${err}`);
+            this.bus.emit("agent:error", {
+                message: err instanceof Error ? err.message : String(err),
+            });
+        }
+        finally {
+            this.log("restoring shell mode");
+            if (!cancelled) {
+                this.bus.emit("agent:response-done", {
+                    response: this.currentResponseText,
+                });
+            }
+            this.lastResponseText = this.currentResponseText;
+            // Show diff previews for files the agent modified via its own tools
+            // (modifications via fs/writeTextFile are already handled inline)
+            if (this.promptInProgress) {
+                await this.showPendingFileChanges();
+            }
+            this.bus.emit("agent:processing-done", {});
+            this.promptInProgress = false;
+        }
+    }
+    /**
+     * Cancel the current prompt and force-recover shell mode.
+     */
+    async cancel() {
+        this.log("cancel requested");
+        // Kill all running terminal sessions
+        for (const session of this.terminalSessions.values()) {
+            if (!session.done)
+                killSession(session);
+        }
+        if (this.connection && this.sessionId && this.promptInProgress) {
+            try {
+                await this.connection.cancel({ sessionId: this.sessionId });
+            }
+            catch {
+                // Cancellation is best-effort
+            }
+        }
+        // Force-recover shell regardless of prompt state
+        if (this.promptInProgress) {
+            this.bus.emit("agent:cancelled", {});
+        }
+        this.bus.emit("agent:processing-done", {});
+        this.promptInProgress = false;
+    }
+    /**
+     * Start a new ACP session, clearing agent-side conversation history.
+     */
+    async resetSession() {
+        if (!this.connection)
+            return;
+        const sessionResponse = await this.connection.newSession({
+            cwd: this.contextManager.getCwd(),
+            mcpServers: [],
+        });
+        this.sessionId = sessionResponse.sessionId;
+        this.lastResponseText = "";
+        this.currentResponseText = "";
+    }
+    /**
+     * Get the text of the last agent response (for /copy).
+     */
+    getLastResponseText() {
+        return this.lastResponseText;
+    }
+    /**
+     * Get agent information for display.
+     */
+    getAgentInfo() {
+        return this.agentInfo;
+    }
+    getModel() {
+        return this.config.model;
+    }
+    /**
+     * Check if agent is connected.
+     */
+    isConnected() {
+        // Consider connected if we have a connection and agent info
+        // Session ID may not be set yet if we're still initializing
+        return this.connection !== null && this.agentInfo !== null;
+    }
+    log(msg) {
+        if (process.env.DEBUG) {
+            process.stderr.write(`[agent-sh] ${msg}\n`);
+        }
+    }
+    /**
+     * Create the Client handler that responds to agent requests.
+     */
+    createClientHandler() {
+        return {
+            // Required: handle session update notifications (streaming)
+            sessionUpdate: async (params) => {
+                this.handleSessionUpdate(params);
+            },
+            // Required: handle permission requests
+            requestPermission: async (params) => {
+                return this.handleRequestPermission(params);
+            },
+            // Optional: terminal operations
+            createTerminal: async (params) => {
+                return this.handleCreateTerminal(params);
+            },
+            terminalOutput: async (params) => {
+                return this.handleTerminalOutput(params);
+            },
+            waitForTerminalExit: async (params) => {
+                return this.handleWaitForTerminalExit(params);
+            },
+            killTerminal: async (params) => {
+                return this.handleKillTerminal(params);
+            },
+            releaseTerminal: async (params) => {
+                return this.handleReleaseTerminal(params);
+            },
+            // Optional: filesystem operations
+            readTextFile: async (params) => {
+                return this.handleReadTextFile(params);
+            },
+            writeTextFile: async (params) => {
+                return this.handleWriteTextFile(params);
+            },
+        };
+    }
+    // ── Session update handler ─────────────────────────────────────
+    handleSessionUpdate(params) {
+        // Suppress rendering during initialization / between prompts
+        if (!this.promptInProgress)
+            return;
+        const update = params.update;
+        switch (update.sessionUpdate) {
+            case "agent_message_chunk": {
+                const content = update.content;
+                if (content.type === "text") {
+                    this.currentResponseText += content.text;
+                    this.bus.emit("agent:response-chunk", { text: content.text });
+                }
+                break;
+            }
+            case "agent_thought_chunk": {
+                const thought = update.content;
+                if (thought.type === "text" && thought.text) {
+                    this.bus.emit("agent:thinking-chunk", { text: thought.text });
+                }
+                break;
+            }
+            case "tool_call": {
+                // Use toolCallId if available, otherwise generate a simple ID
+                const toolId = update.toolCallId || `tool-${this.pendingToolCounter++}`;
+                this.pendingToolCalls.set(toolId, true);
+                this.bus.emit("agent:tool-started", { title: update.title, toolCallId: toolId });
+                break;
+            }
+            case "tool_call_update": {
+                // Only show result when the tool completes, don't show tool call again
+                if (update.status === "completed" || update.status === "failed") {
+                    const toolId = update.toolCallId;
+                    const exitCode = update.status === "completed" ? 0 : 1;
+                    if (toolId && this.pendingToolCalls.has(toolId)) {
+                        this.pendingToolCalls.delete(toolId);
+                        this.bus.emit("agent:tool-completed", { toolCallId: toolId, exitCode });
+                    }
+                    else if (!toolId) {
+                        this.bus.emit("agent:tool-completed", { exitCode });
+                    }
+                }
+                break;
+            }
+            default:
+                // Ignore other update types for now
+                break;
+        }
+    }
+    // ── Permission handler ─────────────────────────────────────────
+    async handleRequestPermission(params) {
+        const title = params.toolCall.title ?? "Unknown action";
+        const result = await this.bus.emitPipeAsync("permission:request", {
+            kind: "tool-call",
+            title,
+            metadata: {
+                options: params.options.map((o) => ({
+                    optionId: o.optionId,
+                    kind: o.kind,
+                })),
+            },
+            decision: {
+                outcome: "selected",
+                optionId: (params.options.find((o) => o.kind === "allow_once") ?? params.options[0])?.optionId,
+            },
+        });
+        return { outcome: result.decision };
+    }
+    // ── Terminal handlers (isolated execution via child_process) ────
+    async handleCreateTerminal(params) {
+        const fullCommand = params.args?.length
+            ? `${params.command} ${params.args.join(" ")}`
+            : params.command;
+        const cwd = params.cwd ?? this.contextManager.getCwd();
+        // Let extensions intercept before spawning a real process
+        const intercept = this.bus.emitPipe("agent:terminal-intercept", {
+            command: fullCommand,
+            cwd,
+            intercepted: false,
+            output: "",
+        });
+        if (intercept.intercepted) {
+            const id = `t${++this.terminalCounter}`;
+            const session = {
+                id,
+                command: fullCommand,
+                output: intercept.output,
+                exitCode: 0,
+                done: true,
+                truncated: false,
+                process: null,
+            };
+            this.terminalSessions.set(id, session);
+            this.terminalDonePromises.set(id, Promise.resolve());
+            return { terminalId: id };
+        }
+        this.bus.emit("agent:tool-call", {
+            tool: fullCommand,
+            args: { command: params.command, args: params.args, cwd },
+        });
+        const id = `t${++this.terminalCounter}`;
+        const { session, done } = executeCommand({
+            command: fullCommand,
+            cwd,
+            timeout: 60_000,
+            maxOutputBytes: 256 * 1024,
+            onOutput: (chunk) => {
+                // Stream output into the box in real-time (strip ANSI for display)
+                this.bus.emit("agent:tool-output-chunk", { chunk: stripAnsi(chunk) });
+            },
+        });
+        session.id = id;
+        this.terminalSessions.set(id, session);
+        this.terminalDonePromises.set(id, done);
+        return { terminalId: id };
+    }
+    async handleTerminalOutput(params) {
+        const session = this.terminalSessions.get(params.terminalId);
+        if (!session) {
+            return { output: "", truncated: false };
+        }
+        return {
+            output: session.output,
+            truncated: session.truncated,
+            ...(session.done && {
+                exitStatus: { exitCode: session.exitCode },
+            }),
+        };
+    }
+    async handleWaitForTerminalExit(params) {
+        const session = this.terminalSessions.get(params.terminalId);
+        if (!session) {
+            return { exitCode: -1 };
+        }
+        if (!session.done) {
+            const done = this.terminalDonePromises.get(params.terminalId);
+            if (done)
+                await done;
+        }
+        this.bus.emit("agent:tool-output", {
+            tool: session.command ?? "",
+            output: session.output,
+            exitCode: session.exitCode,
+        });
+        return { exitCode: session.exitCode ?? -1 };
+    }
+    async handleKillTerminal(params) {
+        const session = this.terminalSessions.get(params.terminalId);
+        if (session && !session.done) {
+            killSession(session);
+        }
+        return {};
+    }
+    async handleReleaseTerminal(params) {
+        this.terminalSessions.delete(params.terminalId);
+        this.terminalDonePromises.delete(params.terminalId);
+        return {};
+    }
+    // ── Filesystem handlers ────────────────────────────────────────
+    async handleReadTextFile(params) {
+        try {
+            let content = await fs.readFile(params.path, "utf-8");
+            if (params.line != null || params.limit != null) {
+                const lines = content.split("\n");
+                const start = (params.line ?? 1) - 1;
+                const end = params.limit != null ? start + params.limit : lines.length;
+                content = lines.slice(start, end).join("\n");
+            }
+            return { content };
+        }
+        catch (err) {
+            throw new Error(`Failed to read ${params.path}: ${err instanceof Error ? err.message : String(err)}`);
+        }
+    }
+    async handleWriteTextFile(params) {
+        // Read original content for diff preview
+        let original = null;
+        try {
+            original = await fs.readFile(params.path, "utf-8");
+        }
+        catch {
+            // File doesn't exist yet — will show as "new file"
+        }
+        const diff = computeDiff(original, params.content);
+        // Identical content — nothing to do
+        if (diff.isIdentical)
+            return {};
+        // Extensions can gate this — default is auto-approve (yolo mode)
+        const result = await this.bus.emitPipeAsync("permission:request", {
+            kind: "file-write",
+            title: params.path,
+            metadata: { path: params.path, diff, content: params.content },
+            decision: { approved: true },
+        });
+        if (!result.decision.approved) {
+            throw new Error(`User rejected modification: ${params.path}`);
+        }
+        // Write the file
+        try {
+            await fs.writeFile(params.path, params.content, "utf-8");
+            this.fileWatcher.approve(path.resolve(params.path), params.content);
+            return {};
+        }
+        catch (err) {
+            throw new Error(`Failed to write ${params.path}: ${err instanceof Error ? err.message : String(err)}`);
+        }
+    }
+    // ── Diff preview for non-ACP file changes ────────────────────
+    /**
+     * After the agent finishes, check all tracked files for changes
+     * made via the agent's own tools (not through fs/writeTextFile)
+     * and show interactive diff previews.
+     */
+    async showPendingFileChanges() {
+        const changes = await this.fileWatcher.detectChanges();
+        if (changes.length === 0)
+            return;
+        for (const change of changes) {
+            const diff = computeDiff(change.before, change.after);
+            if (diff.isIdentical)
+                continue;
+            const result = await this.bus.emitPipeAsync("permission:request", {
+                kind: "file-write",
+                title: change.relPath,
+                metadata: { path: change.relPath, diff, content: change.after },
+                decision: { approved: true },
+            });
+            if (result.decision.approved) {
+                this.fileWatcher.approve(change.path, change.after);
+            }
+            else {
+                await this.fileWatcher.revert(change.path);
+            }
+        }
+    }
+    // ── Cleanup ────────────────────────────────────────────────────
+    kill() {
+        for (const session of this.terminalSessions.values()) {
+            if (!session.done)
+                killSession(session);
+        }
+        if (this.agentProcess && !this.agentProcess.killed) {
+            this.agentProcess.kill("SIGTERM");
+        }
+    }
+}

package/dist/context-manager.d.ts

@@ -0,0 +1,45 @@
+import type { EventBus } from "./event-bus.js";
+export declare class ContextManager {
+    private exchanges;
+    private nextId;
+    private currentCwd;
+    private sessionStart;
+    private pendingToolCalls;
+    constructor(bus: EventBus);
+    getCwd(): string;
+    /**
+     * Build the <shell_context> block for the agent prompt.
+     * Pipeline: window → truncate → format
+     */
+    getContext(budget?: number): string;
+    /**
+     * Regex/keyword search across all exchanges. Returns formatted results.
+     */
+    search(query: string): string;
+    /**
+     * Return full untruncated content for specific exchange IDs.
+     */
+    expand(ids: number[]): string;
+    /**
+     * One-line summaries of last N exchanges.
+     */
+    getRecentSummary(n?: number): string;
+    /**
+     * Parse and handle __shell_recall commands.
+     */
+    handleRecallCommand(command: string): string;
+    /**
+     * Clear exchange history (used by /clear command).
+     */
+    clear(): void;
+    private applyWindow;
+    private applyTruncation;
+    private formatContext;
+    private addExchange;
+    private formatExchangeTruncated;
+    private truncateForRecall;
+    private formatExchangeFull;
+    private exchangeOneLiner;
+    private exchangeSearchText;
+    private exchangeSize;
+}