wave-code 0.9.7 → 0.10.1

package/dist/acp/agent.d.ts

@@ -0,0 +1,28 @@
+import { type Agent as AcpAgent, type AgentSideConnection, type InitializeResponse, type NewSessionRequest, type NewSessionResponse, type LoadSessionRequest, type LoadSessionResponse, type ListSessionsRequest, type ListSessionsResponse, type PromptRequest, type PromptResponse, type CancelNotification, type AuthenticateResponse, type SetSessionModeRequest, type SetSessionConfigOptionRequest, type SetSessionConfigOptionResponse } from "@agentclientprotocol/sdk";
+export declare class WaveAcpAgent implements AcpAgent {
+    private agents;
+    private connection;
+    constructor(connection: AgentSideConnection);
+    private getSessionModeState;
+    private getSessionConfigOptions;
+    private cleanupAllAgents;
+    initialize(): Promise<InitializeResponse>;
+    authenticate(): Promise<AuthenticateResponse | void>;
+    private createAgent;
+    newSession(params: NewSessionRequest): Promise<NewSessionResponse>;
+    loadSession(params: LoadSessionRequest): Promise<LoadSessionResponse>;
+    listSessions(params: ListSessionsRequest): Promise<ListSessionsResponse>;
+    unstable_closeSession(params: Record<string, unknown>): Promise<Record<string, unknown>>;
+    extMethod(method: string, params: Record<string, unknown>): Promise<Record<string, unknown>>;
+    setSessionMode(params: SetSessionModeRequest): Promise<void>;
+    setSessionConfigOption(params: SetSessionConfigOptionRequest): Promise<SetSessionConfigOptionResponse>;
+    prompt(params: PromptRequest): Promise<PromptResponse>;
+    cancel(params: CancelNotification): Promise<void>;
+    private handlePermissionRequest;
+    private getToolContentAsync;
+    private getToolContent;
+    private getToolLocations;
+    private getToolKind;
+    private createCallbacks;
+}
+//# sourceMappingURL=agent.d.ts.map

package/dist/acp/agent.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"agent.d.ts","sourceRoot":"","sources":["../../src/acp/agent.ts"],"names":[],"mappings":"AAaA,OAAO,EACL,KAAK,KAAK,IAAI,QAAQ,EACtB,KAAK,mBAAmB,EACxB,KAAK,kBAAkB,EACvB,KAAK,iBAAiB,EACtB,KAAK,kBAAkB,EACvB,KAAK,kBAAkB,EACvB,KAAK,mBAAmB,EACxB,KAAK,mBAAmB,EACxB,KAAK,oBAAoB,EACzB,KAAK,aAAa,EAClB,KAAK,cAAc,EACnB,KAAK,kBAAkB,EACvB,KAAK,oBAAoB,EAUzB,KAAK,qBAAqB,EAC1B,KAAK,6BAA6B,EAClC,KAAK,8BAA8B,EAEpC,MAAM,0BAA0B,CAAC;AAElC,qBAAa,YAAa,YAAW,QAAQ;IAC3C,OAAO,CAAC,MAAM,CAAqC;IACnD,OAAO,CAAC,UAAU,CAAsB;gBAE5B,UAAU,EAAE,mBAAmB;IAI3C,OAAO,CAAC,mBAAmB;IA4B3B,OAAO,CAAC,uBAAuB;YAkBjB,gBAAgB;IASxB,UAAU,IAAI,OAAO,CAAC,kBAAkB,CAAC;IAoBzC,YAAY,IAAI,OAAO,CAAC,oBAAoB,GAAG,IAAI,CAAC;YAI5C,WAAW;IA8CnB,UAAU,CAAC,MAAM,EAAE,iBAAiB,GAAG,OAAO,CAAC,kBAAkB,CAAC;IA8BlE,WAAW,CAAC,MAAM,EAAE,kBAAkB,GAAG,OAAO,CAAC,mBAAmB,CAAC;IA4BrE,YAAY,CAChB,MAAM,EAAE,mBAAmB,GAC1B,OAAO,CAAC,oBAAoB,CAAC;IAmB1B,qBAAqB,CACzB,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAC9B,OAAO,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IAc7B,SAAS,CACb,MAAM,EAAE,MAAM,EACd,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAC9B,OAAO,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IAO7B,cAAc,CAAC,MAAM,EAAE,qBAAqB,GAAG,OAAO,CAAC,IAAI,CAAC;IAS5D,sBAAsB,CAC1B,MAAM,EAAE,6BAA6B,GACpC,OAAO,CAAC,8BAA8B,CAAC;IAgBpC,MAAM,CAAC,MAAM,EAAE,aAAa,GAAG,OAAO,CAAC,cAAc,CAAC;IAiDtD,MAAM,CAAC,MAAM,EAAE,kBAAkB,GAAG,OAAO,CAAC,IAAI,CAAC;YASzC,uBAAuB;YAsGvB,mBAAmB;IA2EjC,OAAO,CAAC,cAAc;IA4BtB,OAAO,CAAC,gBAAgB;IAgBxB,OAAO,CAAC,WAAW;IAmBnB,OAAO,CAAC,eAAe;CAsIxB"}

package/dist/acp/agent.js

@@ -0,0 +1,603 @@
+import { Agent as WaveAgent, listSessions as listWaveSessions, deleteSession as deleteWaveSession, } from "wave-agent-sdk";
+import * as fs from "node:fs/promises";
+import * as path from "node:path";
+import { logger } from "../utils/logger.js";
+import { AGENT_METHODS, } from "@agentclientprotocol/sdk";
+export class WaveAcpAgent {
+    constructor(connection) {
+        this.agents = new Map();
+        this.connection = connection;
+    }
+    getSessionModeState(agent) {
+        return {
+            currentModeId: agent.getPermissionMode(),
+            availableModes: [
+                {
+                    id: "default",
+                    name: "Default",
+                    description: "Ask for permission for restricted tools",
+                },
+                {
+                    id: "acceptEdits",
+                    name: "Accept Edits",
+                    description: "Automatically accept file edits",
+                },
+                {
+                    id: "plan",
+                    name: "Plan",
+                    description: "Plan mode for complex tasks",
+                },
+                {
+                    id: "bypassPermissions",
+                    name: "Bypass Permissions",
+                    description: "Automatically accept all tool calls",
+                },
+            ],
+        };
+    }
+    getSessionConfigOptions(agent) {
+        return [
+            {
+                id: "permission_mode",
+                name: "Permission Mode",
+                type: "select",
+                category: "mode",
+                currentValue: agent.getPermissionMode(),
+                options: [
+                    { value: "default", name: "Default" },
+                    { value: "acceptEdits", name: "Accept Edits" },
+                    { value: "plan", name: "Plan" },
+                    { value: "bypassPermissions", name: "Bypass Permissions" },
+                ],
+            },
+        ];
+    }
+    async cleanupAllAgents() {
+        logger.info("Cleaning up all active agents due to connection closure");
+        const destroyPromises = Array.from(this.agents.values()).map((agent) => agent.destroy());
+        await Promise.all(destroyPromises);
+        this.agents.clear();
+    }
+    async initialize() {
+        logger.info("Initializing WaveAcpAgent");
+        // Setup cleanup on connection closure
+        this.connection.closed.then(() => this.cleanupAllAgents());
+        return {
+            protocolVersion: 1,
+            agentInfo: {
+                name: "wave-agent",
+                version: "0.1.0",
+            },
+            agentCapabilities: {
+                loadSession: true,
+                sessionCapabilities: {
+                    list: {},
+                    close: {},
+                },
+            },
+        };
+    }
+    async authenticate() {
+        // No authentication required for now
+    }
+    async createAgent(sessionId, cwd) {
+        const callbacks = {};
+        const agentRef = {};
+        const agent = await WaveAgent.create({
+            workdir: cwd,
+            restoreSessionId: sessionId,
+            canUseTool: (context) => {
+                if (!agentRef.instance) {
+                    throw new Error("Agent instance not yet initialized");
+                }
+                return this.handlePermissionRequest(agentRef.instance.sessionId, context);
+            },
+            callbacks: {
+                onAssistantContentUpdated: (chunk) => callbacks.onAssistantContentUpdated?.(chunk, ""),
+                onAssistantReasoningUpdated: (chunk) => callbacks.onAssistantReasoningUpdated?.(chunk, ""),
+                onToolBlockUpdated: (params) => {
+                    const cb = callbacks.onToolBlockUpdated;
+                    cb?.(params);
+                },
+                onTasksChange: (tasks) => callbacks.onTasksChange?.(tasks),
+                onPermissionModeChange: (mode) => callbacks.onPermissionModeChange?.(mode),
+            },
+        });
+        agentRef.instance = agent;
+        const actualSessionId = agent.sessionId;
+        this.agents.set(actualSessionId, agent);
+        // Update the callbacks object with the correct sessionId
+        Object.assign(callbacks, this.createCallbacks(actualSessionId));
+        return agent;
+    }
+    async newSession(params) {
+        const { cwd } = params;
+        logger.info(`Creating new session in ${cwd}`);
+        const agent = await this.createAgent(undefined, cwd);
+        logger.info(`New session created with ID: ${agent.sessionId}`);
+        // Send initial available commands after agent creation
+        setImmediate(() => {
+            this.connection.sessionUpdate({
+                sessionId: agent.sessionId,
+                update: {
+                    sessionUpdate: "available_commands_update",
+                    availableCommands: agent.getSlashCommands().map((cmd) => ({
+                        name: cmd.name,
+                        description: cmd.description,
+                        input: {
+                            hint: "Enter arguments...",
+                        },
+                    })),
+                },
+            });
+        });
+        return {
+            sessionId: agent.sessionId,
+            modes: this.getSessionModeState(agent),
+            configOptions: this.getSessionConfigOptions(agent),
+        };
+    }
+    async loadSession(params) {
+        const { sessionId, cwd } = params;
+        logger.info(`Loading session: ${sessionId} in ${cwd}`);
+        const agent = await this.createAgent(sessionId, cwd);
+        // Send initial available commands after agent creation
+        setImmediate(() => {
+            this.connection.sessionUpdate({
+                sessionId: agent.sessionId,
+                update: {
+                    sessionUpdate: "available_commands_update",
+                    availableCommands: agent.getSlashCommands().map((cmd) => ({
+                        name: cmd.name,
+                        description: cmd.description,
+                        input: {
+                            hint: "Enter arguments...",
+                        },
+                    })),
+                },
+            });
+        });
+        return {
+            modes: this.getSessionModeState(agent),
+            configOptions: this.getSessionConfigOptions(agent),
+        };
+    }
+    async listSessions(params) {
+        const { cwd } = params;
+        logger.info(`listSessions called with params: ${JSON.stringify(params)}`);
+        if (!cwd) {
+            logger.warn("listSessions called without cwd, returning empty list");
+            return { sessions: [] };
+        }
+        logger.info(`Listing sessions for ${cwd}`);
+        const waveSessions = await listWaveSessions(cwd);
+        logger.info(`Found ${waveSessions.length} sessions for ${cwd}`);
+        const sessions = waveSessions.map((meta) => ({
+            sessionId: meta.id,
+            cwd: meta.workdir,
+            updatedAt: meta.lastActiveAt.toISOString(),
+        }));
+        return { sessions };
+    }
+    async unstable_closeSession(params) {
+        const sessionId = params.sessionId;
+        logger.info(`Stopping session ${sessionId}`);
+        const agent = this.agents.get(sessionId);
+        if (agent) {
+            const workdir = agent.workingDirectory;
+            await agent.destroy();
+            this.agents.delete(sessionId);
+            // Delete the session file so it doesn't show up in listSessions
+            await deleteWaveSession(sessionId, workdir);
+        }
+        return {};
+    }
+    async extMethod(method, params) {
+        if (method === AGENT_METHODS.session_close) {
+            return this.unstable_closeSession(params);
+        }
+        throw new Error(`Method ${method} not implemented`);
+    }
+    async setSessionMode(params) {
+        const { sessionId, modeId } = params;
+        const agent = this.agents.get(sessionId);
+        if (!agent)
+            throw new Error(`Session ${sessionId} not found`);
+        agent.setPermissionMode(modeId);
+    }
+    async setSessionConfigOption(params) {
+        const { sessionId, configId, value } = params;
+        const agent = this.agents.get(sessionId);
+        if (!agent)
+            throw new Error(`Session ${sessionId} not found`);
+        if (configId === "permission_mode") {
+            agent.setPermissionMode(value);
+        }
+        return {
+            configOptions: this.getSessionConfigOptions(agent),
+        };
+    }
+    async prompt(params) {
+        const { sessionId, prompt } = params;
+        logger.info(`Received prompt for session ${sessionId}`);
+        const agent = this.agents.get(sessionId);
+        if (!agent) {
+            logger.error(`Session ${sessionId} not found`);
+            throw new Error(`Session ${sessionId} not found`);
+        }
+        // Map ACP prompt to Wave Agent sendMessage
+        const textContent = prompt
+            .filter((block) => block.type === "text")
+            .map((block) => block.text)
+            .join("\n");
+        const images = prompt
+            .filter((block) => block.type === "image")
+            .map((block) => {
+            const img = block;
+            return {
+                path: `data:${img.mimeType};base64,${img.data}`,
+                mimeType: img.mimeType,
+            };
+        });
+        try {
+            logger.info(`Sending message to agent: ${textContent.substring(0, 50)}...`);
+            await agent.sendMessage(textContent, images.length > 0 ? images : undefined);
+            logger.info(`Message sent successfully for session ${sessionId}`);
+            return {
+                stopReason: "end_turn",
+            };
+        }
+        catch (error) {
+            if (error instanceof Error && error.message.includes("abort")) {
+                logger.info(`Message aborted for session ${sessionId}`);
+                return {
+                    stopReason: "cancelled",
+                };
+            }
+            logger.error(`Error sending message for session ${sessionId}:`, error);
+            throw error;
+        }
+    }
+    async cancel(params) {
+        const { sessionId } = params;
+        logger.info(`Cancelling message for session ${sessionId}`);
+        const agent = this.agents.get(sessionId);
+        if (agent) {
+            agent.abortMessage();
+        }
+    }
+    async handlePermissionRequest(sessionId, context) {
+        logger.info(`Handling permission request for ${context.toolName} in session ${sessionId}`);
+        const agent = this.agents.get(sessionId);
+        const workdir = agent?.workingDirectory || process.cwd();
+        const toolCallId = context.toolCallId ||
+            "perm-" + Math.random().toString(36).substring(2, 9);
+        const options = [
+            {
+                optionId: "allow_once",
+                name: "Allow Once",
+                kind: "allow_once",
+            },
+            {
+                optionId: "allow_always",
+                name: "Allow Always",
+                kind: "allow_always",
+            },
+            {
+                optionId: "reject_once",
+                name: "Reject Once",
+                kind: "reject_once",
+            },
+            {
+                optionId: "reject_always",
+                name: "Reject Always",
+                kind: "reject_always",
+            },
+        ];
+        const content = context.toolName
+            ? await this.getToolContentAsync(context.toolName, context.toolInput, workdir)
+            : undefined;
+        const locations = context.toolName
+            ? this.getToolLocations(context.toolName, context.toolInput)
+            : undefined;
+        const kind = context.toolName
+            ? this.getToolKind(context.toolName)
+            : undefined;
+        try {
+            const response = await this.connection.requestPermission({
+                sessionId: sessionId,
+                toolCall: {
+                    toolCallId,
+                    title: `Permission for ${context.toolName}`,
+                    status: "pending",
+                    rawInput: context.toolInput,
+                    content,
+                    locations,
+                    kind,
+                },
+                options,
+            });
+            if (response.outcome.outcome === "cancelled") {
+                return { behavior: "deny", message: "Cancelled by user" };
+            }
+            const selectedOptionId = response.outcome.optionId;
+            logger.info(`User selected permission option: ${selectedOptionId}`);
+            switch (selectedOptionId) {
+                case "allow_once":
+                    return { behavior: "allow" };
+                case "allow_always":
+                    return {
+                        behavior: "allow",
+                        newPermissionRule: `${context.toolName}(*)`,
+                    };
+                case "reject_once":
+                    return { behavior: "deny", message: "Rejected by user" };
+                case "reject_always":
+                    return {
+                        behavior: "deny",
+                        message: "Rejected by user",
+                        newPermissionRule: `!${context.toolName}(*)`,
+                    };
+                default:
+                    return { behavior: "deny", message: "Unknown option selected" };
+            }
+        }
+        catch (error) {
+            logger.error("Error requesting permission via ACP:", error);
+            return {
+                behavior: "deny",
+                message: `Error requesting permission: ${error instanceof Error ? error.message : String(error)}`,
+            };
+        }
+    }
+    async getToolContentAsync(name, parameters, workdir) {
+        if (!parameters)
+            return undefined;
+        if (name === "Write") {
+            let oldText = null;
+            try {
+                const filePath = parameters.file_path;
+                const fullPath = path.isAbsolute(filePath)
+                    ? filePath
+                    : path.join(workdir, filePath);
+                oldText = await fs.readFile(fullPath, "utf-8");
+            }
+            catch {
+                // File might not exist, which is fine for Write
+            }
+            return [
+                {
+                    type: "diff",
+                    path: parameters.file_path,
+                    oldText,
+                    newText: parameters.content,
+                },
+            ];
+        }
+        if (name === "Edit") {
+            let oldText = null;
+            let newText = null;
+            try {
+                const filePath = parameters.file_path;
+                const fullPath = path.isAbsolute(filePath)
+                    ? filePath
+                    : path.join(workdir, filePath);
+                oldText = await fs.readFile(fullPath, "utf-8");
+                if (oldText) {
+                    if (parameters.replace_all) {
+                        newText = oldText
+                            .split(parameters.old_string)
+                            .join(parameters.new_string);
+                    }
+                    else {
+                        newText = oldText.replace(parameters.old_string, parameters.new_string);
+                    }
+                }
+            }
+            catch {
+                logger.error("Failed to read file for Edit diff");
+            }
+            if (oldText && newText) {
+                return [
+                    {
+                        type: "diff",
+                        path: parameters.file_path,
+                        oldText,
+                        newText,
+                    },
+                ];
+            }
+            // Fallback to snippets if file reading fails
+            return [
+                {
+                    type: "diff",
+                    path: parameters.file_path,
+                    oldText: parameters.old_string,
+                    newText: parameters.new_string,
+                },
+            ];
+        }
+        return this.getToolContent(name, parameters);
+    }
+    getToolContent(name, parameters) {
+        if (!parameters)
+            return undefined;
+        if (name === "Write") {
+            return [
+                {
+                    type: "diff",
+                    path: parameters.file_path,
+                    oldText: null,
+                    newText: parameters.content,
+                },
+            ];
+        }
+        if (name === "Edit") {
+            return [
+                {
+                    type: "diff",
+                    path: parameters.file_path,
+                    oldText: parameters.old_string,
+                    newText: parameters.new_string,
+                },
+            ];
+        }
+        return undefined;
+    }
+    getToolLocations(name, parameters) {
+        if (!parameters)
+            return undefined;
+        if (name === "Write" || name === "Edit" || name === "Read") {
+            return [
+                {
+                    path: parameters.file_path,
+                    line: parameters.offset,
+                },
+            ];
+        }
+        return undefined;
+    }
+    getToolKind(name) {
+        switch (name) {
+            case "Read":
+            case "Glob":
+            case "Grep":
+            case "LSP":
+                return "read";
+            case "Write":
+            case "Edit":
+                return "edit";
+            case "Bash":
+                return "execute";
+            case "Agent":
+                return "other";
+            default:
+                return "other";
+        }
+    }
+    createCallbacks(sessionId) {
+        const getAgent = () => this.agents.get(sessionId);
+        return {
+            onAssistantContentUpdated: (chunk) => {
+                this.connection.sessionUpdate({
+                    sessionId: sessionId,
+                    update: {
+                        sessionUpdate: "agent_message_chunk",
+                        content: {
+                            type: "text",
+                            text: chunk,
+                        },
+                    },
+                });
+            },
+            onAssistantReasoningUpdated: (chunk) => {
+                this.connection.sessionUpdate({
+                    sessionId: sessionId,
+                    update: {
+                        sessionUpdate: "agent_thought_chunk",
+                        content: {
+                            type: "text",
+                            text: chunk,
+                        },
+                    },
+                });
+            },
+            onToolBlockUpdated: (params) => {
+                const { id, name, stage, success, error, result, parameters } = params;
+                let parsedParameters = undefined;
+                if (parameters) {
+                    try {
+                        parsedParameters = JSON.parse(parameters);
+                    }
+                    catch {
+                        // Ignore parse errors during streaming
+                    }
+                }
+                const content = name && parsedParameters
+                    ? this.getToolContent(name, parsedParameters)
+                    : undefined;
+                const locations = name && parsedParameters
+                    ? this.getToolLocations(name, parsedParameters)
+                    : undefined;
+                const kind = name ? this.getToolKind(name) : undefined;
+                if (stage === "start") {
+                    this.connection.sessionUpdate({
+                        sessionId: sessionId,
+                        update: {
+                            sessionUpdate: "tool_call",
+                            toolCallId: id,
+                            title: name || "Tool Call",
+                            status: "pending",
+                            content,
+                            locations,
+                            kind,
+                            rawInput: parsedParameters,
+                        },
+                    });
+                    return;
+                }
+                if (stage === "streaming") {
+                    // We don't support streaming tool arguments in ACP yet
+                    return;
+                }
+                const status = stage === "end"
+                    ? success
+                        ? "completed"
+                        : "failed"
+                    : stage === "running"
+                        ? "in_progress"
+                        : "pending";
+                this.connection.sessionUpdate({
+                    sessionId: sessionId,
+                    update: {
+                        sessionUpdate: "tool_call_update",
+                        toolCallId: id,
+                        status,
+                        title: name || "Tool Call",
+                        rawOutput: result || error,
+                        content,
+                        locations,
+                        kind,
+                        rawInput: parsedParameters,
+                    },
+                });
+            },
+            onTasksChange: (tasks) => {
+                this.connection.sessionUpdate({
+                    sessionId: sessionId,
+                    update: {
+                        sessionUpdate: "plan",
+                        entries: tasks.map((task) => ({
+                            content: task.subject,
+                            status: task.status === "completed"
+                                ? "completed"
+                                : task.status === "in_progress"
+                                    ? "in_progress"
+                                    : "pending",
+                            priority: "medium",
+                        })),
+                    },
+                });
+            },
+            onPermissionModeChange: (mode) => {
+                this.connection.sessionUpdate({
+                    sessionId: sessionId,
+                    update: {
+                        sessionUpdate: "current_mode_update",
+                        currentModeId: mode,
+                    },
+                });
+                const agent = getAgent();
+                if (agent) {
+                    this.connection.sessionUpdate({
+                        sessionId: sessionId,
+                        update: {
+                            sessionUpdate: "config_option_update",
+                            configOptions: this.getSessionConfigOptions(agent),
+                        },
+                    });
+                }
+            },
+        };
+    }
+}

package/dist/acp/index.d.ts

@@ -0,0 +1,2 @@
+export declare function startAcpCli(): Promise<void>;
+//# sourceMappingURL=index.d.ts.map

package/dist/acp/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/acp/index.ts"],"names":[],"mappings":"AAKA,wBAAsB,WAAW,kBAsBhC"}

package/dist/acp/index.js

@@ -0,0 +1,22 @@
+import { Readable, Writable } from "node:stream";
+import { AgentSideConnection, ndJsonStream } from "@agentclientprotocol/sdk";
+import { WaveAcpAgent } from "./agent.js";
+import { logger } from "../utils/logger.js";
+export async function startAcpCli() {
+    // Redirect console.log to logger to avoid interfering with JSON-RPC over stdio
+    console.log = (...args) => {
+        logger.info(...args);
+    };
+    logger.info("Starting ACP bridge...");
+    // Convert Node.js stdio to Web streams
+    const stdin = Readable.toWeb(process.stdin);
+    const stdout = Writable.toWeb(process.stdout);
+    // Create ACP stream
+    const stream = ndJsonStream(stdout, stdin);
+    // Initialize AgentSideConnection
+    const connection = new AgentSideConnection((conn) => {
+        return new WaveAcpAgent(conn);
+    }, stream);
+    // Wait for connection to close
+    await connection.closed;
+}

package/dist/acp-cli.d.ts

@@ -0,0 +1,2 @@
+export declare function runAcp(): Promise<void>;
+//# sourceMappingURL=acp-cli.d.ts.map

package/dist/acp-cli.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"acp-cli.d.ts","sourceRoot":"","sources":["../src/acp-cli.ts"],"names":[],"mappings":"AAEA,wBAAsB,MAAM,kBAE3B"}

package/dist/acp-cli.js

@@ -0,0 +1,4 @@
+import { startAcpCli } from "./acp/index.js";
+export async function runAcp() {
+    await startAcpCli();
+}

package/dist/components/ChatInterface.js

@@ -39,7 +39,7 @@ export const ChatInterface = () => {
         }
         const terminalHeight = stdout?.rows || 24;
         const totalHeight = detailsHeight + selectorHeight + dynamicBlocksHeight;
-        if (totalHeight > terminalHeight) {
+        if (totalHeight > terminalHeight - 3) {
             setIsConfirmationTooTall(true);
         }
     }, [