wave-agent-sdk 0.0.1

package/dist/managers/aiManager.js

@@ -0,0 +1,415 @@
+import { callAgent, compressMessages } from "../services/aiService.js";
+import { getMessagesToCompress } from "../utils/messageOperations.js";
+import { convertMessagesForAPI } from "../utils/convertMessagesForAPI.js";
+import * as memory from "../services/memory.js";
+import { DEFAULT_TOKEN_LIMIT } from "../utils/constants.js";
+export class AIManager {
+    constructor(options) {
+        this.isLoading = false;
+        this.abortController = null;
+        this.toolAbortController = null;
+        this.isCompressing = false;
+        this.messageManager = options.messageManager;
+        this.toolManager = options.toolManager;
+        this.backgroundBashManager = options.backgroundBashManager;
+        this.hookManager = options.hookManager;
+        this.logger = options.logger;
+        this.workdir = options.workdir;
+        this.systemPrompt = options.systemPrompt;
+        this.callbacks = options.callbacks ?? {};
+    }
+    /**
+     * Get filtered tool configuration
+     */
+    getFilteredToolsConfig(allowedTools) {
+        const allTools = this.toolManager.getToolsConfig();
+        // If no allowedTools specified, return all tools
+        if (!allowedTools || allowedTools.length === 0) {
+            return allTools;
+        }
+        // Filter allowed tools
+        return allTools.filter((tool) => allowedTools.includes(tool.function.name));
+    }
+    setIsLoading(isLoading) {
+        this.isLoading = isLoading;
+    }
+    abortAIMessage() {
+        // Interrupt AI service
+        if (this.abortController) {
+            try {
+                this.abortController.abort();
+            }
+            catch (error) {
+                this.logger?.error("Failed to abort AI service:", error);
+            }
+        }
+        // Interrupt tool execution
+        if (this.toolAbortController) {
+            try {
+                this.toolAbortController.abort();
+            }
+            catch (error) {
+                this.logger?.error("Failed to abort tool execution:", error);
+            }
+        }
+        this.setIsLoading(false);
+    }
+    // Helper method to generate compactParams
+    generateCompactParams(toolName, toolArgs) {
+        try {
+            const toolPlugin = this.toolManager
+                .list()
+                .find((plugin) => plugin.name === toolName);
+            if (toolPlugin?.formatCompactParams) {
+                const context = {
+                    workdir: this.workdir,
+                };
+                return toolPlugin.formatCompactParams(toolArgs, context);
+            }
+        }
+        catch (error) {
+            this.logger?.warn("Failed to generate compactParams", error);
+        }
+        return undefined;
+    }
+    // Private method to handle token statistics and message compression
+    async handleTokenUsageAndCompression(usage, abortController) {
+        if (!usage)
+            return;
+        // Update token statistics - display latest token usage
+        this.messageManager.setlatestTotalTokens(usage.total_tokens);
+        // Check if token limit exceeded
+        const tokenLimit = parseInt(process.env.TOKEN_LIMIT || `${DEFAULT_TOKEN_LIMIT}`, 10);
+        if (usage.total_tokens > tokenLimit) {
+            this.logger?.info(`Token usage exceeded ${tokenLimit}, compressing messages...`);
+            // Check if messages need compression
+            const { messagesToCompress, insertIndex } = getMessagesToCompress(this.messageManager.getMessages(), 7);
+            // If there are messages to compress, perform compression
+            if (messagesToCompress.length > 0) {
+                const recentChatMessages = convertMessagesForAPI(messagesToCompress);
+                this.setIsCompressing(true);
+                try {
+                    const compressedContent = await compressMessages({
+                        messages: recentChatMessages,
+                        abortSignal: abortController.signal,
+                    });
+                    // Execute message reconstruction and sessionId update after compression
+                    this.messageManager.compressMessagesAndUpdateSession(insertIndex, compressedContent);
+                    this.logger?.info(`Successfully compressed ${messagesToCompress.length} messages and updated session`);
+                }
+                catch (compressError) {
+                    this.logger?.error("Failed to compress messages:", compressError);
+                }
+                finally {
+                    this.setIsCompressing(false);
+                }
+            }
+        }
+    }
+    getIsCompressing() {
+        return this.isCompressing;
+    }
+    setIsCompressing(isCompressing) {
+        if (this.isCompressing !== isCompressing) {
+            this.isCompressing = isCompressing;
+            this.callbacks.onCompressionStateChange?.(isCompressing);
+        }
+    }
+    async sendAIMessage(options = {}) {
+        const { recursionDepth = 0, model, allowedTools } = options;
+        // Only check isLoading for the initial call (recursionDepth === 0)
+        if (recursionDepth === 0 && this.isLoading) {
+            return;
+        }
+        // Create new AbortController
+        const abortController = new AbortController();
+        this.abortController = abortController;
+        // Create separate AbortController for tool execution
+        const toolAbortController = new AbortController();
+        this.toolAbortController = toolAbortController;
+        // Only set loading state for the initial call
+        if (recursionDepth === 0) {
+            this.setIsLoading(true);
+        }
+        // Get recent message history
+        const recentMessages = convertMessagesForAPI(this.messageManager.getMessages());
+        try {
+            // Get combined memory content
+            const combinedMemory = await memory.getCombinedMemoryContent(this.workdir);
+            // Call AI service (non-streaming)
+            const result = await callAgent({
+                messages: recentMessages,
+                sessionId: this.messageManager.getSessionId(),
+                abortSignal: abortController.signal,
+                memory: combinedMemory, // Pass combined memory content
+                workdir: this.workdir, // Pass working directory
+                tools: this.getFilteredToolsConfig(allowedTools), // Pass filtered tool configuration
+                model: model, // Use passed model
+                systemPrompt: this.systemPrompt, // Pass custom system prompt
+            });
+            // Collect content and tool calls
+            const content = result.content || "";
+            const toolCalls = [];
+            if (result.tool_calls) {
+                for (const toolCall of result.tool_calls) {
+                    if (toolCall.type === "function") {
+                        toolCalls.push(toolCall);
+                    }
+                }
+            }
+            // Add assistant message at once (including content and tool calls)
+            this.messageManager.addAssistantMessage(content, toolCalls);
+            if (toolCalls.length > 0) {
+                for (const functionToolCall of toolCalls) {
+                    const toolId = functionToolCall.id || "";
+                    // Execute tool
+                    try {
+                        // Check if already interrupted, skip tool execution if so
+                        if (abortController.signal.aborted ||
+                            toolAbortController.signal.aborted) {
+                            return;
+                        }
+                        // Safely parse tool parameters, handle tools without parameters
+                        let toolArgs = {};
+                        const argsString = functionToolCall.function?.arguments?.trim();
+                        if (!argsString || argsString === "") {
+                            // Tool without parameters, use empty object
+                            toolArgs = {};
+                        }
+                        else {
+                            try {
+                                toolArgs = JSON.parse(argsString);
+                            }
+                            catch (parseError) {
+                                // For non-empty but malformed JSON, still throw exception
+                                const errorMessage = `Failed to parse tool arguments: ${argsString}`;
+                                this.logger?.error(errorMessage, parseError);
+                                throw new Error(errorMessage);
+                            }
+                        }
+                        // Set tool start execution state
+                        const toolName = functionToolCall.function?.name || "";
+                        const compactParams = this.generateCompactParams(toolName, toolArgs);
+                        this.messageManager.updateToolBlock({
+                            toolId,
+                            args: JSON.stringify(toolArgs, null, 2),
+                            isRunning: true, // isRunning: true
+                            name: toolName,
+                            compactParams,
+                        });
+                        try {
+                            // Execute PreToolUse hooks before tool execution
+                            await this.executePreToolUseHooks(toolName, toolArgs);
+                            // Create tool execution context
+                            const context = {
+                                abortSignal: toolAbortController.signal,
+                                backgroundBashManager: this.backgroundBashManager,
+                                workdir: this.workdir,
+                            };
+                            // Execute tool
+                            const toolResult = await this.toolManager.execute(functionToolCall.function?.name || "", toolArgs, context);
+                            // Update message state - tool execution completed
+                            this.messageManager.updateToolBlock({
+                                toolId,
+                                args: JSON.stringify(toolArgs, null, 2),
+                                result: toolResult.content ||
+                                    (toolResult.error ? `Error: ${toolResult.error}` : ""),
+                                success: toolResult.success,
+                                error: toolResult.error,
+                                isRunning: false, // isRunning: false
+                                name: toolName,
+                                shortResult: toolResult.shortResult,
+                                compactParams,
+                            });
+                            // If tool returns diff information, add diff block
+                            if (toolResult.success &&
+                                toolResult.diffResult &&
+                                toolResult.filePath) {
+                                this.messageManager.addDiffBlock(toolResult.filePath, toolResult.diffResult);
+                            }
+                            // Execute PostToolUse hooks after successful tool completion
+                            await this.executePostToolUseHooks(toolName, toolArgs, toolResult);
+                        }
+                        catch (toolError) {
+                            const errorMessage = toolError instanceof Error
+                                ? toolError.message
+                                : String(toolError);
+                            this.messageManager.updateToolBlock({
+                                toolId,
+                                args: JSON.stringify(toolArgs, null, 2),
+                                result: `Tool execution failed: ${errorMessage}`,
+                                success: false,
+                                error: errorMessage,
+                                isRunning: false,
+                                name: toolName,
+                                compactParams,
+                            });
+                        }
+                    }
+                    catch (parseError) {
+                        // Check if it's a parsing error due to interruption
+                        const isAborted = abortController.signal.aborted ||
+                            toolAbortController.signal.aborted;
+                        if (isAborted) {
+                            // If interrupted, return directly without showing error
+                            return;
+                        }
+                        const errorMessage = parseError instanceof Error
+                            ? parseError.message
+                            : String(parseError);
+                        this.messageManager.addErrorBlock(`Failed to parse tool arguments for ${functionToolCall.function?.name}: ${errorMessage}`);
+                    }
+                }
+            }
+            // Handle token statistics and message compression
+            await this.handleTokenUsageAndCompression(result.usage, abortController);
+            // Check if there are tool operations, if so automatically initiate next AI service call
+            if (toolCalls.length > 0) {
+                // Check interruption status
+                const isCurrentlyAborted = abortController.signal.aborted || toolAbortController.signal.aborted;
+                // AI service call ends, clear abort controller
+                this.abortController = null;
+                // Clear tool AbortController after tool execution completes
+                this.toolAbortController = null;
+                if (!isCurrentlyAborted) {
+                    // Recursively call AI service, increment recursion depth, and pass same configuration
+                    await this.sendAIMessage({
+                        recursionDepth: recursionDepth + 1,
+                        model,
+                        allowedTools,
+                    });
+                }
+            }
+            else {
+                // Clear abort controller when no tool operations
+                this.abortController = null;
+                this.toolAbortController = null;
+            }
+        }
+        catch (error) {
+            // Check if error is due to user interrupt operation
+            const isAborted = abortController.signal.aborted ||
+                toolAbortController.signal.aborted ||
+                (error instanceof Error &&
+                    (error.name === "AbortError" || error.message.includes("aborted")));
+            if (!isAborted) {
+                this.messageManager.addErrorBlock(error instanceof Error ? error.message : "Unknown error occurred");
+            }
+            // Reset abort controller on error
+            this.abortController = null;
+            this.toolAbortController = null;
+        }
+        finally {
+            // Only clear loading state for the initial call
+            if (recursionDepth === 0) {
+                this.setIsLoading(false);
+                // Save session before executing Stop hooks
+                await this.messageManager.saveSession();
+                // Execute Stop hooks when AI response cycle completes
+                await this.executeStopHooks();
+            }
+        }
+    }
+    /**
+     * Execute Stop hooks when AI response cycle completes
+     */
+    async executeStopHooks() {
+        if (!this.hookManager)
+            return;
+        try {
+            const context = {
+                event: "Stop",
+                projectDir: this.workdir,
+                timestamp: new Date(),
+                sessionId: this.messageManager.getSessionId(),
+                transcriptPath: this.messageManager.getTranscriptPath(),
+                cwd: this.workdir,
+                // Stop hooks don't need toolName, toolInput, toolResponse, or userPrompt
+            };
+            const results = await this.hookManager.executeHooks("Stop", context);
+            // Log hook execution results for debugging
+            if (results.length > 0) {
+                this.logger?.debug(`Executed ${results.length} Stop hook(s):`, results.map((r) => ({
+                    success: r.success,
+                    duration: r.duration,
+                    exitCode: r.exitCode,
+                    timedOut: r.timedOut,
+                    stderr: r.stderr,
+                })));
+            }
+        }
+        catch (error) {
+            // Hook execution errors should not interrupt the main workflow
+            this.logger?.error("Stop hook execution failed:", error);
+        }
+    }
+    /**
+     * Execute PreToolUse hooks before tool execution
+     */
+    async executePreToolUseHooks(toolName, toolInput) {
+        if (!this.hookManager)
+            return;
+        try {
+            const context = {
+                event: "PreToolUse",
+                projectDir: this.workdir,
+                timestamp: new Date(),
+                toolName,
+                sessionId: this.messageManager.getSessionId(),
+                transcriptPath: this.messageManager.getTranscriptPath(),
+                cwd: this.workdir,
+                toolInput,
+            };
+            const results = await this.hookManager.executeHooks("PreToolUse", context);
+            // Log hook execution results for debugging
+            if (results.length > 0) {
+                this.logger?.debug(`Executed ${results.length} PreToolUse hook(s) for ${toolName}:`, results.map((r) => ({
+                    success: r.success,
+                    duration: r.duration,
+                    exitCode: r.exitCode,
+                    timedOut: r.timedOut,
+                    stderr: r.stderr,
+                })));
+            }
+        }
+        catch (error) {
+            // Hook execution errors should not interrupt the main workflow
+            this.logger?.error("PreToolUse hook execution failed:", error);
+        }
+    }
+    /**
+     * Execute PostToolUse hooks after tool completion
+     */
+    async executePostToolUseHooks(toolName, toolInput, toolResponse) {
+        if (!this.hookManager)
+            return;
+        try {
+            const context = {
+                event: "PostToolUse",
+                projectDir: this.workdir,
+                timestamp: new Date(),
+                toolName,
+                sessionId: this.messageManager.getSessionId(),
+                transcriptPath: this.messageManager.getTranscriptPath(),
+                cwd: this.workdir,
+                toolInput,
+                toolResponse,
+            };
+            const results = await this.hookManager.executeHooks("PostToolUse", context);
+            // Log hook execution results for debugging
+            if (results.length > 0) {
+                this.logger?.debug(`Executed ${results.length} PostToolUse hook(s) for ${toolName}:`, results.map((r) => ({
+                    success: r.success,
+                    duration: r.duration,
+                    exitCode: r.exitCode,
+                    timedOut: r.timedOut,
+                    stderr: r.stderr,
+                })));
+            }
+        }
+        catch (error) {
+            // Hook execution errors should not interrupt the main workflow
+            this.logger?.error("PostToolUse hook execution failed:", error);
+        }
+    }
+}

package/dist/managers/backgroundBashManager.d.ts

@@ -0,0 +1,27 @@
+import type { BackgroundShell } from "../types.js";
+export interface BackgroundBashManagerCallbacks {
+    onShellsChange?: (shells: BackgroundShell[]) => void;
+}
+export interface BackgroundBashManagerOptions {
+    callbacks?: BackgroundBashManagerCallbacks;
+    workdir: string;
+}
+export declare class BackgroundBashManager {
+    private shells;
+    private nextId;
+    private callbacks;
+    private workdir;
+    constructor(options: BackgroundBashManagerOptions);
+    private notifyShellsChange;
+    startShell(command: string, timeout?: number): string;
+    getShell(id: string): BackgroundShell | undefined;
+    getAllShells(): BackgroundShell[];
+    getOutput(id: string, filter?: string): {
+        stdout: string;
+        stderr: string;
+        status: string;
+    } | null;
+    killShell(id: string): boolean;
+    cleanup(): void;
+}
+//# sourceMappingURL=backgroundBashManager.d.ts.map

package/dist/managers/backgroundBashManager.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"backgroundBashManager.d.ts","sourceRoot":"","sources":["../../src/managers/backgroundBashManager.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,aAAa,CAAC;AAEnD,MAAM,WAAW,8BAA8B;IAC7C,cAAc,CAAC,EAAE,CAAC,MAAM,EAAE,eAAe,EAAE,KAAK,IAAI,CAAC;CACtD;AAED,MAAM,WAAW,4BAA4B;IAC3C,SAAS,CAAC,EAAE,8BAA8B,CAAC;IAC3C,OAAO,EAAE,MAAM,CAAC;CACjB;AAED,qBAAa,qBAAqB;IAChC,OAAO,CAAC,MAAM,CAAsC;IACpD,OAAO,CAAC,MAAM,CAAK;IACnB,OAAO,CAAC,SAAS,CAAiC;IAClD,OAAO,CAAC,OAAO,CAAS;gBAEZ,OAAO,EAAE,4BAA4B;IAKjD,OAAO,CAAC,kBAAkB;IAInB,UAAU,CAAC,OAAO,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,MAAM,GAAG,MAAM;IAsErD,QAAQ,CAAC,EAAE,EAAE,MAAM,GAAG,eAAe,GAAG,SAAS;IAIjD,YAAY,IAAI,eAAe,EAAE;IAIjC,SAAS,CACd,EAAE,EAAE,MAAM,EACV,MAAM,CAAC,EAAE,MAAM,GACd;QAAE,MAAM,EAAE,MAAM,CAAC;QAAC,MAAM,EAAE,MAAM,CAAC;QAAC,MAAM,EAAE,MAAM,CAAA;KAAE,GAAG,IAAI;IAiCrD,SAAS,CAAC,EAAE,EAAE,MAAM,GAAG,OAAO;IAmD9B,OAAO,IAAI,IAAI;CAUvB"}

package/dist/managers/backgroundBashManager.js

@@ -0,0 +1,166 @@
+import { spawn } from "child_process";
+export class BackgroundBashManager {
+    constructor(options) {
+        this.shells = new Map();
+        this.nextId = 1;
+        this.callbacks = options.callbacks || {};
+        this.workdir = options.workdir;
+    }
+    notifyShellsChange() {
+        this.callbacks.onShellsChange?.(Array.from(this.shells.values()));
+    }
+    startShell(command, timeout) {
+        const id = `bash_${this.nextId++}`;
+        const startTime = Date.now();
+        const child = spawn(command, {
+            shell: true,
+            stdio: "pipe",
+            cwd: this.workdir,
+            env: {
+                ...process.env,
+            },
+        });
+        const shell = {
+            id,
+            process: child,
+            command,
+            startTime,
+            status: "running",
+            stdout: "",
+            stderr: "",
+        };
+        this.shells.set(id, shell);
+        this.notifyShellsChange();
+        // Set up timeout if specified
+        let timeoutHandle;
+        if (timeout && timeout > 0) {
+            timeoutHandle = setTimeout(() => {
+                if (shell.status === "running") {
+                    this.killShell(id);
+                }
+            }, timeout);
+        }
+        child.stdout?.on("data", (data) => {
+            shell.stdout += data.toString();
+            this.notifyShellsChange();
+        });
+        child.stderr?.on("data", (data) => {
+            shell.stderr += data.toString();
+            this.notifyShellsChange();
+        });
+        child.on("exit", (code) => {
+            if (timeoutHandle) {
+                clearTimeout(timeoutHandle);
+            }
+            shell.status = "completed";
+            shell.exitCode = code ?? 0;
+            shell.runtime = Date.now() - startTime;
+            this.notifyShellsChange();
+        });
+        child.on("error", (error) => {
+            if (timeoutHandle) {
+                clearTimeout(timeoutHandle);
+            }
+            shell.status = "completed";
+            shell.stderr += `\nProcess error: ${error.message}`;
+            shell.exitCode = 1;
+            shell.runtime = Date.now() - startTime;
+            this.notifyShellsChange();
+        });
+        return id;
+    }
+    getShell(id) {
+        return this.shells.get(id);
+    }
+    getAllShells() {
+        return Array.from(this.shells.values());
+    }
+    getOutput(id, filter) {
+        const shell = this.shells.get(id);
+        if (!shell) {
+            return null;
+        }
+        let stdout = shell.stdout;
+        let stderr = shell.stderr;
+        // Apply regex filter if provided
+        if (filter) {
+            try {
+                const regex = new RegExp(filter);
+                stdout = stdout
+                    .split("\n")
+                    .filter((line) => regex.test(line))
+                    .join("\n");
+                stderr = stderr
+                    .split("\n")
+                    .filter((line) => regex.test(line))
+                    .join("\n");
+            }
+            catch {
+                // logger.warn(`Invalid filter regex: ${filter}`, error);
+            }
+        }
+        return {
+            stdout,
+            stderr,
+            status: shell.status,
+        };
+    }
+    killShell(id) {
+        const shell = this.shells.get(id);
+        if (!shell || shell.status !== "running") {
+            return false;
+        }
+        try {
+            // Try to kill process group first
+            if (shell.process.pid) {
+                process.kill(-shell.process.pid, "SIGTERM");
+                // Force kill after timeout
+                setTimeout(() => {
+                    if (shell.status === "running" &&
+                        shell.process.pid &&
+                        !shell.process.killed) {
+                        try {
+                            process.kill(-shell.process.pid, "SIGKILL");
+                        }
+                        catch {
+                            // logger.error("Failed to force kill process:", error);
+                        }
+                    }
+                }, 1000);
+            }
+            shell.status = "killed";
+            shell.runtime = Date.now() - shell.startTime;
+            this.notifyShellsChange();
+            return true;
+        }
+        catch {
+            // Fallback to direct process kill
+            try {
+                shell.process.kill("SIGTERM");
+                setTimeout(() => {
+                    if (!shell.process.killed) {
+                        shell.process.kill("SIGKILL");
+                    }
+                }, 1000);
+                shell.status = "killed";
+                shell.runtime = Date.now() - shell.startTime;
+                this.notifyShellsChange();
+                return true;
+            }
+            catch {
+                // logger.error("Failed to kill child process:", directKillError);
+                return false;
+            }
+        }
+    }
+    cleanup() {
+        // Kill all running shells
+        for (const [id, shell] of this.shells) {
+            if (shell.status === "running") {
+                this.killShell(id);
+            }
+        }
+        this.shells.clear();
+        this.notifyShellsChange();
+    }
+}

package/dist/managers/bashManager.d.ts

@@ -0,0 +1,20 @@
+import type { MessageManager } from "./messageManager.js";
+export interface BashManagerOptions {
+    messageManager: MessageManager;
+    workdir: string;
+}
+export interface CommandExecutionResult {
+    exitCode: number;
+    output: string;
+}
+export declare class BashManager {
+    private workdir;
+    private messageManager;
+    isCommandRunning: boolean;
+    private currentProcess;
+    constructor(options: BashManagerOptions);
+    private setCommandRunning;
+    executeCommand(command: string): Promise<number>;
+    abortCommand(): void;
+}
+//# sourceMappingURL=bashManager.d.ts.map

package/dist/managers/bashManager.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"bashManager.d.ts","sourceRoot":"","sources":["../../src/managers/bashManager.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,qBAAqB,CAAC;AAE1D,MAAM,WAAW,kBAAkB;IACjC,cAAc,EAAE,cAAc,CAAC;IAC/B,OAAO,EAAE,MAAM,CAAC;CACjB;AAED,MAAM,WAAW,sBAAsB;IACrC,QAAQ,EAAE,MAAM,CAAC;IACjB,MAAM,EAAE,MAAM,CAAC;CAChB;AAED,qBAAa,WAAW;IACtB,OAAO,CAAC,OAAO,CAAS;IACxB,OAAO,CAAC,cAAc,CAAiB;IAChC,gBAAgB,UAAS;IAChC,OAAO,CAAC,cAAc,CAA6B;gBAEvC,OAAO,EAAE,kBAAkB;IAKvC,OAAO,CAAC,iBAAiB;IAIZ,cAAc,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC;IA4DtD,YAAY,IAAI,IAAI;CAO5B"}