wave-agent-sdk 0.0.1

package/src/utils/constants.ts

@@ -0,0 +1,37 @@
+/**
+ * Application constants definition
+ */
+
+import path from "path";
+import os from "os";
+
+/**
+ * Application data storage directory
+ * Used to store debug logs, command history and other data
+ */
+export const DATA_DIRECTORY = path.join(os.homedir(), ".wave");
+
+/**
+ * Bash command history file path
+ */
+export const BASH_HISTORY_FILE = path.join(DATA_DIRECTORY, "bash-history.json");
+
+/**
+ * Error log directory path
+ */
+export const ERROR_LOG_DIRECTORY = path.join(DATA_DIRECTORY, "error-logs");
+
+/**
+ * User-level memory file path
+ */
+export const USER_MEMORY_FILE = path.join(DATA_DIRECTORY, "user-memory.md");
+
+/**
+ * AI related constants
+ */
+export const DEFAULT_TOKEN_LIMIT = 64000; // Default token limit
+
+export const FAST_MODEL_ID = process.env.AIGW_FAST_MODEL || "gemini-2.5-flash";
+
+export const AGENT_MODEL_ID =
+  process.env.AIGW_MODEL || "claude-sonnet-4-20250514";

package/src/utils/convertMessagesForAPI.ts

@@ -0,0 +1,236 @@
+import type { Message } from "../types.js";
+import { convertImageToBase64 } from "./messageOperations.js";
+import { ChatCompletionMessageToolCall } from "openai/resources";
+import { stripAnsiColors } from "./stringUtils.js";
+import {
+  ChatCompletionContentPart,
+  ChatCompletionMessageParam,
+} from "openai/resources.js";
+
+/**
+ * Safely handle tool call parameters, ensuring a legal JSON string is returned
+ * @param args Tool call parameters
+ * @returns Legal JSON string
+ */
+function safeToolArguments(args: string): string {
+  if (!args) {
+    return "{}";
+  }
+
+  try {
+    // Try to parse as JSON to validate format
+    JSON.parse(args);
+    return args;
+  } catch {
+    // logger.error(`Invalid tool arguments: ${args}`);
+    // If not valid JSON, return a fallback empty object
+    return "{}";
+  }
+}
+
+/**
+ * Convert message format to API call format, stopping when a compressed message is encountered
+ * @param messages Message list
+ * @returns Converted API message format list
+ */
+export function convertMessagesForAPI(
+  messages: Message[],
+): ChatCompletionMessageParam[] {
+  const recentMessages: ChatCompletionMessageParam[] = [];
+
+  const startIndex = messages.length - 1;
+  for (let i = startIndex; i >= 0; i--) {
+    const message = messages[i];
+
+    // Check if a compression block is encountered, if so, stop iteration
+    if (
+      message.role === "assistant" &&
+      message.blocks.some((block) => block.type === "compress")
+    ) {
+      // Add the content of the compression block as an assistant message to the history
+      const compressBlock = message.blocks.find(
+        (block) => block.type === "compress",
+      );
+      if (compressBlock && compressBlock.type === "compress") {
+        recentMessages.unshift({
+          role: "system",
+          content: `[Compressed Message Summary] ${compressBlock.content}`,
+        });
+      }
+      break;
+    }
+
+    // Skip empty assistant messages
+    if (message.role === "assistant" && message.blocks.length === 0) {
+      continue;
+    }
+
+    if (message.role === "assistant") {
+      // First check if there is a tool block, if so, add the tool message first
+      // Filter out incomplete tool blocks (no result or still running)
+      const toolBlocks = message.blocks.filter(
+        (block) => block.type === "tool",
+      );
+      const completedToolIds = new Set<string>(); // Record completed tool IDs
+
+      if (toolBlocks.length > 0) {
+        toolBlocks.forEach((toolBlock) => {
+          // Only add completed tool blocks (i.e., not running)
+          if (toolBlock.id && !toolBlock.isRunning) {
+            completedToolIds.add(toolBlock.id);
+
+            // Check for image data
+            if (toolBlock.images && toolBlock.images.length > 0) {
+              // If there is an image, create a user message instead of a tool message
+              const contentParts: ChatCompletionContentPart[] = [];
+
+              // Add tool result as text
+              const toolResultText = `Tool result for ${toolBlock.name || "unknown tool"}:\n${stripAnsiColors(toolBlock.result || "")}`;
+              contentParts.push({
+                type: "text",
+                text: toolResultText,
+              });
+
+              // Add image
+              toolBlock.images.forEach((image) => {
+                const imageUrl = image.data.startsWith("data:")
+                  ? image.data
+                  : `data:${image.mediaType || "image/png"};base64,${image.data}`;
+
+                contentParts.push({
+                  type: "image_url",
+                  image_url: {
+                    url: imageUrl,
+                    detail: "auto",
+                  },
+                });
+              });
+
+              // Add user message
+              recentMessages.unshift({
+                role: "user",
+                content: contentParts,
+              });
+            } else {
+              // Normal tool message
+              recentMessages.unshift({
+                tool_call_id: toolBlock.id,
+                role: "tool",
+                content: stripAnsiColors(toolBlock.result || ""),
+              });
+            }
+          }
+        });
+      }
+
+      // Construct the content of the assistant message
+      let content = "";
+      let tool_calls: ChatCompletionMessageToolCall[] | undefined = undefined;
+
+      // Construct content from text blocks
+      const textBlocks = message.blocks.filter(
+        (block) => block.type === "text",
+      );
+      if (textBlocks.length > 0) {
+        content = textBlocks.map((block) => block.content || "").join("\n");
+      }
+
+      // Construct tool calls from tool blocks
+      if (toolBlocks.length > 0) {
+        tool_calls = toolBlocks
+          .filter(
+            (toolBlock) => toolBlock.id && completedToolIds.has(toolBlock.id),
+          )
+          .map((toolBlock) => ({
+            id: toolBlock.id!,
+            type: "function",
+            function: {
+              name: toolBlock.name || "",
+              arguments: safeToolArguments(
+                String(toolBlock.parameters || "{}"),
+              ),
+            },
+          }));
+
+        if (tool_calls.length === 0) {
+          tool_calls = undefined;
+        }
+      }
+
+      // Construct assistant message - only add if there is content or tool calls
+      if (content || tool_calls) {
+        const assistantMessage: ChatCompletionMessageParam = {
+          role: "assistant",
+          content,
+          tool_calls,
+        };
+
+        recentMessages.unshift(assistantMessage);
+      }
+    } else if (message.role === "user") {
+      // User messages converted to standard format
+      const contentParts: ChatCompletionContentPart[] = [];
+
+      message.blocks.forEach((block) => {
+        // Add text content
+        if (block.type === "text" && block.content) {
+          contentParts.push({
+            type: "text",
+            text: block.content,
+          });
+        }
+
+        // Handle custom command blocks - pass full content as text to AI
+        if (block.type === "custom_command" && block.content) {
+          contentParts.push({
+            type: "text",
+            text: block.content,
+          });
+        }
+
+        // If there is an image, add image content
+        if (
+          block.type === "image" &&
+          block.imageUrls &&
+          block.imageUrls.length > 0
+        ) {
+          block.imageUrls.forEach((imageUrl: string) => {
+            // Check if it's already base64, convert if not
+            let finalImageUrl = imageUrl;
+            if (!imageUrl.startsWith("data:image/")) {
+              // If it's a file path, it needs to be converted to base64
+              try {
+                finalImageUrl = convertImageToBase64(imageUrl);
+              } catch (error) {
+                console.error(
+                  "Failed to convert image path to base64:",
+                  imageUrl,
+                  error,
+                );
+                // Skip this image, do not add to content
+                return;
+              }
+            }
+
+            contentParts.push({
+              type: "image_url",
+              image_url: {
+                url: finalImageUrl,
+                detail: "auto",
+              },
+            });
+          });
+        }
+      });
+
+      if (contentParts.length > 0) {
+        recentMessages.unshift({
+          role: "user",
+          content: contentParts,
+        });
+      }
+    }
+  }
+
+  return recentMessages;
+}

package/src/utils/customCommands.ts

@@ -0,0 +1,85 @@
+import { existsSync, readdirSync } from "fs";
+import { join, extname, basename } from "path";
+import { homedir } from "os";
+import type { CustomSlashCommand } from "../types.js";
+import { parseMarkdownFile } from "./markdownParser.js";
+
+/**
+ * Get the project-specific commands directory
+ */
+export function getProjectCommandsDir(workdir: string): string {
+  return join(workdir, ".wave", "commands");
+}
+
+/**
+ * Get the user-specific commands directory
+ */
+export function getUserCommandsDir(): string {
+  return join(homedir(), ".wave", "commands");
+}
+
+/**
+ * Scan a directory for markdown command files
+ */
+function scanCommandsDirectory(dirPath: string): CustomSlashCommand[] {
+  if (!existsSync(dirPath)) {
+    return [];
+  }
+
+  const commands: CustomSlashCommand[] = [];
+
+  try {
+    const files = readdirSync(dirPath);
+
+    for (const file of files) {
+      if (extname(file) !== ".md") {
+        continue;
+      }
+
+      const filePath = join(dirPath, file);
+      const commandName = basename(file, ".md");
+
+      try {
+        const { content, config } = parseMarkdownFile(filePath);
+
+        commands.push({
+          id: commandName,
+          name: commandName,
+          description: config?.description, // Use description from frontmatter
+          filePath,
+          content,
+          config,
+        });
+      } catch (error) {
+        console.warn(`Failed to load custom command from ${filePath}:`, error);
+      }
+    }
+  } catch (error) {
+    console.warn(`Failed to scan commands directory ${dirPath}:`, error);
+  }
+
+  return commands;
+}
+
+/**
+ * Load all custom slash commands from both project and user directories
+ */
+export function loadCustomSlashCommands(workdir: string): CustomSlashCommand[] {
+  const projectCommands = scanCommandsDirectory(getProjectCommandsDir(workdir));
+  const userCommands = scanCommandsDirectory(getUserCommandsDir());
+
+  // Project commands take precedence over user commands with the same name
+  const commandMap = new Map<string, CustomSlashCommand>();
+
+  // Add user commands first
+  for (const command of userCommands) {
+    commandMap.set(command.id, command);
+  }
+
+  // Add project commands (will overwrite user commands with same name)
+  for (const command of projectCommands) {
+    commandMap.set(command.id, command);
+  }
+
+  return Array.from(commandMap.values());
+}

package/src/utils/fileFilter.ts

@@ -0,0 +1,202 @@
+import * as fs from "fs";
+import * as path from "path";
+
+/**
+ * Common ignore directory and file patterns
+ * Can be reused by multiple tools (glob, ripgrep, etc.)
+ */
+export const COMMON_IGNORE_PATTERNS = {
+  // Dependencies and build directories
+  dependencies: [
+    "node_modules/**",
+    ".git/**",
+    "dist/**",
+    "build/**",
+    ".next/**",
+    "coverage/**",
+    ".nyc_output/**",
+    "tmp/**",
+    "temp/**",
+  ],
+
+  // Cache and temporary files
+  cache: ["*.log", "*.cache", ".DS_Store", "Thumbs.db", "*~", "*.swp", "*.swo"],
+
+  // Editor and IDE files
+  editor: [".vscode/**", ".idea/**", "*.sublime-*"],
+
+  // Operating system related
+  os: [".DS_Store", "Thumbs.db", "desktop.ini"],
+};
+
+/**
+ * Get flat array of all common ignore patterns
+ */
+export const getAllIgnorePatterns = (): string[] => {
+  return [
+    ...COMMON_IGNORE_PATTERNS.dependencies,
+    ...COMMON_IGNORE_PATTERNS.cache,
+    ...COMMON_IGNORE_PATTERNS.editor,
+    ...COMMON_IGNORE_PATTERNS.os,
+  ];
+};
+
+/**
+ * Recursively find all .gitignore files in directory
+ * @param dir Directory to search
+ * @param maxDepth Maximum recursion depth to prevent too deep searches
+ * @returns Array of .gitignore file paths
+ */
+const findAllGitignoreFiles = (dir: string, maxDepth: number = 5): string[] => {
+  const gitignoreFiles: string[] = [];
+
+  if (maxDepth <= 0) return gitignoreFiles;
+
+  try {
+    const items = fs.readdirSync(dir, { withFileTypes: true });
+
+    for (const item of items) {
+      const fullPath = path.join(dir, item.name);
+
+      if (item.isFile() && item.name === ".gitignore") {
+        gitignoreFiles.push(fullPath);
+      } else if (item.isDirectory() && !shouldSkipDirectory(item.name)) {
+        // Recursively search subdirectories, but skip some obviously unnecessary directories
+        gitignoreFiles.push(...findAllGitignoreFiles(fullPath, maxDepth - 1));
+      }
+    }
+  } catch {
+    // Ignore permission errors and other issues
+  }
+
+  return gitignoreFiles;
+};
+
+/**
+ * Determine whether to skip searching a directory
+ */
+const shouldSkipDirectory = (dirName: string): boolean => {
+  const skipDirs = [
+    "node_modules",
+    ".git",
+    "dist",
+    "build",
+    ".next",
+    "coverage",
+    ".nyc_output",
+    "tmp",
+    "temp",
+    ".cache",
+  ];
+  return skipDirs.includes(dirName);
+};
+
+/**
+ * Parse single .gitignore file content
+ * @param gitignorePath .gitignore file path
+ * @param basePath Base path for calculating relative paths
+ * @returns Array of parsed glob patterns
+ */
+const parseGitignoreFile = (
+  gitignorePath: string,
+  basePath: string,
+): string[] => {
+  const patterns: string[] = [];
+
+  try {
+    if (fs.existsSync(gitignorePath)) {
+      const gitignoreContent = fs.readFileSync(gitignorePath, "utf8");
+      const gitignoreDir = path.dirname(gitignorePath);
+      // Calculate relative directory relative to base path
+      const relativeDirFromBase = path.relative(basePath, gitignoreDir);
+
+      const lines = gitignoreContent
+        .split("\n")
+        .map((line) => line.trim())
+        .filter((line) => line && !line.startsWith("#"));
+
+      for (const line of lines) {
+        // Skip negation rules (starting with !)
+        if (line.startsWith("!")) {
+          continue;
+        }
+
+        let pattern = line;
+
+        // Handle patterns starting with / (relative to current .gitignore file directory)
+        if (pattern.startsWith("/")) {
+          pattern = pattern.slice(1); // Remove leading /
+        }
+
+        // If .gitignore is in subdirectory, need to add path prefix
+        if (relativeDirFromBase && relativeDirFromBase !== ".") {
+          pattern = path.posix.join(relativeDirFromBase, pattern);
+        }
+
+        // If directory pattern (ending with /)
+        if (pattern.endsWith("/")) {
+          const dirName = pattern.slice(0, -1);
+          // For directory patterns, add both exact match and wildcard match
+          patterns.push(`${dirName}/**`); // Directory and all its sub-content
+          // If no path separators, it's a simple directory name, add global match
+          if (!dirName.includes("/") && !dirName.includes("*")) {
+            patterns.push(`**/${dirName}/**`); // Match directories of same name at any level
+          }
+        } else {
+          // File pattern
+          patterns.push(pattern);
+          // If no wildcards and no extension, also treat as directory
+          if (!pattern.includes("*") && !pattern.includes(".")) {
+            patterns.push(`${pattern}/**`);
+            // Also add global match for simple directory names
+            if (!pattern.includes("/")) {
+              patterns.push(`**/${pattern}/**`);
+            }
+          }
+        }
+      }
+    }
+  } catch {
+    // Ignore errors when reading .gitignore files
+  }
+
+  return patterns;
+};
+
+/**
+ * Parse all .gitignore files in the working directory and its subdirectories and convert to glob patterns
+ * @param workdir Working directory
+ * @returns Array of glob ignore patterns
+ */
+export const parseGitignoreToGlob = (workdir: string): string[] => {
+  const patterns: string[] = [];
+
+  try {
+    // Find all .gitignore files
+    const gitignoreFiles = findAllGitignoreFiles(workdir);
+
+    // Parse each .gitignore file
+    for (const gitignoreFile of gitignoreFiles) {
+      patterns.push(...parseGitignoreFile(gitignoreFile, workdir));
+    }
+  } catch {
+    // Ignore errors during search process
+  }
+
+  return patterns;
+};
+
+/**
+ * Get ignore patterns for glob search
+ * @param workdir Working directory for resolving .gitignore files
+ */
+export const getGlobIgnorePatterns = (workdir?: string): string[] => {
+  const patterns = getAllIgnorePatterns();
+
+  // If working directory is provided, parse .gitignore files
+  if (workdir) {
+    patterns.push(...parseGitignoreToGlob(workdir));
+  }
+
+  return patterns;
+};