wave-agent-sdk 0.0.1

package/src/utils/messageOperations.ts

@@ -0,0 +1,506 @@
+import type { Message } from "../types.js";
+import { readFileSync } from "fs";
+import { extname } from "path";
+import { ChatCompletionMessageFunctionToolCall } from "openai/resources.js";
+
+// Parameter interfaces for message operations
+export interface AddUserMessageParams {
+  messages: Message[];
+  content: string;
+  images?: Array<{ path: string; mimeType: string }>;
+  customCommandBlock?: {
+    type: "custom_command";
+    commandName: string;
+    content: string;
+    originalInput?: string;
+  };
+}
+
+export interface UpdateToolBlockParams {
+  messages: Message[];
+  id: string;
+  parameters: string;
+  result?: string;
+  success?: boolean;
+  error?: string;
+  isRunning?: boolean;
+  name?: string;
+  shortResult?: string;
+  images?: Array<{ data: string; mediaType?: string }>;
+  compactParams?: string;
+}
+
+// Agent specific interfaces (without messages parameter)
+export interface AgentToolBlockUpdateParams {
+  toolId: string;
+  args?: string;
+  result?: string;
+  success?: boolean;
+  error?: string;
+  isRunning?: boolean;
+  name?: string;
+  shortResult?: string;
+  compactParams?: string;
+}
+
+export interface AddDiffBlockParams {
+  messages: Message[];
+  path: string;
+  diffResult: Array<{ value: string; added?: boolean; removed?: boolean }>;
+}
+
+export interface AddErrorBlockParams {
+  messages: Message[];
+  error: string;
+}
+
+export interface AddMemoryBlockParams {
+  messages: Message[];
+  content: string;
+  isSuccess: boolean;
+  memoryType?: "project" | "user";
+  storagePath?: string;
+}
+
+export interface AddCommandOutputParams {
+  messages: Message[];
+  command: string;
+}
+
+export interface UpdateCommandOutputParams {
+  messages: Message[];
+  command: string;
+  output: string;
+}
+
+export interface CompleteCommandParams {
+  messages: Message[];
+  command: string;
+  exitCode: number;
+}
+
+/**
+ * Extract text content from user messages in the messages array
+ */
+export const extractUserInputHistory = (messages: Message[]): string[] => {
+  return messages
+    .filter((message) => message.role === "user")
+    .map((message) => {
+      // Extract all text block content and merge
+      const textBlocks = message.blocks.filter(
+        (block) => block.type === "text",
+      );
+      return textBlocks
+        .map((block) => block.content)
+        .join(" ")
+        .trim();
+    })
+    .filter((text) => text.length > 0); // Filter out empty text
+};
+
+/**
+ * Convert image file path to base64 format
+ * @param imagePath Image file path
+ * @returns base64 format image data URL
+ */
+export const convertImageToBase64 = (imagePath: string): string => {
+  try {
+    const imageBuffer = readFileSync(imagePath);
+    const ext = extname(imagePath).toLowerCase().substring(1);
+
+    // Determine MIME type based on file extension
+    let mimeType = "image/png"; // Default
+    switch (ext) {
+      case "jpg":
+      case "jpeg":
+        mimeType = "image/jpeg";
+        break;
+      case "png":
+        mimeType = "image/png";
+        break;
+      case "gif":
+        mimeType = "image/gif";
+        break;
+      case "webp":
+        mimeType = "image/webp";
+        break;
+      case "bmp":
+        mimeType = "image/bmp";
+        break;
+      default:
+        mimeType = "image/png";
+    }
+
+    const base64String = imageBuffer.toString("base64");
+    return `data:${mimeType};base64,${base64String}`;
+  } catch {
+    // logger.error(`Failed to convert image to base64: ${imagePath}`, error);
+    // Return an error placeholder or throw error
+    return `data:image/png;base64,`; // Empty base64, avoid program crash
+  }
+};
+
+// Add user message
+export const addUserMessageToMessages = ({
+  messages,
+  content,
+  images,
+  customCommandBlock,
+}: AddUserMessageParams): Message[] => {
+  const blocks: Message["blocks"] = [];
+
+  // If there's a custom command block, use it instead of text content
+  if (customCommandBlock) {
+    blocks.push(customCommandBlock);
+  } else {
+    blocks.push({ type: "text", content });
+  }
+
+  // If there are images, add image block
+  if (images && images.length > 0) {
+    const imageUrls = images.map((img) => img.path);
+    blocks.push({
+      type: "image",
+      imageUrls,
+    });
+  }
+
+  const userMessage: Message = {
+    role: "user",
+    blocks,
+  };
+  return [...messages, userMessage];
+};
+
+// Add assistant message (support one-time addition of answer and tool calls)
+export const addAssistantMessageToMessages = (
+  messages: Message[],
+  content?: string,
+  toolCalls?: ChatCompletionMessageFunctionToolCall[],
+): Message[] => {
+  const blocks: Message["blocks"] = [];
+
+  // If there's answer content, add text block
+  if (content) {
+    blocks.push({ type: "text", content: content });
+  }
+
+  // If there are tool calls, add tool blocks
+  if (toolCalls && toolCalls.length > 0) {
+    toolCalls.forEach((toolCall) => {
+      blocks.push({
+        type: "tool",
+        parameters: toolCall.function.arguments || "",
+        result: "",
+        id: toolCall.id || "",
+        name: toolCall.function?.name || "",
+        isRunning: false,
+      });
+    });
+  }
+
+  const initialAssistantMessage: Message = {
+    role: "assistant",
+    blocks,
+  };
+
+  return [...messages, initialAssistantMessage];
+};
+
+// Update File Operation Block of the last assistant message
+export const addDiffBlockToMessage = ({
+  messages,
+  path,
+  diffResult,
+}: AddDiffBlockParams): Message[] => {
+  const newMessages = [...messages];
+  // Find the last assistant message
+  for (let i = newMessages.length - 1; i >= 0; i--) {
+    if (newMessages[i].role === "assistant") {
+      // Directly add diff block instead of replacing existing blocks
+      newMessages[i].blocks.push({
+        type: "diff",
+        path: path,
+        diffResult: diffResult,
+      });
+      break;
+    }
+  }
+  return newMessages;
+};
+
+// Update Tool Block of the last assistant message
+export const updateToolBlockInMessage = ({
+  messages,
+  id,
+  parameters,
+  result,
+  success,
+  error,
+  isRunning,
+  name,
+  shortResult,
+  images,
+  compactParams,
+}: UpdateToolBlockParams): Message[] => {
+  const newMessages = [...messages];
+  // Find the last assistant message
+  for (let i = newMessages.length - 1; i >= 0; i--) {
+    if (newMessages[i].role === "assistant") {
+      const toolBlockIndex = newMessages[i].blocks.findIndex(
+        (block) => block.type === "tool" && block.id === id,
+      );
+
+      if (toolBlockIndex !== -1) {
+        const toolBlock = newMessages[i].blocks[toolBlockIndex];
+        if (toolBlock.type === "tool") {
+          toolBlock.parameters = parameters;
+          if (result !== undefined) toolBlock.result = result;
+          if (shortResult !== undefined) toolBlock.shortResult = shortResult;
+          toolBlock.images = images; // Add image data update
+          if (success !== undefined) toolBlock.success = success;
+          if (error !== undefined) toolBlock.error = error;
+          if (isRunning !== undefined) toolBlock.isRunning = isRunning;
+          if (compactParams !== undefined)
+            toolBlock.compactParams = compactParams;
+        }
+      } else if (result !== undefined) {
+        // If existing block not found, create new one
+        newMessages[i].blocks.push({
+          type: "tool",
+          parameters: parameters,
+          result: result,
+          shortResult: shortResult,
+          images: images, // Add image data
+          id: id,
+          name: name || "unknown",
+          success: success,
+          error: error,
+          isRunning: isRunning ?? false,
+          compactParams: compactParams,
+        });
+      }
+      break;
+    }
+  }
+  return newMessages;
+};
+
+// Add Error Block to the last assistant message
+export const addErrorBlockToMessage = ({
+  messages,
+  error,
+}: AddErrorBlockParams): Message[] => {
+  const newMessages = [...messages];
+  // Find the last assistant message
+  let assistantMessageFound = false;
+  for (let i = newMessages.length - 1; i >= 0; i--) {
+    if (newMessages[i].role === "assistant") {
+      newMessages[i].blocks = [
+        ...newMessages[i].blocks,
+        {
+          type: "error",
+          content: error,
+        },
+      ];
+      assistantMessageFound = true;
+      break;
+    }
+  }
+
+  // If no assistant message found, create a new assistant message with only error block
+  if (!assistantMessageFound) {
+    newMessages.push({
+      role: "assistant",
+      blocks: [
+        {
+          type: "error",
+          content: error,
+        },
+      ],
+    });
+  }
+
+  return newMessages;
+};
+
+// Add Memory Block as new assistant message
+export const addMemoryBlockToMessage = ({
+  messages,
+  content,
+  isSuccess,
+  memoryType,
+  storagePath,
+}: AddMemoryBlockParams): Message[] => {
+  const newMessages = [...messages];
+
+  // Create new assistant message containing MemoryBlock
+  const memoryMessage: Message = {
+    role: "assistant",
+    blocks: [
+      {
+        type: "memory",
+        content,
+        isSuccess,
+        memoryType,
+        storagePath,
+      },
+    ],
+  };
+
+  // Add to end of message list
+  newMessages.push(memoryMessage);
+  return newMessages;
+};
+
+/**
+ * Count valid blocks from the end
+ * Only text, image, and tool type blocks are counted
+ * @param messages Message array
+ * @param targetCount Number of valid blocks to count
+ * @returns { messageIndex: number, blockCount: number } Message index and actual counted block count
+ */
+export const countValidBlocksFromEnd = (
+  messages: Message[],
+  targetCount: number,
+): { messageIndex: number; blockCount: number } => {
+  let validBlockCount = 0;
+
+  // Iterate messages from end to beginning
+  for (let i = messages.length - 1; i >= 0; i--) {
+    const message = messages[i];
+
+    // Iterate through all blocks of current message
+    for (const block of message.blocks) {
+      // Only count valid block types
+      if (
+        block.type === "text" ||
+        block.type === "image" ||
+        block.type === "tool"
+      ) {
+        validBlockCount++;
+
+        // If target count reached, return current message index
+        if (validBlockCount >= targetCount) {
+          return { messageIndex: i, blockCount: validBlockCount };
+        }
+      }
+    }
+  }
+
+  // If target count not reached, return index 0
+  return { messageIndex: 0, blockCount: validBlockCount };
+};
+
+/**
+ * Get messages to be compressed and insertion position
+ * @param messages Message array
+ * @param keepLastCount Keep the last few valid blocks uncompressed
+ * @returns { messagesToCompress: Message[], insertIndex: number }
+ */
+export const getMessagesToCompress = (
+  messages: Message[],
+  keepLastCount: number = 7,
+): { messagesToCompress: Message[]; insertIndex: number } => {
+  // Calculate message position to keep from end to beginning
+  const { messageIndex } = countValidBlocksFromEnd(messages, keepLastCount);
+
+  // Find the last message containing compression block
+  let lastCompressIndex = -1;
+  for (let i = messages.length - 1; i >= 0; i--) {
+    const hasCompressBlock = messages[i].blocks.some(
+      (block) => block.type === "compress",
+    );
+    if (hasCompressBlock) {
+      lastCompressIndex = i;
+      break;
+    }
+  }
+
+  // Determine compression start position
+  // If compression block exists, start from compression block position (include compression block)
+  // If no compression block, start from beginning
+  const startIndex = lastCompressIndex >= 0 ? lastCompressIndex : 0;
+
+  // Messages to compress are all messages from start position to before calculated position
+  const messagesToCompress = messages.slice(startIndex, messageIndex);
+
+  // Change insertion position to negative number, indicating position from end
+  const insertIndex = messageIndex - messages.length;
+
+  return { messagesToCompress, insertIndex };
+};
+
+// Add command output block to message list
+export const addCommandOutputMessage = ({
+  messages,
+  command,
+}: AddCommandOutputParams): Message[] => {
+  const outputMessage: Message = {
+    role: "assistant",
+    blocks: [
+      {
+        type: "command_output",
+        command,
+        output: "",
+        isRunning: true,
+        exitCode: null,
+      },
+    ],
+  };
+
+  return [...messages, outputMessage];
+};
+
+// Update output content of command output block
+export const updateCommandOutputInMessage = ({
+  messages,
+  command,
+  output,
+}: UpdateCommandOutputParams): Message[] => {
+  const newMessages = [...messages];
+  // Find the last assistant message with a command_output block for this command
+  for (let i = newMessages.length - 1; i >= 0; i--) {
+    const msg = newMessages[i];
+    if (msg.role === "assistant") {
+      const commandBlock = msg.blocks.find(
+        (block) =>
+          block.type === "command_output" &&
+          block.command === command &&
+          block.isRunning,
+      );
+      if (commandBlock && commandBlock.type === "command_output") {
+        commandBlock.output = output.trim();
+        break;
+      }
+    }
+  }
+  return newMessages;
+};
+
+// Complete command execution, update exit status
+export const completeCommandInMessage = ({
+  messages,
+  command,
+  exitCode,
+}: CompleteCommandParams): Message[] => {
+  const newMessages = [...messages];
+  // Find the last assistant message with a command_output block for this command
+  for (let i = newMessages.length - 1; i >= 0; i--) {
+    const msg = newMessages[i];
+    if (msg.role === "assistant") {
+      const commandBlock = msg.blocks.find(
+        (block) =>
+          block.type === "command_output" &&
+          block.command === command &&
+          block.isRunning,
+      );
+      if (commandBlock && commandBlock.type === "command_output") {
+        commandBlock.isRunning = false;
+        commandBlock.exitCode = exitCode;
+        break;
+      }
+    }
+  }
+  return newMessages;
+};

package/src/utils/path.ts

@@ -0,0 +1,118 @@
+import { resolve } from "path";
+import { homedir } from "os";
+import { relative } from "path";
+
+/**
+ * Handle paths, supporting ~ expansion
+ * @param filePath File path
+ * @param workdir Working directory
+ * @returns Resolved absolute path
+ */
+export function resolvePath(filePath: string, workdir: string): string {
+  // If the path starts with ~, replace it with the user's home directory
+  if (filePath.startsWith("~/")) {
+    return resolve(homedir(), filePath.slice(2));
+  }
+
+  // If the path starts with ~ but has no slash, it means it's the home directory
+  if (filePath === "~") {
+    return homedir();
+  }
+
+  // For other paths, resolve using the specified working directory
+  return resolve(workdir, filePath);
+}
+
+/**
+ * Binary file extension list
+ */
+export const binaryExtensions = [
+  // Image files
+  "png",
+  "jpg",
+  "jpeg",
+  "gif",
+  "bmp",
+  "ico",
+  "webp",
+  "svg",
+  "sketch",
+  // Audio files
+  "mp3",
+  "wav",
+  "ogg",
+  "aac",
+  // Video files
+  "mp4",
+  "webm",
+  "avi",
+  "mov",
+  // Document files
+  "pdf",
+  "doc",
+  "docx",
+  "xls",
+  "xlsx",
+  "ppt",
+  "pptx",
+  // Compressed files
+  "zip",
+  "rar",
+  "7z",
+  "tar",
+  "gz",
+  // Font files
+  "ttf",
+  "otf",
+  "woff",
+  "woff2",
+  "eot",
+  // Other binary files
+  "exe",
+  "dll",
+  "so",
+  "dylib",
+  "bin",
+] as const;
+/**
+ * Check if a file is a binary file
+ * @param filename File name
+ * @returns Whether it is a binary file
+ */
+export const isBinary = (filename: string): boolean => {
+  const parts = filename.split(".");
+  const ext = parts.length > 1 ? parts.pop()?.toLowerCase() || "" : "";
+  return binaryExtensions.includes(ext as (typeof binaryExtensions)[number]);
+};
+
+/**
+ * Get relative path for display, use relative path if shorter and not in parent directory
+ * @param filePath Absolute path
+ * @param workdir Working directory
+ * @returns Path for display (relative or absolute)
+ */
+export function getDisplayPath(filePath: string, workdir: string): string {
+  if (!filePath) {
+    return filePath;
+  }
+
+  try {
+    const relativePath = relative(workdir, filePath);
+
+    // If the relative path is empty (i.e., the paths are the same), return "."
+    if (relativePath === "") {
+      return ".";
+    }
+
+    // If the relative path is shorter than the absolute path and does not start with .. (not in parent directory), use the relative path
+    if (
+      relativePath.length < filePath.length &&
+      !relativePath.startsWith("..")
+    ) {
+      return relativePath;
+    }
+  } catch {
+    // If calculating the relative path fails, keep the original path
+  }
+  return filePath;
+}