wave-agent-sdk 0.0.2 → 0.0.3

package/dist/utils/subagentParser.js

@@ -0,0 +1,159 @@
+import { readFileSync, readdirSync, statSync } from "fs";
+import { join, extname } from "path";
+/**
+ * Parse YAML frontmatter from markdown file content
+ */
+function parseFrontmatter(content) {
+    const frontmatterRegex = /^---\s*\n([\s\S]*?)\n---\s*\n([\s\S]*)$/;
+    const match = content.match(frontmatterRegex);
+    if (!match) {
+        return { frontmatter: {}, body: content.trim() };
+    }
+    const [, yamlContent, body] = match;
+    const frontmatter = parseYamlFrontmatter(yamlContent);
+    return { frontmatter, body: body.trim() };
+}
+/**
+ * Simple YAML frontmatter parser for subagent files
+ */
+function parseYamlFrontmatter(yamlContent) {
+    const frontmatter = {};
+    try {
+        const lines = yamlContent.split("\n");
+        for (const line of lines) {
+            const trimmed = line.trim();
+            if (!trimmed || trimmed.startsWith("#"))
+                continue;
+            const colonIndex = trimmed.indexOf(":");
+            if (colonIndex === -1)
+                continue;
+            const key = trimmed.substring(0, colonIndex).trim();
+            const value = trimmed
+                .substring(colonIndex + 1)
+                .trim()
+                .replace(/^["']|["']$/g, "");
+            if (key && value) {
+                // Handle array values for tools
+                if (key === "tools" && value) {
+                    let arrayValue = value;
+                    if (arrayValue.startsWith("[") && arrayValue.endsWith("]")) {
+                        arrayValue = arrayValue.slice(1, -1);
+                    }
+                    frontmatter[key] = arrayValue
+                        .split(",")
+                        .map((s) => s.trim())
+                        .filter(Boolean);
+                }
+                else {
+                    if (key === "name" || key === "description" || key === "model") {
+                        frontmatter[key] = value;
+                    }
+                }
+            }
+        }
+    }
+    catch {
+        // Return empty frontmatter on parse error - validation will catch missing fields
+    }
+    return frontmatter;
+}
+/**
+ * Validate subagent configuration
+ */
+function validateConfiguration(config, filePath) {
+    if (!config.name) {
+        throw new Error(`Missing required field 'name' in ${filePath}`);
+    }
+    if (!config.description) {
+        throw new Error(`Missing required field 'description' in ${filePath}`);
+    }
+    // Validate name pattern
+    const namePattern = /^[a-z][a-z0-9-]*$/;
+    if (!namePattern.test(config.name)) {
+        throw new Error(`Invalid subagent name '${config.name}' in ${filePath}. Must start with a letter and contain only lowercase letters, numbers, and hyphens.`);
+    }
+    // Validate model if specified - allow any non-empty string
+    if (config.model && typeof config.model !== "string") {
+        throw new Error(`Invalid model '${config.model}' in ${filePath}. Must be a string.`);
+    }
+}
+/**
+ * Parse a single subagent markdown file
+ */
+function parseSubagentFile(filePath, scope) {
+    try {
+        const content = readFileSync(filePath, "utf-8");
+        const { frontmatter, body } = parseFrontmatter(content);
+        validateConfiguration(frontmatter, filePath);
+        if (!body.trim()) {
+            throw new Error(`Empty system prompt in ${filePath}`);
+        }
+        return {
+            name: frontmatter.name,
+            description: frontmatter.description,
+            tools: frontmatter.tools,
+            model: frontmatter.model,
+            systemPrompt: body,
+            filePath,
+            scope,
+            priority: scope === "project" ? 1 : 2,
+        };
+    }
+    catch (error) {
+        throw new Error(`Failed to parse subagent file ${filePath}: ${error instanceof Error ? error.message : String(error)}`);
+    }
+}
+/**
+ * Scan directory for subagent files
+ */
+function scanSubagentDirectory(dirPath, scope) {
+    const configurations = [];
+    try {
+        const entries = readdirSync(dirPath);
+        for (const entry of entries) {
+            const fullPath = join(dirPath, entry);
+            const stat = statSync(fullPath);
+            if (stat.isFile() && extname(entry) === ".md") {
+                try {
+                    const config = parseSubagentFile(fullPath, scope);
+                    configurations.push(config);
+                }
+                catch (parseError) {
+                    // Log error but continue with other files
+                    console.warn(`Warning: ${parseError instanceof Error ? parseError.message : String(parseError)}`);
+                }
+            }
+        }
+    }
+    catch {
+        // Directory doesn't exist or can't be read - this is OK
+    }
+    return configurations;
+}
+/**
+ * Load all subagent configurations from project and user directories
+ */
+export async function loadSubagentConfigurations(workdir) {
+    const projectDir = join(workdir, ".wave", "agents");
+    const userDir = join(process.env.HOME || "~", ".wave", "agents");
+    const projectConfigs = scanSubagentDirectory(projectDir, "project");
+    const userConfigs = scanSubagentDirectory(userDir, "user");
+    // Merge configurations, with project configs taking precedence
+    const configMap = new Map();
+    // Process in reverse priority order (user first, then project)
+    for (const config of [...userConfigs, ...projectConfigs]) {
+        configMap.set(config.name, config);
+    }
+    return Array.from(configMap.values()).sort((a, b) => {
+        if (a.priority !== b.priority)
+            return a.priority - b.priority;
+        return a.name.localeCompare(b.name);
+    });
+}
+/**
+ * Find subagent by exact name match
+ */
+export async function findSubagentByName(name, workdir) {
+    const configurations = await loadSubagentConfigurations(workdir);
+    return configurations.find((config) => config.name === name) || null;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "wave-agent-sdk",
-  "version": "0.0.2",
+  "version": "0.0.3",
   "description": "SDK for building AI-powered development tools and agents",
   "keywords": [
     "ai",

package/src/agent.ts

@@ -4,6 +4,7 @@ import {
 } from "./managers/messageManager.js";
 import { AIManager } from "./managers/aiManager.js";
 import { ToolManager } from "./managers/toolManager.js";
+import { SubagentManager } from "./managers/subagentManager.js";
 import * as memory from "./services/memory.js";
 import { McpManager, type McpManagerCallbacks } from "./managers/mcpManager.js";
 import { BashManager } from "./managers/bashManager.js";
@@ -23,6 +24,7 @@ import type {
 import { HookManager } from "./hooks/index.js";
 import { configResolver } from "./utils/configResolver.js";
 import { configValidator } from "./utils/configValidator.js";
+import { SkillManager } from "./managers/skillManager.js";
 
 /**
  * Configuration options for Agent instances
@@ -59,13 +61,13 @@ export interface AgentCallbacks
 export class Agent {
   private messageManager: MessageManager;
   private aiManager: AIManager;
-  private callbacks: AgentCallbacks;
 
   private bashManager: BashManager | null = null;
   private backgroundBashManager: BackgroundBashManager;
   private logger?: Logger; // Add optional logger property
   private toolManager: ToolManager; // Add tool registry instance
   private mcpManager: McpManager; // Add MCP manager instance
+  private subagentManager: SubagentManager; // Add subagent manager instance
   private slashCommandManager: SlashCommandManager; // Add slash command manager instance
   private hookManager: HookManager; // Add hooks manager instance
   private workdir: string; // Working directory
@@ -106,7 +108,6 @@ export class Agent {
       modelConfig.fastModel,
     );
 
-    this.callbacks = callbacks;
     this.logger = logger; // Save the passed logger
     this.workdir = workdir || process.cwd(); // Set working directory, default to current working directory
     this.systemPrompt = systemPrompt; // Save custom system prompt
@@ -121,7 +122,11 @@ export class Agent {
       workdir: this.workdir,
     });
     this.mcpManager = new McpManager({ callbacks, logger: this.logger }); // Initialize MCP manager
-    this.toolManager = new ToolManager({ mcpManager: this.mcpManager }); // Initialize tool registry, pass MCP manager
+    this.toolManager = new ToolManager({
+      mcpManager: this.mcpManager,
+      logger: this.logger,
+    }); // Initialize tool registry, pass MCP manager
+
     this.hookManager = new HookManager(
       this.workdir,
       undefined,
@@ -136,6 +141,18 @@ export class Agent {
       logger: this.logger,
     });
 
+    // Initialize subagent manager with all dependencies in constructor
+    // IMPORTANT: Must be initialized AFTER MessageManager
+    this.subagentManager = new SubagentManager({
+      workdir: this.workdir,
+      parentToolManager: this.toolManager,
+      parentMessageManager: this.messageManager,
+      logger: this.logger,
+      gatewayConfig,
+      modelConfig,
+      tokenLimit,
+    });
+
     // Initialize AI manager with resolved configuration
     this.aiManager = new AIManager({
       messageManager: this.messageManager,
@@ -242,6 +259,25 @@ export class Agent {
     continueLastSession?: boolean;
     messages?: Message[];
   }): Promise<void> {
+    // Initialize managers first
+    try {
+      // Initialize SkillManager
+      const skillManager = new SkillManager({ logger: this.logger });
+      await skillManager.initialize();
+
+      // Initialize SubagentManager (load and cache configurations)
+      await this.subagentManager.initialize();
+
+      // Initialize built-in tools with dependencies
+      this.toolManager.initializeBuiltInTools({
+        subagentManager: this.subagentManager,
+        skillManager: skillManager,
+      });
+    } catch (error) {
+      this.logger?.error("Failed to initialize managers and tools:", error);
+      // Don't throw error to prevent app startup failure
+    }
+
     // Initialize MCP servers with auto-connect
     try {
       await this.mcpManager.initialize(this.workdir, true);
@@ -295,6 +331,7 @@ export class Agent {
     this.abortAIMessage();
     this.abortBashCommand();
     this.abortSlashCommand();
+    this.abortSubagents();
   }
 
   /** Add to input history */
@@ -312,16 +349,29 @@ export class Agent {
     this.slashCommandManager.abortCurrentCommand();
   }
 
+  /** Interrupt all subagent execution */
+  public abortSubagents(): void {
+    this.subagentManager.abortAllInstances();
+  }
+
+  /** Interrupt specific subagent execution */
+  public abortSubagent(subagentId: string): boolean {
+    return this.subagentManager.abortInstance(subagentId);
+  }
+
   /** Destroy managers, clean up resources */
   public async destroy(): Promise<void> {
     this.messageManager.saveSession();
     this.abortAIMessage();
     this.abortBashCommand();
     this.abortSlashCommand();
+    this.abortSubagents();
     // Cleanup background bash manager
     this.backgroundBashManager.cleanup();
     // Cleanup MCP connections
     await this.mcpManager.cleanup();
+    // Cleanup subagent manager
+    this.subagentManager.cleanup();
   }
 
   public async sendMessage(

package/src/index.ts

@@ -14,7 +14,6 @@ export * from "./utils/mcpUtils.js";
 export * from "./utils/messageOperations.js";
 export * from "./utils/path.js";
 export * from "./utils/stringUtils.js";
-export * from "./utils/markdownParser.js";
 export * from "./utils/customCommands.js";
 
 // Export hooks system

package/src/managers/aiManager.ts

@@ -444,14 +444,11 @@ export class AIManager {
       if (recursionDepth === 0) {
         this.setIsLoading(false);
 
-        // Save session and execute Stop hooks in parallel but maintain order
-        (async () => {
-          // Save session before executing Stop hooks
-          await this.messageManager.saveSession();
-
-          // Execute Stop hooks when AI response cycle completes
-          await this.executeStopHooks();
-        })();
+        // Save session before executing Stop hooks
+        await this.messageManager.saveSession();
+
+        // Execute Stop hooks when AI response cycle completes
+        await this.executeStopHooks();
       }
     }
   }

package/src/managers/messageManager.ts

@@ -10,6 +10,10 @@ import {
   addCommandOutputMessage,
   updateCommandOutputInMessage,
   completeCommandInMessage,
+  addSubagentBlockToMessage,
+  updateSubagentBlockInMessage,
+  type AddSubagentBlockParams,
+  type UpdateSubagentBlockParams,
   type AgentToolBlockUpdateParams,
 } from "../utils/messageOperations.js";
 import type { Logger, Message } from "../types.js";
@@ -48,10 +52,19 @@ export interface MessageManagerCallbacks {
     type: "project" | "user",
     storagePath: string,
   ) => void;
+  // Custom command callback
+  onCustomCommandAdded?: (
+    commandName: string,
+    content: string,
+    originalInput?: string,
+  ) => void;
   // Bash command callback
   onAddCommandOutputMessage?: (command: string) => void;
   onUpdateCommandOutputMessage?: (command: string, output: string) => void;
   onCompleteCommandMessage?: (command: string, exitCode: number) => void;
+  // Subagent callbacks
+  onSubAgentBlockAdded?: (subagentId: string) => void;
+  onSubAgentBlockUpdated?: (subagentId: string, messages: Message[]) => void;
 }
 
 export interface MessageManagerOptions {
@@ -271,7 +284,7 @@ export class MessageManager {
       },
     });
     this.setMessages(newMessages);
-    this.callbacks.onUserMessageAdded?.(content);
+    this.callbacks.onCustomCommandAdded?.(commandName, content, originalInput);
   }
 
   public addAssistantMessage(
@@ -412,4 +425,45 @@ export class MessageManager {
     this.setMessages(updatedMessages);
     this.callbacks.onCompleteCommandMessage?.(command, exitCode);
   }
+
+  // Subagent block methods
+  public addSubagentBlock(
+    subagentId: string,
+    subagentName: string,
+    status: "active" | "completed" | "error" = "active",
+    subagentMessages: Message[] = [],
+  ): void {
+    const params: AddSubagentBlockParams = {
+      messages: this.messages,
+      subagentId,
+      subagentName,
+      status,
+      subagentMessages,
+    };
+    const updatedMessages = addSubagentBlockToMessage(params);
+    this.setMessages(updatedMessages);
+    this.callbacks.onSubAgentBlockAdded?.(params.subagentId);
+  }
+
+  public updateSubagentBlock(
+    subagentId: string,
+    updates: Partial<{
+      status: "active" | "completed" | "error" | "aborted";
+      messages: Message[];
+    }>,
+  ): void {
+    const updatedMessages = updateSubagentBlockInMessage(
+      this.messages,
+      subagentId,
+      updates,
+    );
+    this.setMessages(updatedMessages);
+    const params: UpdateSubagentBlockParams = {
+      messages: this.messages,
+      subagentId,
+      status: updates.status || "active",
+      subagentMessages: updates.messages || [],
+    };
+    this.callbacks.onSubAgentBlockUpdated?.(params.subagentId, params.messages);
+  }
 }

package/src/managers/skillManager.ts

@@ -11,7 +11,6 @@ import type {
   SkillInvocationContext,
   Logger,
 } from "../types.js";
-import type { ToolPlugin, ToolResult } from "../tools/types.js";
 import { parseSkillFile, formatSkillError } from "../utils/skillParser.js";
 
 /**
@@ -76,6 +75,13 @@ export class SkillManager {
     }
   }
 
+  /**
+   * Check if the skill manager is initialized
+   */
+  isInitialized(): boolean {
+    return this.initialized;
+  }
+
   /**
    * Get all available skills metadata
    */
@@ -233,101 +239,6 @@ export class SkillManager {
     return directories;
   }
 
-  /**
-   * Create a tool plugin for registering with ToolManager
-   */
-  createTool(): ToolPlugin {
-    // Initialize skill manager asynchronously
-    let initializationPromise: Promise<void> | null = null;
-
-    const ensureInitialized = async (): Promise<void> => {
-      if (!initializationPromise) {
-        initializationPromise = this.initialize();
-      }
-      await initializationPromise;
-    };
-
-    const getToolDescription = (): string => {
-      if (!this.initialized) {
-        return "Invoke a Wave skill by name. Skills are user-defined automation templates that can be personal or project-specific. Skills will be loaded during initialization.";
-      }
-
-      const availableSkills = this.getAvailableSkills();
-
-      if (availableSkills.length === 0) {
-        return "Invoke a Wave skill by name. Skills are user-defined automation templates that can be personal or project-specific. No skills are currently available.";
-      }
-
-      const skillList = availableSkills
-        .map(
-          (skill) =>
-            `• **${skill.name}** (${skill.type}): ${skill.description}`,
-        )
-        .join("\n");
-
-      return `Invoke a Wave skill by name. Skills are user-defined automation templates that can be personal or project-specific.\n\nAvailable skills:\n${skillList}`;
-    };
-
-    return {
-      name: "skill",
-      config: {
-        type: "function",
-        function: {
-          name: "skill",
-          description: getToolDescription(),
-          parameters: {
-            type: "object",
-            properties: {
-              skill_name: {
-                type: "string",
-                description: "Name of the skill to invoke",
-                enum: this.initialized
-                  ? this.getAvailableSkills().map((skill) => skill.name)
-                  : [],
-              },
-            },
-            required: ["skill_name"],
-          },
-        },
-      },
-      execute: async (args: Record<string, unknown>): Promise<ToolResult> => {
-        try {
-          // Ensure skill manager is initialized
-          await ensureInitialized();
-
-          // Validate arguments
-          const skillName = args.skill_name as string;
-          if (!skillName || typeof skillName !== "string") {
-            return {
-              success: false,
-              content: "",
-              error: "skill_name parameter is required and must be a string",
-            };
-          }
-
-          // Execute the skill
-          const result = await this.executeSkill({ skill_name: skillName });
-
-          return {
-            success: true,
-            content: result.content,
-            shortResult: `Invoked skill: ${skillName}`,
-          };
-        } catch (error) {
-          return {
-            success: false,
-            content: "",
-            error: error instanceof Error ? error.message : String(error),
-          };
-        }
-      },
-      formatCompactParams: (params: Record<string, unknown>) => {
-        const skillName = params.skill_name as string;
-        return skillName || "unknown-skill";
-      },
-    };
-  }
-
   /**
    * Execute a skill by name
    */