wave-agent-sdk 0.0.2 → 0.0.4

package/dist/managers/subagentManager.js

@@ -0,0 +1,261 @@
+import { randomUUID } from "crypto";
+import { AIManager } from "./aiManager.js";
+import { MessageManager, } from "./messageManager.js";
+export class SubagentManager {
+    constructor(options) {
+        this.instances = new Map();
+        this.cachedConfigurations = null;
+        this.workdir = options.workdir;
+        this.parentToolManager = options.parentToolManager;
+        this.parentMessageManager = options.parentMessageManager;
+        this.logger = options.logger;
+        this.gatewayConfig = options.gatewayConfig;
+        this.modelConfig = options.modelConfig;
+        this.tokenLimit = options.tokenLimit;
+    }
+    /**
+     * Initialize the SubagentManager by loading and caching configurations
+     */
+    async initialize() {
+        await this.loadConfigurations();
+    }
+    /**
+     * Load all available subagent configurations and cache them
+     */
+    async loadConfigurations() {
+        if (this.cachedConfigurations === null) {
+            const { loadSubagentConfigurations } = await import("../utils/subagentParser.js");
+            this.cachedConfigurations = await loadSubagentConfigurations(this.workdir);
+        }
+        return this.cachedConfigurations;
+    }
+    /**
+     * Get cached configurations synchronously (must call loadConfigurations first)
+     */
+    getConfigurations() {
+        if (this.cachedConfigurations === null) {
+            throw new Error("SubagentManager not initialized. Call loadConfigurations() first.");
+        }
+        return this.cachedConfigurations;
+    }
+    /**
+     * Find subagent by exact name match
+     */
+    async findSubagent(name) {
+        const { findSubagentByName } = await import("../utils/subagentParser.js");
+        return findSubagentByName(name, this.workdir);
+    }
+    /**
+     * Create a new subagent instance with isolated managers
+     */
+    async createInstance(configuration, taskDescription) {
+        if (!this.parentToolManager ||
+            !this.gatewayConfig ||
+            !this.modelConfig ||
+            !this.tokenLimit) {
+            throw new Error("SubagentManager not properly initialized - call initialize() first");
+        }
+        const subagentId = randomUUID();
+        // Create isolated MessageManager for the subagent
+        const subagentCallbacks = {
+            // These callbacks will be handled by the parent agent
+            onMessagesChange: (messages) => {
+                const instance = this.instances.get(subagentId);
+                if (instance) {
+                    instance.messages = messages;
+                    // Update parent's subagent block with latest messages
+                    this.parentMessageManager.updateSubagentBlock(subagentId, {
+                        messages: messages,
+                    });
+                }
+            },
+        };
+        const messageManager = new MessageManager({
+            callbacks: subagentCallbacks,
+            workdir: this.workdir,
+            logger: this.logger,
+        });
+        // Use the parent tool manager directly - tool restrictions will be handled by allowedTools parameter
+        const toolManager = this.parentToolManager;
+        // Determine model to use
+        const modelToUse = configuration.model && configuration.model !== "inherit"
+            ? configuration.model
+            : this.modelConfig.agentModel;
+        // Create isolated AIManager for the subagent
+        const aiManager = new AIManager({
+            messageManager,
+            toolManager,
+            logger: this.logger,
+            workdir: this.workdir,
+            systemPrompt: configuration.systemPrompt,
+            gatewayConfig: this.gatewayConfig,
+            modelConfig: {
+                ...this.modelConfig,
+                agentModel: modelToUse,
+            },
+            tokenLimit: this.tokenLimit,
+        });
+        const instance = {
+            subagentId,
+            configuration,
+            aiManager,
+            messageManager,
+            toolManager,
+            status: "initializing",
+            taskDescription,
+            messages: [],
+        };
+        this.instances.set(subagentId, instance);
+        // Create subagent block in parent message manager
+        this.parentMessageManager.addSubagentBlock(subagentId, configuration.name, "active", []);
+        return instance;
+    }
+    /**
+     * Execute task using subagent instance
+     *
+     * IMPORTANT: This method automatically filters out the Task tool from allowedTools
+     * to prevent subagents from spawning other subagents (infinite recursion protection)
+     */
+    async executeTask(instance, prompt) {
+        try {
+            // Set status to active and update parent
+            this.updateInstanceStatus(instance.subagentId, "active");
+            this.parentMessageManager.updateSubagentBlock(instance.subagentId, {
+                status: "active",
+            });
+            // Add the user's prompt as a message
+            instance.messageManager.addUserMessage(prompt);
+            // Create allowed tools list - always exclude Task tool to prevent subagent recursion
+            let allowedTools = instance.configuration.tools;
+            // Always filter out the Task tool to prevent subagents from creating sub-subagents
+            if (allowedTools) {
+                allowedTools = allowedTools.filter((tool) => tool !== "Task");
+            }
+            else {
+                // If no tools specified, get all tools except Task
+                const allTools = instance.toolManager.list().map((tool) => tool.name);
+                allowedTools = allTools.filter((tool) => tool !== "Task");
+            }
+            // Execute the AI request with tool restrictions
+            await instance.aiManager.sendAIMessage({
+                allowedTools,
+                model: instance.configuration.model !== "inherit"
+                    ? instance.configuration.model
+                    : undefined,
+            });
+            // Get the latest messages to extract the response
+            const messages = instance.messageManager.getMessages();
+            const lastAssistantMessage = messages
+                .filter((msg) => msg.role === "assistant")
+                .pop();
+            if (!lastAssistantMessage) {
+                throw new Error("No response from subagent");
+            }
+            // Extract text content from the last assistant message
+            const textBlocks = lastAssistantMessage.blocks.filter((block) => block.type === "text");
+            const response = textBlocks.map((block) => block.content).join("\n");
+            // Update status to completed and update parent with final messages
+            this.updateInstanceStatus(instance.subagentId, "completed");
+            this.parentMessageManager.updateSubagentBlock(instance.subagentId, {
+                status: "completed",
+                messages: messages,
+            });
+            return response || "Task completed with no text response";
+        }
+        catch (error) {
+            this.updateInstanceStatus(instance.subagentId, "error");
+            this.parentMessageManager.updateSubagentBlock(instance.subagentId, {
+                status: "error",
+            });
+            throw error;
+        }
+    }
+    /**
+     * Get instance by subagent ID
+     */
+    getInstance(subagentId) {
+        return this.instances.get(subagentId) || null;
+    }
+    /**
+     * Update instance status
+     */
+    updateInstanceStatus(subagentId, status) {
+        const instance = this.instances.get(subagentId);
+        if (instance) {
+            instance.status = status;
+        }
+    }
+    /**
+     * Add message to instance
+     */
+    addMessageToInstance(subagentId, message) {
+        const instance = this.instances.get(subagentId);
+        if (instance) {
+            instance.messages.push(message);
+        }
+    }
+    /**
+     * Abort a running subagent instance
+     */
+    abortInstance(subagentId) {
+        const instance = this.instances.get(subagentId);
+        if (!instance) {
+            return false;
+        }
+        // Only abort active or initializing instances
+        if (instance.status !== "active" && instance.status !== "initializing") {
+            return false;
+        }
+        try {
+            // Abort the AI manager operations
+            instance.aiManager.abortAIMessage();
+            // Update status
+            this.updateInstanceStatus(subagentId, "aborted");
+            this.parentMessageManager.updateSubagentBlock(subagentId, {
+                status: "aborted",
+                messages: instance.messages,
+            });
+            this.logger?.info(`Aborted subagent instance: ${subagentId}`);
+            return true;
+        }
+        catch (error) {
+            this.logger?.error(`Failed to abort subagent instance ${subagentId}:`, error);
+            return false;
+        }
+    }
+    /**
+     * Abort all active subagent instances
+     */
+    abortAllInstances() {
+        const activeInstances = this.getActiveInstances();
+        for (const instance of activeInstances) {
+            this.abortInstance(instance.subagentId);
+        }
+    }
+    /**
+     * Clean up completed, errored, or aborted instances
+     */
+    cleanupInstance(subagentId) {
+        const instance = this.instances.get(subagentId);
+        if (instance &&
+            (instance.status === "completed" ||
+                instance.status === "error" ||
+                instance.status === "aborted")) {
+            this.instances.delete(subagentId);
+        }
+    }
+    /**
+     * Get all active instances
+     */
+    getActiveInstances() {
+        return Array.from(this.instances.values()).filter((instance) => instance.status === "active" || instance.status === "initializing");
+    }
+    /**
+     * Clean up all instances (for session end)
+     */
+    cleanup() {
+        // Abort all active instances before cleanup
+        this.abortAllInstances();
+        this.instances.clear();
+    }
+}

package/dist/managers/toolManager.d.ts

@@ -2,6 +2,8 @@ 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";
+import type { SubagentManager } from "./subagentManager.js";
+import type { SkillManager } from "./skillManager.js";
 export interface ToolManagerOptions {
     mcpManager: McpManager;
     logger?: Logger;
@@ -14,7 +16,37 @@ declare class ToolManager {
     private mcpManager;
     private logger?;
     constructor(options: ToolManagerOptions);
-    private initializeBuiltInTools;
+    /**
+     * Register a new tool
+     */
+    register(tool: ToolPlugin): void;
+    /**
+     * Initialize built-in tools. Can be called with dependencies for tools that require them.
+     *
+     * This method can be called multiple times safely. When called without dependencies,
+     * it registers basic tools (Bash, Read, Write, TodoWrite, etc.). When called with
+     * dependencies, it also registers tools that require managers (Task, Skill).
+     *
+     * @param deps Optional dependencies for advanced tools
+     * @param deps.subagentManager SubagentManager instance for Task tool
+     * @param deps.skillManager SkillManager instance for Skill tool
+     *
+     * @example
+     * ```typescript
+     * // Initialize basic tools only
+     * toolManager.initializeBuiltInTools();
+     *
+     * // Initialize all tools including those requiring dependencies
+     * toolManager.initializeBuiltInTools({
+     *   subagentManager: mySubagentManager,
+     *   skillManager: mySkillManager
+     * });
+     * ```
+     */
+    initializeBuiltInTools(deps?: {
+        subagentManager?: SubagentManager;
+        skillManager?: SkillManager;
+    }): void;
     execute(name: string, args: Record<string, unknown>, context: ToolContext): Promise<ToolResult>;
     list(): ToolPlugin[];
     getToolsConfig(): ChatCompletionFunctionTool[];

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

@@ -1 +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"}
+{"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;AAc7E,OAAO,EAAE,UAAU,EAAE,MAAM,iBAAiB,CAAC;AAC7C,OAAO,EAAE,0BAA0B,EAAE,MAAM,qBAAqB,CAAC;AACjE,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,aAAa,CAAC;AAC1C,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,sBAAsB,CAAC;AAC5D,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,mBAAmB,CAAC;AAEtD,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;IAKvC;;OAEG;IACI,QAAQ,CAAC,IAAI,EAAE,UAAU,GAAG,IAAI;IAIvC;;;;;;;;;;;;;;;;;;;;;;OAsBG;IACI,sBAAsB,CAAC,IAAI,CAAC,EAAE;QACnC,eAAe,CAAC,EAAE,eAAe,CAAC;QAClC,YAAY,CAAC,EAAE,YAAY,CAAC;KAC7B,GAAG,IAAI;IAgCF,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

@@ -8,7 +8,9 @@ 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 { todoWriteTool } from "../tools/todoWriteTool.js";
+import { createTaskTool } from "../tools/taskTool.js";
+import { createSkillTool } from "../tools/skillTool.js";
 /**
  * Tool Manager
  */
@@ -17,10 +19,37 @@ class ToolManager {
         this.tools = new Map();
         this.mcpManager = options.mcpManager;
         this.logger = options.logger;
-        // Initialize built-in tools
-        this.initializeBuiltInTools();
     }
-    initializeBuiltInTools() {
+    /**
+     * Register a new tool
+     */
+    register(tool) {
+        this.tools.set(tool.name, tool);
+    }
+    /**
+     * Initialize built-in tools. Can be called with dependencies for tools that require them.
+     *
+     * This method can be called multiple times safely. When called without dependencies,
+     * it registers basic tools (Bash, Read, Write, TodoWrite, etc.). When called with
+     * dependencies, it also registers tools that require managers (Task, Skill).
+     *
+     * @param deps Optional dependencies for advanced tools
+     * @param deps.subagentManager SubagentManager instance for Task tool
+     * @param deps.skillManager SkillManager instance for Skill tool
+     *
+     * @example
+     * ```typescript
+     * // Initialize basic tools only
+     * toolManager.initializeBuiltInTools();
+     *
+     * // Initialize all tools including those requiring dependencies
+     * toolManager.initializeBuiltInTools({
+     *   subagentManager: mySubagentManager,
+     *   skillManager: mySkillManager
+     * });
+     * ```
+     */
+    initializeBuiltInTools(deps) {
         const builtInTools = [
             bashTool,
             bashOutputTool,
@@ -33,11 +62,20 @@ class ToolManager {
             grepTool,
             lsTool,
             readTool,
-            new SkillManager({ logger: this.logger }).createTool(),
+            todoWriteTool,
         ];
         for (const tool of builtInTools) {
             this.tools.set(tool.name, tool);
         }
+        // Register tools that require dependencies
+        if (deps?.subagentManager) {
+            const taskTool = createTaskTool(deps.subagentManager);
+            this.tools.set(taskTool.name, taskTool);
+        }
+        if (deps?.skillManager) {
+            const skillTool = createSkillTool(deps.skillManager);
+            this.tools.set(skillTool.name, skillTool);
+        }
     }
     async execute(name, args, context) {
         // Check if it's an MCP tool first

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

@@ -1 +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;AAC7B,OAAO,KAAK,EAAE,aAAa,EAAE,WAAW,EAAE,MAAM,aAAa,CAAC;AAmC9D,MAAM,WAAW,gBAAgB;IAE/B,aAAa,EAAE,aAAa,CAAC;IAC7B,WAAW,EAAE,WAAW,CAAC;IAGzB,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,CA0G1B;AAED,MAAM,WAAW,uBAAuB;IAEtC,aAAa,EAAE,aAAa,CAAC;IAC7B,WAAW,EAAE,WAAW,CAAC;IAGzB,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,CAyFjB"}
+{"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;AAC7B,OAAO,KAAK,EAAE,aAAa,EAAE,WAAW,EAAE,MAAM,aAAa,CAAC;AA4D9D,MAAM,WAAW,gBAAgB;IAE/B,aAAa,EAAE,aAAa,CAAC;IAC7B,WAAW,EAAE,WAAW,CAAC;IAGzB,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,CA6G1B;AAED,MAAM,WAAW,uBAAuB;IAEtC,aAAa,EAAE,aAAa,CAAC;IAC7B,WAAW,EAAE,WAAW,CAAC;IAGzB,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,CAyFjB"}

package/dist/services/aiService.js

@@ -1,4 +1,29 @@
 import OpenAI from "openai";
+import * as os from "os";
+import * as fs from "fs";
+import * as path from "path";
+/**
+ * Check if a directory is a git repository
+ * @param dirPath Directory path to check
+ * @returns "Yes" if it's a git repo, "No" otherwise
+ */
+function isGitRepository(dirPath) {
+    try {
+        // Check if .git directory exists in current directory or any parent directory
+        let currentPath = path.resolve(dirPath);
+        while (currentPath !== path.dirname(currentPath)) {
+            const gitPath = path.join(currentPath, ".git");
+            if (fs.existsSync(gitPath)) {
+                return "Yes";
+            }
+            currentPath = path.dirname(currentPath);
+        }
+        return "No";
+    }
+    catch {
+        return "No";
+    }
+}
 /**
  * Get specific configuration parameters based on model name
  * @param modelName Model name
@@ -27,22 +52,23 @@ export async function callAgent(options) {
             baseURL: gatewayConfig.baseURL,
         });
         // 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.
+        let systemContent = systemPrompt ||
+            `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.`;
+        // Always add environment information
+        systemContent += `
 
-## Current Working Directory
-${workdir}
+Here is useful information about the environment you are running in:
+<env>
+Working directory: ${workdir}
+Is directory a git repo: ${isGitRepository(workdir)}
+Platform: ${os.platform()}
+OS Version: ${os.type()} ${os.release()}
+Today's date: ${new Date().toISOString().split("T")[0]}
+</env>
 `;
-            // 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}`;
-            }
+        // If there is memory content, add it to the system prompt
+        if (memory && memory.trim()) {
+            systemContent += `\n## Memory Context\n\nThe following is important context and memory from previous interactions:\n\n${memory}`;
         }
         // Add system prompt
         const systemMessage = {

package/dist/services/memory.js

@@ -10,7 +10,7 @@ export const addMemory = async (message, workdir) => {
         return;
     }
     try {
-        const memoryFilePath = path.join(workdir, "WAVE.md");
+        const memoryFilePath = path.join(workdir, "AGENTS.md");
         // Format memory entry, starting with -, no timestamp
         const memoryEntry = `- ${message.substring(1).trim()}\n`;
         // Check if file exists
@@ -97,7 +97,7 @@ export const getUserMemoryContent = async () => {
 // Read project memory file content
 export const readMemoryFile = async (workdir) => {
     try {
-        const memoryFilePath = path.join(workdir, "WAVE.md");
+        const memoryFilePath = path.join(workdir, "AGENTS.md");
         return await fs.readFile(memoryFilePath, "utf-8");
     }
     catch (error) {

package/dist/tools/grepTool.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"grepTool.d.ts","sourceRoot":"","sources":["../../src/tools/grepTool.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAA2B,MAAM,YAAY,CAAC;AAMtE;;GAEG;AACH,eAAO,MAAM,QAAQ,EAAE,UA0QtB,CAAC"}
+{"version":3,"file":"grepTool.d.ts","sourceRoot":"","sources":["../../src/tools/grepTool.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAA2B,MAAM,YAAY,CAAC;AAMtE;;GAEG;AACH,eAAO,MAAM,QAAQ,EAAE,UA6QtB,CAAC"}

package/dist/tools/grepTool.js

@@ -58,7 +58,7 @@ export const grepTool = {
                     },
                     head_limit: {
                         type: "number",
-                        description: 'Limit output to first N lines/entries, equivalent to "| head -N". Works across all output modes: content (limits output lines), files_with_matches (limits file paths), count (limits count entries). When unspecified, shows all results from ripgrep.',
+                        description: 'Limit output to first N lines/entries, equivalent to "| head -N". Works across all output modes: content (limits output lines), files_with_matches (limits file paths), count (limits count entries). Defaults to 100 to prevent excessive token usage.',
                     },
                     multiline: {
                         type: "boolean",
@@ -176,11 +176,13 @@ export const grepTool = {
                     shortResult: "No matches found",
                 };
             }
-            // Apply head_limit
+            // Apply head_limit with default fallback
             let finalOutput = output;
             let lines = output.split("\n");
-            if (headLimit && headLimit > 0 && lines.length > headLimit) {
-                lines = lines.slice(0, headLimit);
+            // Set default head_limit if not specified to prevent excessive token usage
+            const effectiveHeadLimit = headLimit || 100;
+            if (lines.length > effectiveHeadLimit) {
+                lines = lines.slice(0, effectiveHeadLimit);
                 finalOutput = lines.join("\n");
             }
             // Generate short result
@@ -195,8 +197,8 @@ export const grepTool = {
             else {
                 shortResult = `Found ${totalLines} matching line${totalLines === 1 ? "" : "s"}`;
             }
-            if (headLimit && totalLines > headLimit) {
-                shortResult += ` (showing first ${headLimit})`;
+            if (effectiveHeadLimit && totalLines > effectiveHeadLimit) {
+                shortResult += ` (showing first ${effectiveHeadLimit})`;
             }
             return {
                 success: true,

package/dist/tools/readTool.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"readTool.d.ts","sourceRoot":"","sources":["../../src/tools/readTool.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,UAAU,EAA2B,MAAM,YAAY,CAAC;AAGtE;;GAEG;AACH,eAAO,MAAM,QAAQ,EAAE,UA6JtB,CAAC"}
+{"version":3,"file":"readTool.d.ts","sourceRoot":"","sources":["../../src/tools/readTool.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,UAAU,EAA2B,MAAM,YAAY,CAAC;AAOtE;;GAEG;AACH,eAAO,MAAM,QAAQ,EAAE,UA2LtB,CAAC"}

package/dist/tools/readTool.js

@@ -1,5 +1,6 @@
 import { readFile } from "fs/promises";
 import { resolvePath, getDisplayPath } from "../utils/path.js";
+import { isBinaryDocument, getBinaryDocumentError, } from "../utils/fileFormat.js";
 /**
  * Read Tool Plugin - Read file content
  */
@@ -9,7 +10,7 @@ export const readTool = {
         type: "function",
         function: {
             name: "Read",
-            description: "Reads a file from the local filesystem. You can access any file directly by using this tool.\nAssume this tool is able to read all files on the machine. If the User provides a path to a file assume that path is valid. It is okay to read a file that does not exist; an error will be returned.\n\nUsage:\n- The file_path parameter must be an absolute path, not a relative path\n- By default, it reads up to 2000 lines starting from the beginning of the file\n- You can optionally specify a line offset and limit (especially handy for long files), but it's recommended to read the whole file by not providing these parameters\n- Any lines longer than 2000 characters will be truncated\n- Results are returned using cat -n format, with line numbers starting at 1\n- This tool allows Claude Code to read images (eg PNG, JPG, etc). When reading an image file the contents are presented visually as Claude Code is a multimodal LLM.\n- This tool can read PDF files (.pdf). PDFs are processed page by page, extracting both text and visual content for analysis.\n- This tool can read Jupyter notebooks (.ipynb files) and returns all cells with their outputs, combining code, text, and visualizations.\n- You have the capability to call multiple tools in a single response. It is always better to speculatively read multiple files as a batch that are potentially useful.\n- You will regularly be asked to read screenshots. If the user provides a path to a screenshot ALWAYS use this tool to view the file at the path. This tool will work with all temporary file paths like /var/folders/123/abc/T/TemporaryItems/NSIRD_screencaptureui_ZfB1tD/Screenshot.png\n- If you read a file that exists but has empty contents you will receive a system reminder warning in place of file contents.",
+            description: "Reads a file from the local filesystem. You can access any file directly by using this tool.\nAssume this tool is able to read all files on the machine. If the User provides a path to a file assume that path is valid. It is okay to read a file that does not exist; an error will be returned.\n\nUsage:\n- The file_path parameter must be an absolute path, not a relative path\n- By default, it reads up to 2000 lines starting from the beginning of the file\n- You can optionally specify a line offset and limit (especially handy for long files), but it's recommended to read the whole file by not providing these parameters\n- Any lines longer than 2000 characters will be truncated\n- Results are returned using cat -n format, with line numbers starting at 1\n- This tool allows Claude Code to read images (eg PNG, JPG, etc). When reading an image file the contents are presented visually as Claude Code is a multimodal LLM.\n- This tool can read Jupyter notebooks (.ipynb files) and returns all cells with their outputs, combining code, text, and visualizations.\n- You have the capability to call multiple tools in a single response. It is always better to speculatively read multiple files as a batch that are potentially useful.\n- You will regularly be asked to read screenshots. If the user provides a path to a screenshot ALWAYS use this tool to view the file at the path. This tool will work with all temporary file paths like /var/folders/123/abc/T/TemporaryItems/NSIRD_screencaptureui_ZfB1tD/Screenshot.png\n- If you read a file that exists but has empty contents you will receive a system reminder warning in place of file contents.\n- Binary document formats (PDF, DOC, DOCX, XLS, XLSX, PPT, PPTX) are not supported and will return an error.",
             parameters: {
                 type: "object",
                 properties: {
@@ -41,6 +42,14 @@ export const readTool = {
                 error: "file_path parameter is required and must be a string",
             };
         }
+        // Check for binary document formats
+        if (isBinaryDocument(filePath)) {
+            return {
+                success: false,
+                content: "",
+                error: getBinaryDocumentError(filePath),
+            };
+        }
         try {
             // Note: New Read tool requires absolute paths, so we don't use resolvePath
             // But for compatibility, if it's not an absolute path, we still try to resolve
@@ -57,8 +66,17 @@ export const readTool = {
                     shortResult: "Empty file",
                 };
             }
-            const lines = fileContent.split("\n");
+            // Check content size limit (100KB)
+            const MAX_CONTENT_SIZE = 100 * 1024; // 100KB
+            let contentToProcess = fileContent;
+            let contentTruncated = false;
+            if (fileContent.length > MAX_CONTENT_SIZE) {
+                contentToProcess = fileContent.substring(0, MAX_CONTENT_SIZE);
+                contentTruncated = true;
+            }
+            const lines = contentToProcess.split("\n");
             const totalLines = lines.length;
+            const originalTotalLines = fileContent.split("\n").length;
             // Handle offset and limit
             let startLine = 1;
             let endLine = Math.min(totalLines, 2000); // Default maximum read 2000 lines
@@ -94,7 +112,11 @@ export const readTool = {
                 .join("\n");
             // Add file information header
             let content = `File: ${filePath}\n`;
-            if (startLine > 1 || endLine < totalLines) {
+            if (contentTruncated) {
+                content += `Content truncated at ${MAX_CONTENT_SIZE} bytes\n`;
+                content += `Lines ${startLine}-${endLine} of ${totalLines} (original file: ${originalTotalLines} lines)\n`;
+            }
+            else if (startLine > 1 || endLine < totalLines) {
                 content += `Lines ${startLine}-${endLine} of ${totalLines}\n`;
             }
             else {
@@ -103,14 +125,22 @@ export const readTool = {
             content += "─".repeat(50) + "\n";
             content += formattedContent;
             // If only showing partial content, add prompt
-            if (endLine < totalLines) {
+            if (endLine < totalLines || contentTruncated) {
                 content += `\n${"─".repeat(50)}\n`;
-                content += `... ${totalLines - endLine} more lines not shown`;
+                if (contentTruncated) {
+                    content += `... content truncated due to size limit (${MAX_CONTENT_SIZE} bytes)`;
+                    if (endLine < totalLines) {
+                        content += ` and ${totalLines - endLine} more lines not shown`;
+                    }
+                }
+                else {
+                    content += `... ${totalLines - endLine} more lines not shown`;
+                }
             }
             return {
                 success: true,
                 content,
-                shortResult: `Read ${selectedLines.length} lines${totalLines > 2000 ? " (truncated)" : ""}`,
+                shortResult: `Read ${selectedLines.length} lines${totalLines > 2000 || contentTruncated ? " (truncated)" : ""}`,
             };
         }
         catch (error) {

package/dist/tools/skillTool.d.ts

@@ -0,0 +1,8 @@
+import type { ToolPlugin } from "./types.js";
+import type { SkillManager } from "../managers/skillManager.js";
+/**
+ * Create a skill tool plugin that uses the provided SkillManager
+ * Note: SkillManager should be initialized before calling this function
+ */
+export declare function createSkillTool(skillManager: SkillManager): ToolPlugin;
+//# sourceMappingURL=skillTool.d.ts.map

package/dist/tools/skillTool.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"skillTool.d.ts","sourceRoot":"","sources":["../../src/tools/skillTool.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAc,MAAM,YAAY,CAAC;AACzD,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,6BAA6B,CAAC;AAEhE;;;GAGG;AACH,wBAAgB,eAAe,CAAC,YAAY,EAAE,YAAY,GAAG,UAAU,CA0EtE"}