wave-agent-sdk 0.0.1

package/dist/utils/constants.d.ts

@@ -0,0 +1,27 @@
+/**
+ * Application constants definition
+ */
+/**
+ * Application data storage directory
+ * Used to store debug logs, command history and other data
+ */
+export declare const DATA_DIRECTORY: string;
+/**
+ * Bash command history file path
+ */
+export declare const BASH_HISTORY_FILE: string;
+/**
+ * Error log directory path
+ */
+export declare const ERROR_LOG_DIRECTORY: string;
+/**
+ * User-level memory file path
+ */
+export declare const USER_MEMORY_FILE: string;
+/**
+ * AI related constants
+ */
+export declare const DEFAULT_TOKEN_LIMIT = 64000;
+export declare const FAST_MODEL_ID: string;
+export declare const AGENT_MODEL_ID: string;
+//# sourceMappingURL=constants.d.ts.map

package/dist/utils/constants.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"constants.d.ts","sourceRoot":"","sources":["../../src/utils/constants.ts"],"names":[],"mappings":"AAAA;;GAEG;AAKH;;;GAGG;AACH,eAAO,MAAM,cAAc,QAAmC,CAAC;AAE/D;;GAEG;AACH,eAAO,MAAM,iBAAiB,QAAiD,CAAC;AAEhF;;GAEG;AACH,eAAO,MAAM,mBAAmB,QAA0C,CAAC;AAE3E;;GAEG;AACH,eAAO,MAAM,gBAAgB,QAA8C,CAAC;AAE5E;;GAEG;AACH,eAAO,MAAM,mBAAmB,QAAQ,CAAC;AAEzC,eAAO,MAAM,aAAa,QAAoD,CAAC;AAE/E,eAAO,MAAM,cAAc,QAC2B,CAAC"}

package/dist/utils/constants.js

@@ -0,0 +1,28 @@
+/**
+ * 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/dist/utils/convertMessagesForAPI.d.ts

@@ -0,0 +1,9 @@
+import type { Message } from "../types.js";
+import { ChatCompletionMessageParam } from "openai/resources.js";
+/**
+ * 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 declare function convertMessagesForAPI(messages: Message[]): ChatCompletionMessageParam[];
+//# sourceMappingURL=convertMessagesForAPI.d.ts.map

package/dist/utils/convertMessagesForAPI.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"convertMessagesForAPI.d.ts","sourceRoot":"","sources":["../../src/utils/convertMessagesForAPI.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,aAAa,CAAC;AAI3C,OAAO,EAEL,0BAA0B,EAC3B,MAAM,qBAAqB,CAAC;AAuB7B;;;;GAIG;AACH,wBAAgB,qBAAqB,CACnC,QAAQ,EAAE,OAAO,EAAE,GAClB,0BAA0B,EAAE,CAsM9B"}

package/dist/utils/convertMessagesForAPI.js

@@ -0,0 +1,189 @@
+import { convertImageToBase64 } from "./messageOperations.js";
+import { stripAnsiColors } from "./stringUtils.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) {
+    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) {
+    const recentMessages = [];
+    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(); // 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 = [];
+                            // 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 = 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 = {
+                    role: "assistant",
+                    content,
+                    tool_calls,
+                };
+                recentMessages.unshift(assistantMessage);
+            }
+        }
+        else if (message.role === "user") {
+            // User messages converted to standard format
+            const contentParts = [];
+            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) => {
+                        // 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/dist/utils/customCommands.d.ts

@@ -0,0 +1,14 @@
+import type { CustomSlashCommand } from "../types.js";
+/**
+ * Get the project-specific commands directory
+ */
+export declare function getProjectCommandsDir(workdir: string): string;
+/**
+ * Get the user-specific commands directory
+ */
+export declare function getUserCommandsDir(): string;
+/**
+ * Load all custom slash commands from both project and user directories
+ */
+export declare function loadCustomSlashCommands(workdir: string): CustomSlashCommand[];
+//# sourceMappingURL=customCommands.d.ts.map

package/dist/utils/customCommands.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"customCommands.d.ts","sourceRoot":"","sources":["../../src/utils/customCommands.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,aAAa,CAAC;AAGtD;;GAEG;AACH,wBAAgB,qBAAqB,CAAC,OAAO,EAAE,MAAM,GAAG,MAAM,CAE7D;AAED;;GAEG;AACH,wBAAgB,kBAAkB,IAAI,MAAM,CAE3C;AA6CD;;GAEG;AACH,wBAAgB,uBAAuB,CAAC,OAAO,EAAE,MAAM,GAAG,kBAAkB,EAAE,CAkB7E"}

package/dist/utils/customCommands.js

@@ -0,0 +1,71 @@
+import { existsSync, readdirSync } from "fs";
+import { join, extname, basename } from "path";
+import { homedir } from "os";
+import { parseMarkdownFile } from "./markdownParser.js";
+/**
+ * Get the project-specific commands directory
+ */
+export function getProjectCommandsDir(workdir) {
+    return join(workdir, ".wave", "commands");
+}
+/**
+ * Get the user-specific commands directory
+ */
+export function getUserCommandsDir() {
+    return join(homedir(), ".wave", "commands");
+}
+/**
+ * Scan a directory for markdown command files
+ */
+function scanCommandsDirectory(dirPath) {
+    if (!existsSync(dirPath)) {
+        return [];
+    }
+    const commands = [];
+    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) {
+    const projectCommands = scanCommandsDirectory(getProjectCommandsDir(workdir));
+    const userCommands = scanCommandsDirectory(getUserCommandsDir());
+    // Project commands take precedence over user commands with the same name
+    const commandMap = new Map();
+    // 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/dist/utils/fileFilter.d.ts

@@ -0,0 +1,26 @@
+/**
+ * Common ignore directory and file patterns
+ * Can be reused by multiple tools (glob, ripgrep, etc.)
+ */
+export declare const COMMON_IGNORE_PATTERNS: {
+    dependencies: string[];
+    cache: string[];
+    editor: string[];
+    os: string[];
+};
+/**
+ * Get flat array of all common ignore patterns
+ */
+export declare const getAllIgnorePatterns: () => string[];
+/**
+ * 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 declare const parseGitignoreToGlob: (workdir: string) => string[];
+/**
+ * Get ignore patterns for glob search
+ * @param workdir Working directory for resolving .gitignore files
+ */
+export declare const getGlobIgnorePatterns: (workdir?: string) => string[];
+//# sourceMappingURL=fileFilter.d.ts.map

package/dist/utils/fileFilter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"fileFilter.d.ts","sourceRoot":"","sources":["../../src/utils/fileFilter.ts"],"names":[],"mappings":"AAGA;;;GAGG;AACH,eAAO,MAAM,sBAAsB;;;;;CAsBlC,CAAC;AAEF;;GAEG;AACH,eAAO,MAAM,oBAAoB,QAAO,MAAM,EAO7C,CAAC;AA4HF;;;;GAIG;AACH,eAAO,MAAM,oBAAoB,GAAI,SAAS,MAAM,KAAG,MAAM,EAgB5D,CAAC;AAEF;;;GAGG;AACH,eAAO,MAAM,qBAAqB,GAAI,UAAU,MAAM,KAAG,MAAM,EAS9D,CAAC"}

package/dist/utils/fileFilter.js

@@ -0,0 +1,177 @@
+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 = () => {
+    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, maxDepth = 5) => {
+    const gitignoreFiles = [];
+    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) => {
+    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, basePath) => {
+    const patterns = [];
+    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) => {
+    const patterns = [];
+    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) => {
+    const patterns = getAllIgnorePatterns();
+    // If working directory is provided, parse .gitignore files
+    if (workdir) {
+        patterns.push(...parseGitignoreToGlob(workdir));
+    }
+    return patterns;
+};

package/dist/utils/markdownParser.d.ts

@@ -0,0 +1,27 @@
+import type { CustomSlashCommandConfig } from "../types.js";
+interface ParsedMarkdownFile {
+    content: string;
+    config?: CustomSlashCommandConfig;
+}
+/**
+ * Parse markdown file and extract config and content
+ */
+export declare function parseMarkdownFile(filePath: string): ParsedMarkdownFile;
+/**
+ * Parse and execute bash commands in markdown content
+ */
+export interface BashCommandResult {
+    command: string;
+    output: string;
+    exitCode: number;
+}
+export declare function parseBashCommands(content: string): {
+    commands: string[];
+    processedContent: string;
+};
+/**
+ * Replace bash command placeholders with their outputs
+ */
+export declare function replaceBashCommandsWithOutput(content: string, results: BashCommandResult[]): string;
+export {};
+//# sourceMappingURL=markdownParser.d.ts.map

package/dist/utils/markdownParser.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"markdownParser.d.ts","sourceRoot":"","sources":["../../src/utils/markdownParser.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,wBAAwB,EAAE,MAAM,aAAa,CAAC;AAE5D,UAAU,kBAAkB;IAC1B,OAAO,EAAE,MAAM,CAAC;IAChB,MAAM,CAAC,EAAE,wBAAwB,CAAC;CACnC;AAwDD;;GAEG;AACH,wBAAgB,iBAAiB,CAAC,QAAQ,EAAE,MAAM,GAAG,kBAAkB,CAsCtE;AAED;;GAEG;AACH,MAAM,WAAW,iBAAiB;IAChC,OAAO,EAAE,MAAM,CAAC;IAChB,MAAM,EAAE,MAAM,CAAC;IACf,QAAQ,EAAE,MAAM,CAAC;CAClB;AAED,wBAAgB,iBAAiB,CAAC,OAAO,EAAE,MAAM,GAAG;IAClD,QAAQ,EAAE,MAAM,EAAE,CAAC;IACnB,gBAAgB,EAAE,MAAM,CAAC;CAC1B,CAgBA;AAED;;GAEG;AACH,wBAAgB,6BAA6B,CAC3C,OAAO,EAAE,MAAM,EACf,OAAO,EAAE,iBAAiB,EAAE,GAC3B,MAAM,CAcR"}