wave-agent-sdk 0.0.1

package/dist/managers/slashCommandManager.d.ts

@@ -0,0 +1,77 @@
+import type { MessageManager } from "./messageManager.js";
+import type { AIManager } from "./aiManager.js";
+import type { SlashCommand, CustomSlashCommand, Logger } from "../types.js";
+export interface SlashCommandManagerOptions {
+    messageManager: MessageManager;
+    aiManager: AIManager;
+    workdir: string;
+    logger?: Logger;
+}
+export declare class SlashCommandManager {
+    private commands;
+    private customCommands;
+    private messageManager;
+    private aiManager;
+    private workdir;
+    private logger?;
+    constructor(options: SlashCommandManagerOptions);
+    private initializeBuiltinCommands;
+    /**
+     * Load custom commands from filesystem
+     */
+    private loadCustomCommands;
+    /**
+     * Reload custom commands (useful for development)
+     */
+    reloadCustomCommands(): void;
+    /**
+     * Register new command
+     */
+    private registerCommand;
+    /**
+     * Unregister command
+     */
+    private unregisterCommand;
+    /**
+     * Get all available commands
+     */
+    getCommands(): SlashCommand[];
+    /**
+     * Get command by ID
+     */
+    getCommand(commandId: string): SlashCommand | undefined;
+    /**
+     * Execute command
+     */
+    executeCommand(commandId: string, args?: string): Promise<boolean>;
+    /**
+     * Parse and validate a slash command input
+     * Returns whether the command is valid along with parsed commandId and args
+     */
+    parseAndValidateSlashCommand(input: string): {
+        isValid: boolean;
+        commandId?: string;
+        args?: string;
+    };
+    /**
+     * Check if command exists
+     */
+    hasCommand(commandId: string): boolean;
+    /**
+     * Get custom command details
+     */
+    getCustomCommand(commandId: string): CustomSlashCommand | undefined;
+    /**
+     * Get all custom commands
+     */
+    getCustomCommands(): CustomSlashCommand[];
+    /**
+     * Execute custom command in main agent instead of sub-agent
+     */
+    private executeCustomCommandInMainAgent;
+    /**
+     * Interrupt the currently executing slash command
+     */
+    abortCurrentCommand(): void;
+}
+//# sourceMappingURL=slashCommandManager.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"slashCommandManager.d.ts","sourceRoot":"","sources":["../../src/managers/slashCommandManager.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,qBAAqB,CAAC;AAC1D,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,gBAAgB,CAAC;AAChD,OAAO,KAAK,EAAE,YAAY,EAAE,kBAAkB,EAAE,MAAM,EAAE,MAAM,aAAa,CAAC;AAkB5E,MAAM,WAAW,0BAA0B;IACzC,cAAc,EAAE,cAAc,CAAC;IAC/B,SAAS,EAAE,SAAS,CAAC;IACrB,OAAO,EAAE,MAAM,CAAC;IAChB,MAAM,CAAC,EAAE,MAAM,CAAC;CACjB;AAED,qBAAa,mBAAmB;IAC9B,OAAO,CAAC,QAAQ,CAAmC;IACnD,OAAO,CAAC,cAAc,CAAyC;IAC/D,OAAO,CAAC,cAAc,CAAiB;IACvC,OAAO,CAAC,SAAS,CAAY;IAC7B,OAAO,CAAC,OAAO,CAAS;IACxB,OAAO,CAAC,MAAM,CAAC,CAAS;gBAEZ,OAAO,EAAE,0BAA0B;IAU/C,OAAO,CAAC,yBAAyB;IAYjC;;OAEG;IACH,OAAO,CAAC,kBAAkB;IAwC1B;;OAEG;IACI,oBAAoB,IAAI,IAAI;IAWnC;;OAEG;IACH,OAAO,CAAC,eAAe;IAIvB;;OAEG;IACH,OAAO,CAAC,iBAAiB;IAIzB;;OAEG;IACI,WAAW,IAAI,YAAY,EAAE;IAIpC;;OAEG;IACI,UAAU,CAAC,SAAS,EAAE,MAAM,GAAG,YAAY,GAAG,SAAS;IAI9D;;OAEG;IACU,cAAc,CACzB,SAAS,EAAE,MAAM,EACjB,IAAI,CAAC,EAAE,MAAM,GACZ,OAAO,CAAC,OAAO,CAAC;IAenB;;;OAGG;IACI,4BAA4B,CAAC,KAAK,EAAE,MAAM,GAAG;QAClD,OAAO,EAAE,OAAO,CAAC;QACjB,SAAS,CAAC,EAAE,MAAM,CAAC;QACnB,IAAI,CAAC,EAAE,MAAM,CAAC;KACf;IAeD;;OAEG;IACI,UAAU,CAAC,SAAS,EAAE,MAAM,GAAG,OAAO;IAI7C;;OAEG;IACI,gBAAgB,CAAC,SAAS,EAAE,MAAM,GAAG,kBAAkB,GAAG,SAAS;IAI1E;;OAEG;IACI,iBAAiB,IAAI,kBAAkB,EAAE;IAIhD;;OAEG;YACW,+BAA+B;IA2E7C;;OAEG;IACI,mBAAmB,IAAI,IAAI;CAInC"}

package/dist/managers/slashCommandManager.js

@@ -0,0 +1,208 @@
+import { loadCustomSlashCommands } from "../utils/customCommands.js";
+import { substituteCommandParameters, parseSlashCommandInput, hasParameterPlaceholders, } from "../utils/commandArgumentParser.js";
+import { parseBashCommands, replaceBashCommandsWithOutput, } from "../utils/markdownParser.js";
+import { exec } from "child_process";
+import { promisify } from "util";
+const execAsync = promisify(exec);
+export class SlashCommandManager {
+    constructor(options) {
+        this.commands = new Map();
+        this.customCommands = new Map();
+        this.messageManager = options.messageManager;
+        this.aiManager = options.aiManager;
+        this.workdir = options.workdir;
+        this.logger = options.logger;
+        this.initializeBuiltinCommands();
+        this.loadCustomCommands();
+    }
+    initializeBuiltinCommands() {
+        // Register built-in clear command
+        this.registerCommand({
+            id: "clear",
+            name: "clear",
+            description: "Clear the chat session",
+            handler: () => {
+                this.messageManager.clearMessages();
+            },
+        });
+    }
+    /**
+     * Load custom commands from filesystem
+     */
+    loadCustomCommands() {
+        try {
+            const customCommands = loadCustomSlashCommands(this.workdir);
+            for (const command of customCommands) {
+                this.customCommands.set(command.id, command);
+                // Generate description: prioritize custom description, otherwise use default description
+                const description = command.description ||
+                    `Custom command: ${command.name}${hasParameterPlaceholders(command.content) ? " (supports parameters)" : ""}`;
+                // Register as a regular command with a handler that executes the custom command
+                this.registerCommand({
+                    id: command.id,
+                    name: command.name,
+                    description,
+                    handler: async (args) => {
+                        // Substitute parameters in the command content
+                        const processedContent = hasParameterPlaceholders(command.content) && args
+                            ? substituteCommandParameters(command.content, args)
+                            : command.content;
+                        await this.executeCustomCommandInMainAgent(command.name, processedContent, command.config, args);
+                    },
+                });
+            }
+            this.logger?.info(`Loaded ${customCommands.length} custom commands`);
+        }
+        catch (error) {
+            this.logger?.warn("Failed to load custom commands:", error);
+        }
+    }
+    /**
+     * Reload custom commands (useful for development)
+     */
+    reloadCustomCommands() {
+        // Clear existing custom commands
+        for (const commandId of this.customCommands.keys()) {
+            this.unregisterCommand(commandId);
+        }
+        this.customCommands.clear();
+        // Reload
+        this.loadCustomCommands();
+    }
+    /**
+     * Register new command
+     */
+    registerCommand(command) {
+        this.commands.set(command.id, command);
+    }
+    /**
+     * Unregister command
+     */
+    unregisterCommand(commandId) {
+        return this.commands.delete(commandId);
+    }
+    /**
+     * Get all available commands
+     */
+    getCommands() {
+        return Array.from(this.commands.values());
+    }
+    /**
+     * Get command by ID
+     */
+    getCommand(commandId) {
+        return this.commands.get(commandId);
+    }
+    /**
+     * Execute command
+     */
+    async executeCommand(commandId, args) {
+        const command = this.commands.get(commandId);
+        if (!command) {
+            return false;
+        }
+        try {
+            await command.handler(args);
+            return true;
+        }
+        catch (error) {
+            console.error(`Failed to execute slash command ${commandId}:`, error);
+            return false;
+        }
+    }
+    /**
+     * Parse and validate a slash command input
+     * Returns whether the command is valid along with parsed commandId and args
+     */
+    parseAndValidateSlashCommand(input) {
+        try {
+            const { command: commandId, args } = parseSlashCommandInput(input);
+            const isValid = this.hasCommand(commandId);
+            return {
+                isValid,
+                commandId: isValid ? commandId : undefined,
+                args: isValid ? args || undefined : undefined, // Convert empty string to undefined
+            };
+        }
+        catch (error) {
+            console.error(`Failed to parse slash command input "${input}":`, error);
+            return { isValid: false };
+        }
+    }
+    /**
+     * Check if command exists
+     */
+    hasCommand(commandId) {
+        return this.commands.has(commandId);
+    }
+    /**
+     * Get custom command details
+     */
+    getCustomCommand(commandId) {
+        return this.customCommands.get(commandId);
+    }
+    /**
+     * Get all custom commands
+     */
+    getCustomCommands() {
+        return Array.from(this.customCommands.values());
+    }
+    /**
+     * Execute custom command in main agent instead of sub-agent
+     */
+    async executeCustomCommandInMainAgent(commandName, content, config, args) {
+        try {
+            // Parse bash commands from the content
+            const { commands, processedContent } = parseBashCommands(content);
+            // Execute bash commands if any
+            const bashResults = [];
+            for (const command of commands) {
+                try {
+                    const { stdout, stderr } = await execAsync(command, {
+                        cwd: this.workdir,
+                        timeout: 30000, // 30 second timeout
+                    });
+                    bashResults.push({
+                        command,
+                        output: stdout || stderr || "",
+                        exitCode: 0,
+                    });
+                }
+                catch (error) {
+                    const execError = error;
+                    bashResults.push({
+                        command,
+                        output: execError.stdout || execError.stderr || execError.message || "",
+                        exitCode: execError.code || 1,
+                    });
+                }
+            }
+            // Replace bash command placeholders with their outputs
+            const finalContent = bashResults.length > 0
+                ? replaceBashCommandsWithOutput(processedContent, bashResults)
+                : processedContent;
+            // Add custom command block to show the command being executed
+            const originalInput = args
+                ? `/${commandName} ${args}`
+                : `/${commandName}`;
+            this.messageManager.addCustomCommandMessage(commandName, finalContent, originalInput);
+            // Execute the AI conversation with custom configuration
+            await this.aiManager.sendAIMessage({
+                model: config?.model,
+                allowedTools: config?.allowedTools,
+            });
+        }
+        catch (error) {
+            this.logger?.error(`Failed to execute custom command '${commandName}':`, error);
+            // Add error to message manager
+            this.messageManager.addErrorBlock(`Failed to execute custom command '${commandName}': ${error instanceof Error ? error.message : String(error)}`);
+        }
+    }
+    /**
+     * Interrupt the currently executing slash command
+     */
+    abortCurrentCommand() {
+        // Abort the AI manager if it's running
+        this.aiManager.abortAIMessage();
+    }
+}

package/dist/managers/toolManager.d.ts

@@ -0,0 +1,23 @@
+import type { ToolContext, ToolPlugin, ToolResult } from "../tools/types.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
+ */
+declare class ToolManager {
+    private tools;
+    private mcpManager;
+    private logger?;
+    constructor(options: ToolManagerOptions);
+    private initializeBuiltInTools;
+    execute(name: string, args: Record<string, unknown>, context: ToolContext): Promise<ToolResult>;
+    list(): ToolPlugin[];
+    getToolsConfig(): ChatCompletionFunctionTool[];
+}
+export { ToolManager };
+//# sourceMappingURL=toolManager.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"toolManager.d.ts","sourceRoot":"","sources":["../../src/managers/toolManager.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,UAAU,EAAE,UAAU,EAAE,MAAM,mBAAmB,CAAC;AAY7E,OAAO,EAAE,UAAU,EAAE,MAAM,iBAAiB,CAAC;AAC7C,OAAO,EAAE,0BAA0B,EAAE,MAAM,qBAAqB,CAAC;AACjE,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,aAAa,CAAC;AAE1C,MAAM,WAAW,kBAAkB;IACjC,UAAU,EAAE,UAAU,CAAC;IACvB,MAAM,CAAC,EAAE,MAAM,CAAC;CACjB;AAED;;GAEG;AACH,cAAM,WAAW;IACf,OAAO,CAAC,KAAK,CAAiC;IAC9C,OAAO,CAAC,UAAU,CAAa;IAC/B,OAAO,CAAC,MAAM,CAAC,CAAS;gBAEZ,OAAO,EAAE,kBAAkB;IAQvC,OAAO,CAAC,sBAAsB;IAqBxB,OAAO,CACX,IAAI,EAAE,MAAM,EACZ,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAC7B,OAAO,EAAE,WAAW,GACnB,OAAO,CAAC,UAAU,CAAC;IA2BtB,IAAI,IAAI,UAAU,EAAE;IAMpB,cAAc,IAAI,0BAA0B,EAAE;CAO/C;AAGD,OAAO,EAAE,WAAW,EAAE,CAAC"}

package/dist/managers/toolManager.js

@@ -0,0 +1,79 @@
+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";
+/**
+ * Tool Manager
+ */
+class ToolManager {
+    constructor(options) {
+        this.tools = new Map();
+        this.mcpManager = options.mcpManager;
+        this.logger = options.logger;
+        // Initialize built-in tools
+        this.initializeBuiltInTools();
+    }
+    initializeBuiltInTools() {
+        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, args, context) {
+        // 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() {
+        const builtInTools = Array.from(this.tools.values());
+        const mcpTools = this.mcpManager.getMcpToolPlugins();
+        return [...builtInTools, ...mcpTools];
+    }
+    getToolsConfig() {
+        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/dist/services/aiService.d.ts

@@ -0,0 +1,28 @@
+import { ChatCompletionMessageToolCall } from "openai/resources";
+import { ChatCompletionMessageParam, ChatCompletionFunctionTool } from "openai/resources.js";
+export interface CallAgentOptions {
+    messages: ChatCompletionMessageParam[];
+    sessionId?: string;
+    abortSignal?: AbortSignal;
+    memory?: string;
+    workdir: string;
+    tools?: ChatCompletionFunctionTool[];
+    model?: string;
+    systemPrompt?: string;
+}
+export interface CallAgentResult {
+    content?: string;
+    tool_calls?: ChatCompletionMessageToolCall[];
+    usage?: {
+        prompt_tokens: number;
+        completion_tokens: number;
+        total_tokens: number;
+    };
+}
+export declare function callAgent(options: CallAgentOptions): Promise<CallAgentResult>;
+export interface CompressMessagesOptions {
+    messages: ChatCompletionMessageParam[];
+    abortSignal?: AbortSignal;
+}
+export declare function compressMessages(options: CompressMessagesOptions): Promise<string>;
+//# sourceMappingURL=aiService.d.ts.map

package/dist/services/aiService.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"aiService.d.ts","sourceRoot":"","sources":["../../src/services/aiService.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,6BAA6B,EAAE,MAAM,kBAAkB,CAAC;AACjE,OAAO,EAEL,0BAA0B,EAC1B,0BAA0B,EAC3B,MAAM,qBAAqB,CAAC;AAuC7B,MAAM,WAAW,gBAAgB;IAC/B,QAAQ,EAAE,0BAA0B,EAAE,CAAC;IACvC,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,WAAW,CAAC,EAAE,WAAW,CAAC;IAC1B,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,OAAO,EAAE,MAAM,CAAC;IAChB,KAAK,CAAC,EAAE,0BAA0B,EAAE,CAAC;IACrC,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,YAAY,CAAC,EAAE,MAAM,CAAC;CACvB;AAED,MAAM,WAAW,eAAe;IAC9B,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,UAAU,CAAC,EAAE,6BAA6B,EAAE,CAAC;IAC7C,KAAK,CAAC,EAAE;QACN,aAAa,EAAE,MAAM,CAAC;QACtB,iBAAiB,EAAE,MAAM,CAAC;QAC1B,YAAY,EAAE,MAAM,CAAC;KACtB,CAAC;CACH;AAED,wBAAsB,SAAS,CAC7B,OAAO,EAAE,gBAAgB,GACxB,OAAO,CAAC,eAAe,CAAC,CA2F1B;AAED,MAAM,WAAW,uBAAuB;IACtC,QAAQ,EAAE,0BAA0B,EAAE,CAAC;IACvC,WAAW,CAAC,EAAE,WAAW,CAAC;CAC3B;AAED,wBAAsB,gBAAgB,CACpC,OAAO,EAAE,uBAAuB,GAC/B,OAAO,CAAC,MAAM,CAAC,CAmFjB"}

package/dist/services/aiService.js

@@ -0,0 +1,180 @@
+import OpenAI from "openai";
+import { FAST_MODEL_ID, AGENT_MODEL_ID } from "../utils/constants.js";
+/**
+ * Get specific configuration parameters based on model name
+ * @param modelName Model name
+ * @param baseConfig Base configuration
+ * @returns Configured model parameters
+ */
+function getModelConfig(modelName, baseConfig = {}) {
+    const config = {
+        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 async function callAgent(options) {
+    const { messages, abortSignal, memory, workdir, tools, model, systemPrompt } = options;
+    try {
+        // Build system prompt content
+        let systemContent;
+        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 = {
+            role: "system",
+            content: systemContent,
+        };
+        // ChatCompletionMessageParam[] is already in OpenAI format, add system prompt to the beginning
+        const openaiMessages = [systemMessage, ...messages];
+        // Get model configuration
+        const modelConfig = getModelConfig(model || AGENT_MODEL_ID, {
+            temperature: 0,
+            max_completion_tokens: 32768,
+        });
+        // Prepare API call parameters
+        const createParams = {
+            ...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 = {};
+        // 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.name === "AbortError") {
+            throw new Error("Request was aborted");
+        }
+        // // logger.error("Failed to call OpenAI:", error);
+        throw error;
+    }
+}
+export async function compressMessages(options) {
+    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.name === "AbortError") {
+            throw new Error("Compression request was aborted");
+        }
+        // // logger.error("Failed to compress messages:", error);
+        return "Failed to compress conversation history";
+    }
+}

package/dist/services/memory.d.ts

@@ -0,0 +1,8 @@
+export declare const isMemoryMessage: (message: string) => boolean;
+export declare const addMemory: (message: string, workdir: string) => Promise<void>;
+export declare const ensureUserMemoryFile: () => Promise<void>;
+export declare const addUserMemory: (message: string) => Promise<void>;
+export declare const getUserMemoryContent: () => Promise<string>;
+export declare const readMemoryFile: (workdir: string) => Promise<string>;
+export declare const getCombinedMemoryContent: (workdir: string) => Promise<string>;
+//# sourceMappingURL=memory.d.ts.map

package/dist/services/memory.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"memory.d.ts","sourceRoot":"","sources":["../../src/services/memory.ts"],"names":[],"mappings":"AAKA,eAAO,MAAM,eAAe,GAAI,SAAS,MAAM,KAAG,OAEjD,CAAC;AAEF,eAAO,MAAM,SAAS,GACpB,SAAS,MAAM,EACf,SAAS,MAAM,KACd,OAAO,CAAC,IAAI,CAoCd,CAAC;AAGF,eAAO,MAAM,oBAAoB,QAAa,OAAO,CAAC,IAAI,CAyBzD,CAAC;AAEF,eAAO,MAAM,aAAa,GAAU,SAAS,MAAM,KAAG,OAAO,CAAC,IAAI,CAsBjE,CAAC;AAEF,eAAO,MAAM,oBAAoB,QAAa,OAAO,CAAC,MAAM,CAQ3D,CAAC;AAGF,eAAO,MAAM,cAAc,GAAU,SAAS,MAAM,KAAG,OAAO,CAAC,MAAM,CAUpE,CAAC;AAGF,eAAO,MAAM,wBAAwB,GACnC,SAAS,MAAM,KACd,OAAO,CAAC,MAAM,CAoBhB,CAAC"}