wave-code 0.9.6 → 0.10.0

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/commands/plugin/marketplace.ts

@@ -43,8 +43,11 @@ export async function listMarketplacesCommand() {
           sourceInfo = source.url + (source.ref ? `#${source.ref}` : "");
         }
         const builtinLabel = m.isBuiltin ? " [builtin]" : "";
+        const lastUpdatedLabel = m.lastUpdated
+          ? ` (Last updated: ${new Date(m.lastUpdated).toLocaleString()})`
+          : "";
         console.log(
-          `- ${m.name}${builtinLabel}: ${sourceInfo} (${m.source.source})`,
+          `- ${m.name}${builtinLabel}: ${sourceInfo} (${m.source.source})${lastUpdatedLabel}`,
         );
       });
     }

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/components/FileSelector.tsx

@@ -69,7 +69,7 @@ export const FileSelector: React.FC<FileSelectorProps> = ({
     );
   }
 
-  const maxDisplay = 10;
+  const maxDisplay = 5;
 
   // Calculate display window start and end positions
   const getDisplayWindow = () => {
@@ -77,20 +77,19 @@ export const FileSelector: React.FC<FileSelectorProps> = ({
       0,
       Math.min(
         selectedIndex - Math.floor(maxDisplay / 2),
-        files.length - maxDisplay,
+        Math.max(0, files.length - maxDisplay),
       ),
     );
     const endIndex = Math.min(files.length, startIndex + maxDisplay);
-    const adjustedStartIndex = Math.max(0, endIndex - maxDisplay);
 
     return {
-      startIndex: adjustedStartIndex,
-      endIndex: endIndex,
-      displayFiles: files.slice(adjustedStartIndex, endIndex),
+      startIndex,
+      endIndex,
+      displayFiles: files.slice(startIndex, endIndex),
     };
   };
 
-  const { startIndex, endIndex, displayFiles } = getDisplayWindow();
+  const { startIndex, displayFiles } = getDisplayWindow();
 
   return (
     <Box
@@ -100,42 +99,36 @@ export const FileSelector: React.FC<FileSelectorProps> = ({
       borderBottom={false}
       borderLeft={false}
       borderRight={false}
+      gap={1}
     >
-      <Text color="cyan" bold>
-        Select File/Directory {searchQuery && `(filtering: "${searchQuery}")`}
-      </Text>
-
-      {/* Show hint for more files above */}
-      {startIndex > 0 && (
-        <Text dimColor>... {startIndex} more files above</Text>
-      )}
-
-      {displayFiles.map((fileItem, displayIndex) => {
-        const actualIndex = startIndex + displayIndex;
-        const isSelected = actualIndex === selectedIndex;
-
-        return (
-          <Box key={fileItem.path}>
-            <Text
-              color={isSelected ? "black" : "white"}
-              backgroundColor={isSelected ? "cyan" : undefined}
-            >
-              {fileItem.path}
-            </Text>
-          </Box>
-        );
-      })}
-
-      {/* Show hint for more files below */}
-      {endIndex < files.length && (
-        <Text dimColor>... {files.length - endIndex} more files below</Text>
-      )}
-
       <Box>
-        <Text dimColor>
-          Use ↑↓ to navigate, Enter/Tab to select, Escape to cancel
+        <Text color="cyan" bold>
+          Select File/Directory {searchQuery && `(filtering: "${searchQuery}")`}
         </Text>
       </Box>
+
+      <Box flexDirection="column">
+        {displayFiles.map((fileItem, displayIndex) => {
+          const actualIndex = startIndex + displayIndex;
+          const isSelected = actualIndex === selectedIndex;
+
+          return (
+            <Box key={fileItem.path}>
+              <Text
+                color={isSelected ? "black" : "white"}
+                backgroundColor={isSelected ? "cyan" : undefined}
+              >
+                {isSelected ? "▶ " : "  "}
+                {fileItem.path}
+              </Text>
+            </Box>
+          );
+        })}
+      </Box>
+
+      <Box>
+        <Text dimColor>↑↓ navigate • Enter/Tab select • Esc cancel</Text>
+      </Box>
     </Box>
   );
 };