wave-code 0.9.7 → 0.10.0

package/dist/acp/agent.d.ts

@@ -0,0 +1,14 @@
+import type { Agent as AcpAgent, AgentSideConnection, InitializeResponse, NewSessionRequest, NewSessionResponse, LoadSessionRequest, LoadSessionResponse, PromptRequest, PromptResponse, CancelNotification, AuthenticateResponse } from "@agentclientprotocol/sdk";
+export declare class WaveAcpAgent implements AcpAgent {
+    private agents;
+    private connection;
+    constructor(connection: AgentSideConnection);
+    initialize(): Promise<InitializeResponse>;
+    authenticate(): Promise<AuthenticateResponse | void>;
+    newSession(params: NewSessionRequest): Promise<NewSessionResponse>;
+    loadSession(params: LoadSessionRequest): Promise<LoadSessionResponse>;
+    prompt(params: PromptRequest): Promise<PromptResponse>;
+    cancel(params: CancelNotification): Promise<void>;
+    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":"AAEA,OAAO,KAAK,EACV,KAAK,IAAI,QAAQ,EACjB,mBAAmB,EACnB,kBAAkB,EAClB,iBAAiB,EACjB,kBAAkB,EAClB,kBAAkB,EAClB,mBAAmB,EACnB,aAAa,EACb,cAAc,EACd,kBAAkB,EAClB,oBAAoB,EAIrB,MAAM,0BAA0B,CAAC;AAElC,qBAAa,YAAa,YAAW,QAAQ;IAC3C,OAAO,CAAC,MAAM,CAAqC;IACnD,OAAO,CAAC,UAAU,CAAsB;gBAE5B,UAAU,EAAE,mBAAmB;IAIrC,UAAU,IAAI,OAAO,CAAC,kBAAkB,CAAC;IAczC,YAAY,IAAI,OAAO,CAAC,oBAAoB,GAAG,IAAI,CAAC;IAIpD,UAAU,CAAC,MAAM,EAAE,iBAAiB,GAAG,OAAO,CAAC,kBAAkB,CAAC;IAsClE,WAAW,CAAC,MAAM,EAAE,kBAAkB,GAAG,OAAO,CAAC,mBAAmB,CAAC;IAmCrE,MAAM,CAAC,MAAM,EAAE,aAAa,GAAG,OAAO,CAAC,cAAc,CAAC;IAuDtD,MAAM,CAAC,MAAM,EAAE,kBAAkB,GAAG,OAAO,CAAC,IAAI,CAAC;IASvD,OAAO,CAAC,eAAe;CAuFxB"}

package/dist/acp/agent.js

@@ -0,0 +1,209 @@
+import { Agent as WaveAgent } from "wave-agent-sdk";
+import { logger } from "../utils/logger.js";
+export class WaveAcpAgent {
+    constructor(connection) {
+        this.agents = new Map();
+        this.connection = connection;
+    }
+    async initialize() {
+        logger.info("Initializing WaveAcpAgent");
+        return {
+            protocolVersion: 1,
+            agentInfo: {
+                name: "wave-agent",
+                version: "0.1.0",
+            },
+            agentCapabilities: {
+                loadSession: true,
+            },
+        };
+    }
+    async authenticate() {
+        // No authentication required for now
+    }
+    async newSession(params) {
+        const { cwd } = params;
+        logger.info(`Creating new session in ${cwd}`);
+        const callbacks = {};
+        const agent = await WaveAgent.create({
+            workdir: cwd,
+            callbacks: {
+                onAssistantContentUpdated: (chunk) => callbacks.onAssistantContentUpdated?.(chunk, ""),
+                onAssistantReasoningUpdated: (chunk) => callbacks.onAssistantReasoningUpdated?.(chunk, ""),
+                onToolBlockUpdated: (params) => {
+                    const cb = callbacks.onToolBlockUpdated;
+                    cb?.(params);
+                },
+                onTasksChange: (tasks) => {
+                    const cb = callbacks.onTasksChange;
+                    cb?.(tasks);
+                },
+            },
+        });
+        const sessionId = agent.sessionId;
+        logger.info(`New session created: ${sessionId}`);
+        this.agents.set(sessionId, agent);
+        // Update the callbacks object with the correct sessionId
+        Object.assign(callbacks, this.createCallbacks(sessionId));
+        return {
+            sessionId: sessionId,
+        };
+    }
+    async loadSession(params) {
+        const { sessionId } = params;
+        logger.info(`Loading session: ${sessionId}`);
+        const callbacks = {};
+        const agent = await WaveAgent.create({
+            restoreSessionId: sessionId,
+            callbacks: {
+                onAssistantContentUpdated: (chunk) => callbacks.onAssistantContentUpdated?.(chunk, ""),
+                onAssistantReasoningUpdated: (chunk) => callbacks.onAssistantReasoningUpdated?.(chunk, ""),
+                onToolBlockUpdated: (params) => {
+                    const cb = callbacks.onToolBlockUpdated;
+                    cb?.(params);
+                },
+                onTasksChange: (tasks) => {
+                    const cb = callbacks.onTasksChange;
+                    cb?.(tasks);
+                },
+            },
+        });
+        this.agents.set(sessionId, agent);
+        logger.info(`Session loaded: ${sessionId}`);
+        // Update the callbacks object with the correct sessionId
+        Object.assign(callbacks, this.createCallbacks(sessionId));
+        return {};
+    }
+    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);
+            // Force save session so it can be loaded later
+            await agent.messageManager.saveSession();
+            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();
+        }
+    }
+    createCallbacks(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 } = params;
+                if (stage === "start") {
+                    this.connection.sessionUpdate({
+                        sessionId: sessionId,
+                        update: {
+                            sessionUpdate: "tool_call",
+                            toolCallId: id,
+                            title: name || "Tool Call",
+                            status: "pending",
+                        },
+                    });
+                    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,
+                    },
+                });
+            },
+            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",
+                        })),
+                    },
+                });
+            },
+        };
+    }
+}

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/DiffDisplay.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"DiffDisplay.d.ts","sourceRoot":"","sources":["../../src/components/DiffDisplay.tsx"],"names":[],"mappings":"AAAA,OAAO,KAAkB,MAAM,OAAO,CAAC;AAMvC,UAAU,gBAAgB;IACxB,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,eAAe,CAAC,EAAE,MAAM,CAAC;CAC1B;AAED,eAAO,MAAM,WAAW,EAAE,KAAK,CAAC,EAAE,CAAC,gBAAgB,CA8VlD,CAAC"}
+{"version":3,"file":"DiffDisplay.d.ts","sourceRoot":"","sources":["../../src/components/DiffDisplay.tsx"],"names":[],"mappings":"AAAA,OAAO,KAAkB,MAAM,OAAO,CAAC;AAMvC,UAAU,gBAAgB;IACxB,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,eAAe,CAAC,EAAE,MAAM,CAAC;CAC1B;AAED,eAAO,MAAM,WAAW,EAAE,KAAK,CAAC,EAAE,CAAC,gBAAgB,CA0VlD,CAAC"}

package/dist/components/DiffDisplay.js

@@ -1,5 +1,5 @@
 import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
-import React, { useMemo } from "react";
+import { useMemo } from "react";
 import { Box, Text } from "ink";
 import { WRITE_TOOL_NAME, EDIT_TOOL_NAME } from "wave-agent-sdk";
 import { transformToolBlockToChanges } from "../utils/toolParameterTransforms.js";
@@ -85,26 +85,46 @@ export const DiffDisplay = ({ toolName, parameters, startLineNumber, }) => {
                     let newLineNum = change.startLineNumber || 1;
                     // Process line diffs
                     const diffElements = [];
-                    lineDiffs.forEach((part, partIndex) => {
+                    for (let i = 0; i < lineDiffs.length; i++) {
+                        const part = lineDiffs[i];
                         const lines = part.value.split("\n");
                         // diffLines might return a trailing empty string if the content ends with a newline
                         if (lines[lines.length - 1] === "") {
                             lines.pop();
                         }
-                        if (part.added) {
+                        if (part.removed) {
+                            // Look ahead for an added block
+                            if (i + 1 < lineDiffs.length && lineDiffs[i + 1].added) {
+                                const nextPart = lineDiffs[i + 1];
+                                const addedLines = nextPart.value.split("\n");
+                                if (addedLines[addedLines.length - 1] === "") {
+                                    addedLines.pop();
+                                }
+                                if (lines.length === addedLines.length) {
+                                    // Word-level diffing
+                                    lines.forEach((line, lineIndex) => {
+                                        const { removedParts, addedParts } = renderWordLevelDiff(line, addedLines[lineIndex], `word-${changeIndex}-${i}-${lineIndex}`);
+                                        diffElements.push(renderLine(oldLineNum++, null, "-", removedParts, "red", `remove-${changeIndex}-${i}-${lineIndex}`));
+                                        diffElements.push(renderLine(null, newLineNum++, "+", addedParts, "green", `add-${changeIndex}-${i}-${lineIndex}`));
+                                    });
+                                    i++; // Skip the added block
+                                    continue;
+                                }
+                            }
+                            // Fallback to standard removed rendering
                             lines.forEach((line, lineIndex) => {
-                                diffElements.push(renderLine(null, newLineNum++, "+", line, "green", `add-${changeIndex}-${partIndex}-${lineIndex}`));
+                                diffElements.push(renderLine(oldLineNum++, null, "-", line, "red", `remove-${changeIndex}-${i}-${lineIndex}`));
                             });
                         }
-                        else if (part.removed) {
+                        else if (part.added) {
                             lines.forEach((line, lineIndex) => {
-                                diffElements.push(renderLine(oldLineNum++, null, "-", line, "red", `remove-${changeIndex}-${partIndex}-${lineIndex}`));
+                                diffElements.push(renderLine(null, newLineNum++, "+", line, "green", `add-${changeIndex}-${i}-${lineIndex}`));
                             });
                         }
                         else {
                             // Context lines - show unchanged content
-                            const isFirstBlock = partIndex === 0;
-                            const isLastBlock = partIndex === lineDiffs.length - 1;
+                            const isFirstBlock = i === 0;
+                            const isLastBlock = i === lineDiffs.length - 1;
                             let linesToDisplay = lines;
                             let showEllipsisTop = false;
                             let showEllipsisBottom = false;
@@ -133,7 +153,7 @@ export const DiffDisplay = ({ toolName, parameters, startLineNumber, }) => {
                                 }
                             }
                             if (showEllipsisTop) {
-                                diffElements.push(_jsx(Box, { children: _jsxs(Text, { color: "gray", children: [" ".repeat(maxDigits * 2 + 2), "..."] }) }, `ellipsis-top-${changeIndex}-${partIndex}`));
+                                diffElements.push(_jsx(Box, { children: _jsxs(Text, { color: "gray", children: [" ".repeat(maxDigits * 2 + 2), "..."] }) }, `ellipsis-top-${changeIndex}-${i}`));
                             }
                             linesToDisplay.forEach((line, lineIndex) => {
                                 // If it's a middle block and we are at the split point
@@ -144,9 +164,9 @@ export const DiffDisplay = ({ toolName, parameters, startLineNumber, }) => {
                                     const skipCount = lines.length - 6;
                                     oldLineNum += skipCount;
                                     newLineNum += skipCount;
-                                    diffElements.push(_jsx(Box, { children: _jsxs(Text, { color: "gray", children: [" ".repeat(maxDigits * 2 + 2), "..."] }) }, `ellipsis-mid-${changeIndex}-${partIndex}`));
+                                    diffElements.push(_jsx(Box, { children: _jsxs(Text, { color: "gray", children: [" ".repeat(maxDigits * 2 + 2), "..."] }) }, `ellipsis-mid-${changeIndex}-${i}`));
                                 }
-                                diffElements.push(renderLine(oldLineNum++, newLineNum++, " ", line, "white", `context-${changeIndex}-${partIndex}-${lineIndex}`));
+                                diffElements.push(renderLine(oldLineNum++, newLineNum++, " ", line, "white", `context-${changeIndex}-${i}-${lineIndex}`));
                             });
                             if (showEllipsisBottom) {
                                 const skipCount = lines.length - linesToDisplay.length;
@@ -154,34 +174,11 @@ export const DiffDisplay = ({ toolName, parameters, startLineNumber, }) => {
                                 // But we need to account for the lines we skipped at the end of this block
                                 oldLineNum += skipCount;
                                 newLineNum += skipCount;
-                                diffElements.push(_jsx(Box, { children: _jsxs(Text, { color: "gray", children: [" ".repeat(maxDigits * 2 + 2), "..."] }) }, `ellipsis-bottom-${changeIndex}-${partIndex}`));
+                                diffElements.push(_jsx(Box, { children: _jsxs(Text, { color: "gray", children: [" ".repeat(maxDigits * 2 + 2), "..."] }) }, `ellipsis-bottom-${changeIndex}-${i}`));
                             }
                         }
-                    });
-                    // If it's a single line change (one removed, one added), use word-level diff
-                    if (diffElements.length === 2 &&
-                        React.isValidElement(diffElements[0]) &&
-                        React.isValidElement(diffElements[1]) &&
-                        typeof diffElements[0].key === "string" &&
-                        diffElements[0].key.includes("remove-") &&
-                        typeof diffElements[1].key === "string" &&
-                        diffElements[1].key.includes("add-")) {
-                        const removedText = extractTextFromElement(diffElements[0]);
-                        const addedText = extractTextFromElement(diffElements[1]);
-                        const oldLineNumVal = extractOldLineNumFromElement(diffElements[0]);
-                        const newLineNumVal = extractNewLineNumFromElement(diffElements[1]);
-                        if (removedText && addedText) {
-                            const { removedParts, addedParts } = renderWordLevelDiff(removedText, addedText, `word-${changeIndex}`);
-                            allElements.push(renderLine(oldLineNumVal, null, "-", removedParts, "red", `word-diff-removed-${changeIndex}`));
-                            allElements.push(renderLine(null, newLineNumVal, "+", addedParts, "green", `word-diff-added-${changeIndex}`));
-                        }
-                        else {
-                            allElements.push(...diffElements);
-                        }
-                    }
-                    else {
-                        allElements.push(...diffElements);
                     }
+                    allElements.push(...diffElements);
                 }
                 catch (error) {
                     console.warn(`Error rendering diff for change ${changeIndex}:`, error);
@@ -202,56 +199,3 @@ export const DiffDisplay = ({ toolName, parameters, startLineNumber, }) => {
     }
     return (_jsx(Box, { flexDirection: "column", children: _jsx(Box, { paddingLeft: 2, borderLeft: true, borderColor: "cyan", flexDirection: "column", children: renderExpandedDiff() }) }));
 };
-// Helper function to extract text content from a React element
-const extractTextFromElement = (element) => {
-    if (!React.isValidElement(element))
-        return null;
-    // Navigate through Box -> Text structure
-    // Our new structure is: Box -> Text (old), Text (new), Text (|), Text (prefix), Text (content)
-    const children = element.props.children;
-    if (Array.isArray(children) && children.length >= 5) {
-        const textElement = children[4]; // Fifth child should be the Text with content
-        if (React.isValidElement(textElement)) {
-            const textChildren = textElement.props
-                .children;
-            return Array.isArray(textChildren)
-                ? textChildren.join("")
-                : String(textChildren || "");
-        }
-    }
-    return null;
-};
-const extractOldLineNumFromElement = (element) => {
-    if (!React.isValidElement(element))
-        return null;
-    const children = element.props.children;
-    if (Array.isArray(children) && children.length >= 1) {
-        const textElement = children[0];
-        if (React.isValidElement(textElement)) {
-            const textChildren = textElement.props
-                .children;
-            const val = (Array.isArray(textChildren)
-                ? textChildren.join("")
-                : String(textChildren || "")).trim();
-            return val ? parseInt(val, 10) : null;
-        }
-    }
-    return null;
-};
-const extractNewLineNumFromElement = (element) => {
-    if (!React.isValidElement(element))
-        return null;
-    const children = element.props.children;
-    if (Array.isArray(children) && children.length >= 2) {
-        const textElement = children[1];
-        if (React.isValidElement(textElement)) {
-            const textChildren = textElement.props
-                .children;
-            const val = (Array.isArray(textChildren)
-                ? textChildren.join("")
-                : String(textChildren || "")).trim();
-            return val ? parseInt(val, 10) : null;
-        }
-    }
-    return null;
-};

package/dist/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAeA,wBAAsB,IAAI,kBAuSzB;AAGD,OAAO,EAAE,QAAQ,EAAE,MAAM,UAAU,CAAC;AAGpC,OAAO,EAAE,MAAM,EAAE,MAAM,mBAAmB,CAAC;AAG3C,OAAO,EACL,kBAAkB,EAClB,gBAAgB,EAChB,iBAAiB,EACjB,KAAK,oBAAoB,GAC1B,MAAM,sBAAsB,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAeA,wBAAsB,IAAI,kBAkTzB;AAGD,OAAO,EAAE,QAAQ,EAAE,MAAM,UAAU,CAAC;AAGpC,OAAO,EAAE,MAAM,EAAE,MAAM,mBAAmB,CAAC;AAG3C,OAAO,EACL,kBAAkB,EAClB,gBAAgB,EAChB,iBAAiB,EACjB,KAAK,oBAAoB,GAC1B,MAAM,sBAAsB,CAAC"}

package/dist/index.js

@@ -65,6 +65,11 @@ export async function main() {
             description: "Specify the AI model to use",
             type: "string",
             global: false,
+        })
+            .option("acp", {
+            description: "Run as an ACP bridge",
+            type: "boolean",
+            global: false,
         })
             .command("plugin", "Manage plugins and marketplaces", (yargs) => {
             return yargs
@@ -170,6 +175,11 @@ export async function main() {
         if (worktreeSession) {
             process.chdir(workdir);
         }
+        // Handle ACP mode
+        if (argv.acp) {
+            const { runAcp } = await import("./acp-cli.js");
+            return runAcp();
+        }
         // Handle restore session command
         if (argv.restore === "" ||
             (process.argv.includes("-r") && argv.restore === undefined) ||

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "wave-code",
-  "version": "0.9.7",
+  "version": "0.10.0",
   "description": "CLI-based code assistant powered by AI, built with React and Ink",
   "repository": {
     "type": "git",
@@ -39,7 +39,9 @@
     "react": "^19.2.4",
     "react-dom": "19.2.4",
     "yargs": "^17.7.2",
-    "wave-agent-sdk": "0.9.7"
+    "@agentclientprotocol/sdk": "0.15.0",
+    "zod": "^3.23.8",
+    "wave-agent-sdk": "0.10.0"
   },
   "devDependencies": {
     "@types/react": "^19.1.8",

package/src/acp/agent.ts

@@ -0,0 +1,270 @@
+import { Agent as WaveAgent, AgentOptions } from "wave-agent-sdk";
+import { logger } from "../utils/logger.js";
+import type {
+  Agent as AcpAgent,
+  AgentSideConnection,
+  InitializeResponse,
+  NewSessionRequest,
+  NewSessionResponse,
+  LoadSessionRequest,
+  LoadSessionResponse,
+  PromptRequest,
+  PromptResponse,
+  CancelNotification,
+  AuthenticateResponse,
+  SessionId as AcpSessionId,
+  ToolCallStatus,
+  StopReason,
+} from "@agentclientprotocol/sdk";
+
+export class WaveAcpAgent implements AcpAgent {
+  private agents: Map<string, WaveAgent> = new Map();
+  private connection: AgentSideConnection;
+
+  constructor(connection: AgentSideConnection) {
+    this.connection = connection;
+  }
+
+  async initialize(): Promise<InitializeResponse> {
+    logger.info("Initializing WaveAcpAgent");
+    return {
+      protocolVersion: 1,
+      agentInfo: {
+        name: "wave-agent",
+        version: "0.1.0",
+      },
+      agentCapabilities: {
+        loadSession: true,
+      },
+    };
+  }
+
+  async authenticate(): Promise<AuthenticateResponse | void> {
+    // No authentication required for now
+  }
+
+  async newSession(params: NewSessionRequest): Promise<NewSessionResponse> {
+    const { cwd } = params;
+    logger.info(`Creating new session in ${cwd}`);
+    const callbacks: AgentOptions["callbacks"] = {};
+    const agent = await WaveAgent.create({
+      workdir: cwd,
+      callbacks: {
+        onAssistantContentUpdated: (chunk: string) =>
+          callbacks.onAssistantContentUpdated?.(chunk, ""),
+        onAssistantReasoningUpdated: (chunk: string) =>
+          callbacks.onAssistantReasoningUpdated?.(chunk, ""),
+        onToolBlockUpdated: (params: unknown) => {
+          const cb = callbacks.onToolBlockUpdated as
+            | ((params: unknown) => void)
+            | undefined;
+          cb?.(params);
+        },
+        onTasksChange: (tasks: unknown[]) => {
+          const cb = callbacks.onTasksChange as
+            | ((tasks: unknown[]) => void)
+            | undefined;
+          cb?.(tasks);
+        },
+      },
+    });
+
+    const sessionId = agent.sessionId;
+    logger.info(`New session created: ${sessionId}`);
+    this.agents.set(sessionId, agent);
+
+    // Update the callbacks object with the correct sessionId
+    Object.assign(callbacks, this.createCallbacks(sessionId));
+
+    return {
+      sessionId: sessionId as AcpSessionId,
+    };
+  }
+
+  async loadSession(params: LoadSessionRequest): Promise<LoadSessionResponse> {
+    const { sessionId } = params;
+    logger.info(`Loading session: ${sessionId}`);
+    const callbacks: AgentOptions["callbacks"] = {};
+    const agent = await WaveAgent.create({
+      restoreSessionId: sessionId,
+      callbacks: {
+        onAssistantContentUpdated: (chunk: string) =>
+          callbacks.onAssistantContentUpdated?.(chunk, ""),
+        onAssistantReasoningUpdated: (chunk: string) =>
+          callbacks.onAssistantReasoningUpdated?.(chunk, ""),
+        onToolBlockUpdated: (params: unknown) => {
+          const cb = callbacks.onToolBlockUpdated as
+            | ((params: unknown) => void)
+            | undefined;
+          cb?.(params);
+        },
+        onTasksChange: (tasks: unknown[]) => {
+          const cb = callbacks.onTasksChange as
+            | ((tasks: unknown[]) => void)
+            | undefined;
+          cb?.(tasks);
+        },
+      },
+    });
+
+    this.agents.set(sessionId, agent);
+    logger.info(`Session loaded: ${sessionId}`);
+
+    // Update the callbacks object with the correct sessionId
+    Object.assign(callbacks, this.createCallbacks(sessionId));
+
+    return {};
+  }
+
+  async prompt(params: PromptRequest): Promise<PromptResponse> {
+    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 as { text: string }).text)
+      .join("\n");
+
+    const images = prompt
+      .filter((block) => block.type === "image")
+      .map((block) => {
+        const img = block as { data: string; mimeType: string };
+        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,
+      );
+      // Force save session so it can be loaded later
+      await (
+        agent as unknown as {
+          messageManager: { saveSession: () => Promise<void> };
+        }
+      ).messageManager.saveSession();
+      logger.info(`Message sent successfully for session ${sessionId}`);
+      return {
+        stopReason: "end_turn" as StopReason,
+      };
+    } catch (error) {
+      if (error instanceof Error && error.message.includes("abort")) {
+        logger.info(`Message aborted for session ${sessionId}`);
+        return {
+          stopReason: "cancelled" as StopReason,
+        };
+      }
+      logger.error(`Error sending message for session ${sessionId}:`, error);
+      throw error;
+    }
+  }
+
+  async cancel(params: CancelNotification): Promise<void> {
+    const { sessionId } = params;
+    logger.info(`Cancelling message for session ${sessionId}`);
+    const agent = this.agents.get(sessionId);
+    if (agent) {
+      agent.abortMessage();
+    }
+  }
+
+  private createCallbacks(sessionId: string): AgentOptions["callbacks"] {
+    return {
+      onAssistantContentUpdated: (chunk: string) => {
+        this.connection.sessionUpdate({
+          sessionId: sessionId as AcpSessionId,
+          update: {
+            sessionUpdate: "agent_message_chunk",
+            content: {
+              type: "text",
+              text: chunk,
+            },
+          },
+        });
+      },
+      onAssistantReasoningUpdated: (chunk: string) => {
+        this.connection.sessionUpdate({
+          sessionId: sessionId as AcpSessionId,
+          update: {
+            sessionUpdate: "agent_thought_chunk",
+            content: {
+              type: "text",
+              text: chunk,
+            },
+          },
+        });
+      },
+      onToolBlockUpdated: (params) => {
+        const { id, name, stage, success, error, result } = params;
+
+        if (stage === "start") {
+          this.connection.sessionUpdate({
+            sessionId: sessionId as AcpSessionId,
+            update: {
+              sessionUpdate: "tool_call",
+              toolCallId: id,
+              title: name || "Tool Call",
+              status: "pending",
+            },
+          });
+          return;
+        }
+
+        if (stage === "streaming") {
+          // We don't support streaming tool arguments in ACP yet
+          return;
+        }
+
+        const status: ToolCallStatus =
+          stage === "end"
+            ? success
+              ? "completed"
+              : "failed"
+            : stage === "running"
+              ? "in_progress"
+              : "pending";
+
+        this.connection.sessionUpdate({
+          sessionId: sessionId as AcpSessionId,
+          update: {
+            sessionUpdate: "tool_call_update",
+            toolCallId: id,
+            status,
+            title: name || "Tool Call",
+            rawOutput: result || error,
+          },
+        });
+      },
+      onTasksChange: (tasks) => {
+        this.connection.sessionUpdate({
+          sessionId: sessionId as AcpSessionId,
+          update: {
+            sessionUpdate: "plan",
+            entries: tasks.map((task) => ({
+              content: task.subject,
+              status:
+                task.status === "completed"
+                  ? "completed"
+                  : task.status === "in_progress"
+                    ? "in_progress"
+                    : "pending",
+              priority: "medium",
+            })),
+          },
+        });
+      },
+    };
+  }
+}

package/src/acp/index.ts

@@ -0,0 +1,28 @@
+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: unknown[]) => {
+    logger.info(...args);
+  };
+
+  logger.info("Starting ACP bridge...");
+
+  // Convert Node.js stdio to Web streams
+  const stdin = Readable.toWeb(process.stdin) as ReadableStream<Uint8Array>;
+  const stdout = Writable.toWeb(process.stdout) as WritableStream<Uint8Array>;
+
+  // 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/src/acp-cli.ts

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

package/src/components/DiffDisplay.tsx

@@ -154,43 +154,87 @@ export const DiffDisplay: React.FC<DiffDisplayProps> = ({
 
           // Process line diffs
           const diffElements: React.ReactNode[] = [];
-          lineDiffs.forEach((part, partIndex) => {
+          for (let i = 0; i < lineDiffs.length; i++) {
+            const part = lineDiffs[i];
             const lines = part.value.split("\n");
             // diffLines might return a trailing empty string if the content ends with a newline
             if (lines[lines.length - 1] === "") {
               lines.pop();
             }
 
-            if (part.added) {
+            if (part.removed) {
+              // Look ahead for an added block
+              if (i + 1 < lineDiffs.length && lineDiffs[i + 1].added) {
+                const nextPart = lineDiffs[i + 1];
+                const addedLines = nextPart.value.split("\n");
+                if (addedLines[addedLines.length - 1] === "") {
+                  addedLines.pop();
+                }
+
+                if (lines.length === addedLines.length) {
+                  // Word-level diffing
+                  lines.forEach((line, lineIndex) => {
+                    const { removedParts, addedParts } = renderWordLevelDiff(
+                      line,
+                      addedLines[lineIndex],
+                      `word-${changeIndex}-${i}-${lineIndex}`,
+                    );
+                    diffElements.push(
+                      renderLine(
+                        oldLineNum++,
+                        null,
+                        "-",
+                        removedParts,
+                        "red",
+                        `remove-${changeIndex}-${i}-${lineIndex}`,
+                      ),
+                    );
+                    diffElements.push(
+                      renderLine(
+                        null,
+                        newLineNum++,
+                        "+",
+                        addedParts,
+                        "green",
+                        `add-${changeIndex}-${i}-${lineIndex}`,
+                      ),
+                    );
+                  });
+                  i++; // Skip the added block
+                  continue;
+                }
+              }
+
+              // Fallback to standard removed rendering
               lines.forEach((line, lineIndex) => {
                 diffElements.push(
                   renderLine(
+                    oldLineNum++,
                     null,
-                    newLineNum++,
-                    "+",
+                    "-",
                     line,
-                    "green",
-                    `add-${changeIndex}-${partIndex}-${lineIndex}`,
+                    "red",
+                    `remove-${changeIndex}-${i}-${lineIndex}`,
                   ),
                 );
               });
-            } else if (part.removed) {
+            } else if (part.added) {
               lines.forEach((line, lineIndex) => {
                 diffElements.push(
                   renderLine(
-                    oldLineNum++,
                     null,
-                    "-",
+                    newLineNum++,
+                    "+",
                     line,
-                    "red",
-                    `remove-${changeIndex}-${partIndex}-${lineIndex}`,
+                    "green",
+                    `add-${changeIndex}-${i}-${lineIndex}`,
                   ),
                 );
               });
             } else {
               // Context lines - show unchanged content
-              const isFirstBlock = partIndex === 0;
-              const isLastBlock = partIndex === lineDiffs.length - 1;
+              const isFirstBlock = i === 0;
+              const isLastBlock = i === lineDiffs.length - 1;
 
               let linesToDisplay = lines;
               let showEllipsisTop = false;
@@ -221,7 +265,7 @@ export const DiffDisplay: React.FC<DiffDisplayProps> = ({
 
               if (showEllipsisTop) {
                 diffElements.push(
-                  <Box key={`ellipsis-top-${changeIndex}-${partIndex}`}>
+                  <Box key={`ellipsis-top-${changeIndex}-${i}`}>
                     <Text color="gray">{" ".repeat(maxDigits * 2 + 2)}...</Text>
                   </Box>,
                 );
@@ -239,7 +283,7 @@ export const DiffDisplay: React.FC<DiffDisplayProps> = ({
                   oldLineNum += skipCount;
                   newLineNum += skipCount;
                   diffElements.push(
-                    <Box key={`ellipsis-mid-${changeIndex}-${partIndex}`}>
+                    <Box key={`ellipsis-mid-${changeIndex}-${i}`}>
                       <Text color="gray">
                         {" ".repeat(maxDigits * 2 + 2)}...
                       </Text>
@@ -254,7 +298,7 @@ export const DiffDisplay: React.FC<DiffDisplayProps> = ({
                     " ",
                     line,
                     "white",
-                    `context-${changeIndex}-${partIndex}-${lineIndex}`,
+                    `context-${changeIndex}-${i}-${lineIndex}`,
                   ),
                 );
               });
@@ -266,62 +310,14 @@ export const DiffDisplay: React.FC<DiffDisplayProps> = ({
                 oldLineNum += skipCount;
                 newLineNum += skipCount;
                 diffElements.push(
-                  <Box key={`ellipsis-bottom-${changeIndex}-${partIndex}`}>
+                  <Box key={`ellipsis-bottom-${changeIndex}-${i}`}>
                     <Text color="gray">{" ".repeat(maxDigits * 2 + 2)}...</Text>
                   </Box>,
                 );
               }
             }
-          });
-
-          // If it's a single line change (one removed, one added), use word-level diff
-          if (
-            diffElements.length === 2 &&
-            React.isValidElement(diffElements[0]) &&
-            React.isValidElement(diffElements[1]) &&
-            typeof diffElements[0].key === "string" &&
-            diffElements[0].key.includes("remove-") &&
-            typeof diffElements[1].key === "string" &&
-            diffElements[1].key.includes("add-")
-          ) {
-            const removedText = extractTextFromElement(diffElements[0]);
-            const addedText = extractTextFromElement(diffElements[1]);
-            const oldLineNumVal = extractOldLineNumFromElement(diffElements[0]);
-            const newLineNumVal = extractNewLineNumFromElement(diffElements[1]);
-
-            if (removedText && addedText) {
-              const { removedParts, addedParts } = renderWordLevelDiff(
-                removedText,
-                addedText,
-                `word-${changeIndex}`,
-              );
-
-              allElements.push(
-                renderLine(
-                  oldLineNumVal,
-                  null,
-                  "-",
-                  removedParts,
-                  "red",
-                  `word-diff-removed-${changeIndex}`,
-                ),
-              );
-              allElements.push(
-                renderLine(
-                  null,
-                  newLineNumVal,
-                  "+",
-                  addedParts,
-                  "green",
-                  `word-diff-added-${changeIndex}`,
-                ),
-              );
-            } else {
-              allElements.push(...diffElements);
-            }
-          } else {
-            allElements.push(...diffElements);
           }
+          allElements.push(...diffElements);
         } catch (error) {
           console.warn(
             `Error rendering diff for change ${changeIndex}:`,
@@ -361,71 +357,3 @@ export const DiffDisplay: React.FC<DiffDisplayProps> = ({
     </Box>
   );
 };
-
-// Helper function to extract text content from a React element
-const extractTextFromElement = (element: React.ReactNode): string | null => {
-  if (!React.isValidElement(element)) return null;
-
-  // Navigate through Box -> Text structure
-  // Our new structure is: Box -> Text (old), Text (new), Text (|), Text (prefix), Text (content)
-  const children = (
-    element.props as unknown as { children?: React.ReactNode[] }
-  ).children;
-  if (Array.isArray(children) && children.length >= 5) {
-    const textElement = children[4]; // Fifth child should be the Text with content
-    if (React.isValidElement(textElement)) {
-      const textChildren = (textElement.props as Record<string, unknown>)
-        .children;
-      return Array.isArray(textChildren)
-        ? textChildren.join("")
-        : String(textChildren || "");
-    }
-  }
-  return null;
-};
-
-const extractOldLineNumFromElement = (
-  element: React.ReactNode,
-): number | null => {
-  if (!React.isValidElement(element)) return null;
-  const children = (
-    element.props as unknown as { children?: React.ReactNode[] }
-  ).children;
-  if (Array.isArray(children) && children.length >= 1) {
-    const textElement = children[0];
-    if (React.isValidElement(textElement)) {
-      const textChildren = (textElement.props as Record<string, unknown>)
-        .children;
-      const val = (
-        Array.isArray(textChildren)
-          ? textChildren.join("")
-          : String(textChildren || "")
-      ).trim();
-      return val ? parseInt(val, 10) : null;
-    }
-  }
-  return null;
-};
-
-const extractNewLineNumFromElement = (
-  element: React.ReactNode,
-): number | null => {
-  if (!React.isValidElement(element)) return null;
-  const children = (
-    element.props as unknown as { children?: React.ReactNode[] }
-  ).children;
-  if (Array.isArray(children) && children.length >= 2) {
-    const textElement = children[1];
-    if (React.isValidElement(textElement)) {
-      const textChildren = (textElement.props as Record<string, unknown>)
-        .children;
-      const val = (
-        Array.isArray(textChildren)
-          ? textChildren.join("")
-          : String(textChildren || "")
-      ).trim();
-      return val ? parseInt(val, 10) : null;
-    }
-  }
-  return null;
-};

package/src/index.ts

@@ -70,6 +70,11 @@ export async function main() {
         type: "string",
         global: false,
       })
+      .option("acp", {
+        description: "Run as an ACP bridge",
+        type: "boolean",
+        global: false,
+      })
       .command("plugin", "Manage plugins and marketplaces", (yargs) => {
         return yargs
           .help()
@@ -246,6 +251,12 @@ export async function main() {
       process.chdir(workdir);
     }
 
+    // Handle ACP mode
+    if (argv.acp) {
+      const { runAcp } = await import("./acp-cli.js");
+      return runAcp();
+    }
+
     // Handle restore session command
     if (
       argv.restore === "" ||