wave-agent-sdk 0.0.1

package/src/managers/toolManager.ts

@@ -0,0 +1,106 @@
+import type { ToolContext, ToolPlugin, ToolResult } from "../tools/types.js";
+import { bashTool, bashOutputTool, killBashTool } from "../tools/bashTool.js";
+import { deleteFileTool } from "../tools/deleteFileTool.js";
+import { editTool } from "../tools/editTool.js";
+import { multiEditTool } from "../tools/multiEditTool.js";
+import { writeTool } from "../tools/writeTool.js";
+// New tools
+import { globTool } from "../tools/globTool.js";
+import { grepTool } from "../tools/grepTool.js";
+import { lsTool } from "../tools/lsTool.js";
+import { readTool } from "../tools/readTool.js";
+import { SkillManager } from "./skillManager.js";
+import { McpManager } from "./mcpManager.js";
+import { ChatCompletionFunctionTool } from "openai/resources.js";
+import type { Logger } from "../types.js";
+
+export interface ToolManagerOptions {
+  mcpManager: McpManager;
+  logger?: Logger;
+}
+
+/**
+ * Tool Manager
+ */
+class ToolManager {
+  private tools = new Map<string, ToolPlugin>();
+  private mcpManager: McpManager;
+  private logger?: Logger;
+
+  constructor(options: ToolManagerOptions) {
+    this.mcpManager = options.mcpManager;
+    this.logger = options.logger;
+
+    // Initialize built-in tools
+    this.initializeBuiltInTools();
+  }
+
+  private initializeBuiltInTools(): void {
+    const builtInTools = [
+      bashTool,
+      bashOutputTool,
+      killBashTool,
+      deleteFileTool,
+      editTool,
+      multiEditTool,
+      writeTool,
+      globTool,
+      grepTool,
+      lsTool,
+      readTool,
+      new SkillManager({ logger: this.logger }).createTool(),
+    ];
+
+    for (const tool of builtInTools) {
+      this.tools.set(tool.name, tool);
+    }
+  }
+
+  async execute(
+    name: string,
+    args: Record<string, unknown>,
+    context: ToolContext,
+  ): Promise<ToolResult> {
+    // Check if it's an MCP tool first
+    if (this.mcpManager.isMcpTool(name)) {
+      return this.mcpManager.executeMcpToolByRegistry(name, args, context);
+    }
+
+    // Check built-in tools
+    const plugin = this.tools.get(name);
+    if (plugin) {
+      try {
+        return await plugin.execute(args, context);
+      } catch (error) {
+        return {
+          success: false,
+          content: "",
+          error: error instanceof Error ? error.message : String(error),
+        };
+      }
+    }
+
+    return {
+      success: false,
+      content: "",
+      error: `Tool '${name}' not found`,
+    };
+  }
+
+  list(): ToolPlugin[] {
+    const builtInTools = Array.from(this.tools.values());
+    const mcpTools = this.mcpManager.getMcpToolPlugins();
+    return [...builtInTools, ...mcpTools];
+  }
+
+  getToolsConfig(): ChatCompletionFunctionTool[] {
+    const builtInToolsConfig = Array.from(this.tools.values()).map(
+      (tool) => tool.config,
+    );
+    const mcpToolsConfig = this.mcpManager.getMcpToolsConfig();
+    return [...builtInToolsConfig, ...mcpToolsConfig];
+  }
+}
+
+// Export tool registry class and types
+export { ToolManager };

package/src/services/aiService.ts

@@ -0,0 +1,252 @@
+import OpenAI from "openai";
+import { ChatCompletionMessageToolCall } from "openai/resources";
+import {
+  ChatCompletionCreateParamsNonStreaming,
+  ChatCompletionMessageParam,
+  ChatCompletionFunctionTool,
+} from "openai/resources.js";
+import { FAST_MODEL_ID, AGENT_MODEL_ID } from "@/utils/constants.js";
+
+/**
+ * Model configuration type, based on OpenAI parameters but excluding messages
+ */
+type ModelConfig = Omit<ChatCompletionCreateParamsNonStreaming, "messages">;
+
+/**
+ * Get specific configuration parameters based on model name
+ * @param modelName Model name
+ * @param baseConfig Base configuration
+ * @returns Configured model parameters
+ */
+function getModelConfig(
+  modelName: string,
+  baseConfig: Partial<ModelConfig> = {},
+): ModelConfig {
+  const config: ModelConfig = {
+    model: modelName,
+    stream: false,
+    ...baseConfig,
+  };
+
+  // Configuration rules for specific models
+  if (modelName.includes("gpt-5-codex")) {
+    // gpt-5-codex model sets temperature to undefined
+    config.temperature = undefined;
+  }
+
+  return config;
+}
+
+// Initialize OpenAI client with environment variables
+const openai = new OpenAI({
+  apiKey: process.env.AIGW_TOKEN,
+  baseURL: process.env.AIGW_URL,
+});
+
+export interface CallAgentOptions {
+  messages: ChatCompletionMessageParam[];
+  sessionId?: string;
+  abortSignal?: AbortSignal;
+  memory?: string; // Memory content parameter, content read from WAVE.md
+  workdir: string; // Current working directory
+  tools?: ChatCompletionFunctionTool[]; // Tool configuration
+  model?: string; // Custom model
+  systemPrompt?: string; // Custom system prompt
+}
+
+export interface CallAgentResult {
+  content?: string;
+  tool_calls?: ChatCompletionMessageToolCall[];
+  usage?: {
+    prompt_tokens: number;
+    completion_tokens: number;
+    total_tokens: number;
+  };
+}
+
+export async function callAgent(
+  options: CallAgentOptions,
+): Promise<CallAgentResult> {
+  const { messages, abortSignal, memory, workdir, tools, model, systemPrompt } =
+    options;
+
+  try {
+    // Build system prompt content
+    let systemContent: string;
+
+    if (systemPrompt) {
+      // Use custom system prompt if provided
+      systemContent = systemPrompt;
+    } else {
+      // Use default system prompt
+      systemContent = `You are an interactive CLI tool that helps users with software engineering tasks. Use the instructions below and the tools available to you to assist the user.
+
+## Current Working Directory
+${workdir}
+`;
+
+      // If there is memory content, add it to the system prompt
+      if (memory && memory.trim()) {
+        systemContent += `\n\n## Memory Context\n\nThe following is important context and memory from previous interactions:\n\n${memory}`;
+      }
+    }
+
+    // Add system prompt
+    const systemMessage: OpenAI.Chat.Completions.ChatCompletionMessageParam = {
+      role: "system",
+      content: systemContent,
+    };
+
+    // ChatCompletionMessageParam[] is already in OpenAI format, add system prompt to the beginning
+    const openaiMessages: OpenAI.Chat.Completions.ChatCompletionMessageParam[] =
+      [systemMessage, ...messages];
+
+    // Get model configuration
+    const modelConfig = getModelConfig(model || AGENT_MODEL_ID, {
+      temperature: 0,
+      max_completion_tokens: 32768,
+    });
+
+    // Prepare API call parameters
+    const createParams: ChatCompletionCreateParamsNonStreaming = {
+      ...modelConfig,
+      messages: openaiMessages,
+    };
+
+    // Only add tools if they exist
+    if (tools && tools.length > 0) {
+      createParams.tools = tools;
+    }
+
+    // Call OpenAI API (non-streaming)
+    const response = await openai.chat.completions.create(createParams, {
+      signal: abortSignal,
+    });
+
+    const finalMessage = response.choices[0]?.message;
+    const totalUsage = response.usage
+      ? {
+          prompt_tokens: response.usage.prompt_tokens,
+          completion_tokens: response.usage.completion_tokens,
+          total_tokens: response.usage.total_tokens,
+        }
+      : undefined;
+
+    const result: CallAgentResult = {};
+
+    // Return content
+    if (finalMessage?.content) {
+      result.content = finalMessage.content;
+    }
+
+    // Return tool call
+    if (finalMessage?.tool_calls && finalMessage.tool_calls.length > 0) {
+      result.tool_calls = finalMessage.tool_calls;
+    }
+
+    // Return token usage information
+    if (totalUsage) {
+      result.usage = totalUsage;
+    }
+
+    return result;
+  } catch (error) {
+    if ((error as Error).name === "AbortError") {
+      throw new Error("Request was aborted");
+    }
+    // // logger.error("Failed to call OpenAI:", error);
+    throw error;
+  }
+}
+
+export interface CompressMessagesOptions {
+  messages: ChatCompletionMessageParam[];
+  abortSignal?: AbortSignal;
+}
+
+export async function compressMessages(
+  options: CompressMessagesOptions,
+): Promise<string> {
+  const { messages, abortSignal } = options;
+
+  // Get model configuration
+  const modelConfig = getModelConfig(FAST_MODEL_ID, {
+    temperature: 0.1,
+    max_tokens: 1500,
+  });
+
+  try {
+    const response = await openai.chat.completions.create(
+      {
+        ...modelConfig,
+        messages: [
+          {
+            role: "system",
+            content: `You are an expert conversation history compression specialist. Your task is to create comprehensive yet concise summaries that preserve critical development context.
+
+## Primary Request and Intent
+Compress conversation history while maintaining all essential technical and procedural information.
+
+## Key Technical Concepts
+- Code modifications and file operations
+- Tool executions and their results  
+- Error handling and debugging processes
+- User requirements and assistant solutions
+- Technical discussions and decisions
+
+## Compression Strategy
+1. **Preserve Critical Information**:
+   - All file paths, function names, and code examples
+   - Tool execution results and outcomes
+   - Error messages and resolution steps
+   - User requirements and implementation approaches
+   - Technical decisions and their reasoning
+
+2. **Structure Organization**:
+   - Group related actions and discussions
+   - Maintain chronological flow for complex operations
+   - Separate different technical topics clearly
+   
+3. **Context Preservation**:
+   - Keep enough detail for future reference
+   - Maintain relationships between requests and solutions
+   - Preserve debugging context and error resolution paths
+
+## Output Requirements:
+- Use third-person narrative format
+- Target 300-800 words (scale based on complexity)
+- Maintain the original conversation language
+- Structure with clear sections for multi-topic conversations
+- Focus on actionable information and outcomes
+
+## Format Template:
+For technical conversations, structure as:
+- **User Requests**: Key requirements and goals
+- **Technical Implementation**: Code changes, file operations, tool usage
+- **Problem Resolution**: Errors encountered and solutions applied
+- **Outcomes**: Final results and current state`,
+          },
+          ...messages,
+          {
+            role: "user",
+            content: `Please compress this conversation following the structured approach. Focus on preserving all technical details, file operations, and problem-solving context while creating a concise summary.`,
+          },
+        ],
+      },
+      {
+        signal: abortSignal,
+      },
+    );
+
+    return (
+      response.choices[0]?.message?.content?.trim() ||
+      "Failed to compress conversation history"
+    );
+  } catch (error) {
+    if ((error as Error).name === "AbortError") {
+      throw new Error("Compression request was aborted");
+    }
+    // // logger.error("Failed to compress messages:", error);
+    return "Failed to compress conversation history";
+  }
+}

package/src/services/memory.ts

@@ -0,0 +1,149 @@
+import { promises as fs } from "fs";
+import path from "path";
+import { USER_MEMORY_FILE, DATA_DIRECTORY } from "../utils/constants.js";
+
+// Project memory related methods
+export const isMemoryMessage = (message: string): boolean => {
+  return message.trim().startsWith("#");
+};
+
+export const addMemory = async (
+  message: string,
+  workdir: string,
+): Promise<void> => {
+  if (!isMemoryMessage(message)) {
+    return;
+  }
+
+  try {
+    const memoryFilePath = path.join(workdir, "WAVE.md");
+
+    // Format memory entry, starting with -, no timestamp
+    const memoryEntry = `- ${message.substring(1).trim()}\n`;
+
+    // Check if file exists
+    let existingContent = "";
+    try {
+      existingContent = await fs.readFile(memoryFilePath, "utf-8");
+    } catch (error) {
+      // File does not exist, create new file
+      if ((error as NodeJS.ErrnoException).code === "ENOENT") {
+        existingContent =
+          "# Memory\n\nThis is the AI assistant's memory file, recording important information and context.\n\n";
+      } else {
+        throw error;
+      }
+    }
+
+    // Append new memory entry to the end of the file
+    const updatedContent = existingContent + memoryEntry;
+
+    // Write file
+    await fs.writeFile(memoryFilePath, updatedContent, "utf-8");
+
+    // logger.info(`Memory added to ${memoryFilePath}:`, message);
+  } catch (error) {
+    // logger.error("Failed to add memory:", error);
+    throw new Error(`Failed to add memory: ${(error as Error).message}`);
+  }
+};
+
+// User memory related methods
+export const ensureUserMemoryFile = async (): Promise<void> => {
+  try {
+    // Ensure data directory exists
+    await fs.mkdir(DATA_DIRECTORY, { recursive: true });
+
+    // Check if user memory file exists
+    try {
+      await fs.access(USER_MEMORY_FILE);
+    } catch (error) {
+      // File does not exist, create new file
+      if ((error as NodeJS.ErrnoException).code === "ENOENT") {
+        const initialContent =
+          "# User Memory\n\nThis is the user-level memory file, recording important information and context across projects.\n\n";
+        await fs.writeFile(USER_MEMORY_FILE, initialContent, "utf-8");
+        // logger.info(`Created user memory file: ${USER_MEMORY_FILE}`);
+      } else {
+        throw error;
+      }
+    }
+  } catch (error) {
+    // logger.error("Failed to ensure user memory file:", error);
+    throw new Error(
+      `Failed to ensure user memory file: ${(error as Error).message}`,
+    );
+  }
+};
+
+export const addUserMemory = async (message: string): Promise<void> => {
+  try {
+    // Ensure user memory file exists
+    await ensureUserMemoryFile();
+
+    // Format memory entry, starting with -
+    const memoryEntry = `- ${message.substring(1).trim()}\n`;
+
+    // Read existing content
+    const existingContent = await fs.readFile(USER_MEMORY_FILE, "utf-8");
+
+    // Append new memory entry to the end of the file
+    const updatedContent = existingContent + memoryEntry;
+
+    // Write file
+    await fs.writeFile(USER_MEMORY_FILE, updatedContent, "utf-8");
+
+    // logger.info(`User memory added to ${USER_MEMORY_FILE}:`, message);
+  } catch (error) {
+    // logger.error("Failed to add user memory:", error);
+    throw new Error(`Failed to add user memory: ${(error as Error).message}`);
+  }
+};
+
+export const getUserMemoryContent = async (): Promise<string> => {
+  try {
+    await ensureUserMemoryFile();
+    return await fs.readFile(USER_MEMORY_FILE, "utf-8");
+  } catch {
+    // logger.error("Failed to read user memory:", error);
+    return "";
+  }
+};
+
+// Read project memory file content
+export const readMemoryFile = async (workdir: string): Promise<string> => {
+  try {
+    const memoryFilePath = path.join(workdir, "WAVE.md");
+    return await fs.readFile(memoryFilePath, "utf-8");
+  } catch (error) {
+    if ((error as NodeJS.ErrnoException).code === "ENOENT") {
+      return "";
+    }
+    throw error;
+  }
+};
+
+// Get merged memory content (project memory + user memory)
+export const getCombinedMemoryContent = async (
+  workdir: string,
+): Promise<string> => {
+  // Read memory file content
+  const memoryContent = await readMemoryFile(workdir);
+
+  // Read user-level memory content
+  const userMemoryContent = await getUserMemoryContent();
+
+  // Merge project memory and user memory
+  let combinedMemory = "";
+  if (memoryContent.trim()) {
+    combinedMemory += memoryContent;
+  }
+  if (userMemoryContent.trim()) {
+    if (combinedMemory) {
+      combinedMemory += "\n\n";
+    }
+    combinedMemory += userMemoryContent;
+  }
+
+  return combinedMemory;
+};