wave-agent-sdk 0.0.1 → 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.1",
+  "version": "0.0.3",
   "description": "SDK for building AI-powered development tools and agents",
   "keywords": [
     "ai",
@@ -18,18 +18,6 @@
     "src",
     "README.md"
   ],
-  "scripts": {
-    "build": "rimraf dist && tsc -p tsconfig.build.json && tsc-alias -p tsconfig.build.json",
-    "type-check": "tsc --noEmit --incremental",
-    "dev": "tsc -p tsconfig.build.json --watch & tsc-alias -p tsconfig.build.json --watch",
-    "test": "vitest run",
-    "lint": "eslint --cache",
-    "format": "prettier --write .",
-    "release:patch": "pnpm version patch && npm publish",
-    "release:minor": "pnpm version minor && npm publish",
-    "release:major": "pnpm version major && npm publish",
-    "prepublishOnly": "npm run build"
-  },
   "dependencies": {
     "@modelcontextprotocol/sdk": "^1.18.2",
     "@vscode/ripgrep": "^1.15.14",
@@ -47,5 +35,13 @@
   "engines": {
     "node": ">=16.0.0"
   },
-  "license": "MIT"
-}
+  "license": "MIT",
+  "scripts": {
+    "build": "rimraf dist && tsc -p tsconfig.build.json && tsc-alias -p tsconfig.build.json",
+    "type-check": "tsc --noEmit --incremental",
+    "dev": "tsc -p tsconfig.build.json --watch & tsc-alias -p tsconfig.build.json --watch",
+    "test": "vitest run",
+    "lint": "eslint --cache",
+    "format": "prettier --write ."
+  }
+}

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";
@@ -13,10 +14,33 @@ import {
 } from "./managers/backgroundBashManager.js";
 import { SlashCommandManager } from "./managers/slashCommandManager.js";
 import type { SlashCommand, CustomSlashCommand } from "./types.js";
-import type { Message, Logger, McpServerStatus } from "./types.js";
+import type {
+  Message,
+  Logger,
+  McpServerStatus,
+  GatewayConfig,
+  ModelConfig,
+} from "./types.js";
 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
+ *
+ * IMPORTANT: This interface is used by both Agent constructor and Agent.create()
+ * Any changes to this interface must be compatible with both methods.
+ */
 export interface AgentOptions {
+  // Optional configuration with environment fallbacks
+  apiKey?: string;
+  baseURL?: string;
+  agentModel?: string;
+  fastModel?: string;
+  tokenLimit?: number;
+
+  // Existing options (preserved)
   callbacks?: AgentCallbacks;
   restoreSessionId?: string;
   continueLastSession?: boolean;
@@ -37,32 +61,72 @@ 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
   private systemPrompt?: string; // Custom system prompt
 
-  // Private constructor to prevent direct instantiation
-  private constructor(options: AgentOptions) {
+  // Configuration properties
+  private gatewayConfig: GatewayConfig;
+  private modelConfig: ModelConfig;
+  private tokenLimit: number;
+
+  /**
+   * Agent constructor - handles configuration resolution and validation
+   *
+   * IMPORTANT: Keep this constructor's signature exactly the same as Agent.create()
+   * to maintain API consistency. Both methods should accept the same AgentOptions.
+   *
+   * @param options - Configuration options for the Agent instance
+   */
+  constructor(options: AgentOptions) {
     const { callbacks = {}, logger, workdir, systemPrompt } = options;
 
-    this.callbacks = callbacks;
+    // Resolve configuration from constructor args and environment variables
+    const gatewayConfig = configResolver.resolveGatewayConfig(
+      options.apiKey,
+      options.baseURL,
+    );
+    const modelConfig = configResolver.resolveModelConfig(
+      options.agentModel,
+      options.fastModel,
+    );
+    const tokenLimit = configResolver.resolveTokenLimit(options.tokenLimit);
+
+    // Validate resolved configuration
+    configValidator.validateGatewayConfig(gatewayConfig);
+    configValidator.validateTokenLimit(tokenLimit);
+    configValidator.validateModelConfig(
+      modelConfig.agentModel,
+      modelConfig.fastModel,
+    );
+
     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
+
+    // Store resolved configuration
+    this.gatewayConfig = gatewayConfig;
+    this.modelConfig = modelConfig;
+    this.tokenLimit = tokenLimit;
+
     this.backgroundBashManager = new BackgroundBashManager({
       callbacks,
       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,
@@ -77,7 +141,19 @@ export class Agent {
       logger: this.logger,
     });
 
-    // Initialize AI manager
+    // 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,
       toolManager: this.toolManager,
@@ -87,6 +163,9 @@ export class Agent {
       callbacks,
       workdir: this.workdir,
       systemPrompt: this.systemPrompt,
+      gatewayConfig: this.gatewayConfig,
+      modelConfig: this.modelConfig,
+      tokenLimit: this.tokenLimit,
     });
 
     // Initialize command manager
@@ -154,8 +233,17 @@ export class Agent {
     return this.backgroundBashManager.killShell(id);
   }
 
-  /** Static async factory method */
+  /**
+   * Static async factory method for creating Agent instances
+   *
+   * IMPORTANT: Keep this method's signature exactly the same as the constructor
+   * to maintain consistency and avoid confusion for users of the API.
+   *
+   * @param options - Same AgentOptions interface used by constructor
+   * @returns Promise<Agent> - Fully initialized Agent instance
+   */
   static async create(options: AgentOptions): Promise<Agent> {
+    // Create Agent instance - configuration resolution and validation now happens in constructor
     const instance = new Agent(options);
     await instance.initialize({
       restoreSessionId: options.restoreSessionId,
@@ -171,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);
@@ -224,6 +331,7 @@ export class Agent {
     this.abortAIMessage();
     this.abortBashCommand();
     this.abortSlashCommand();
+    this.abortSubagents();
   }
 
   /** Add to input history */
@@ -241,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

@@ -2,12 +2,11 @@ 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 type { Logger } from "../types.js";
+import type { Logger, GatewayConfig, ModelConfig } from "../types.js";
 import type { ToolManager } from "./toolManager.js";
 import type { ToolContext, ToolResult } from "../tools/types.js";
 import type { MessageManager } from "./messageManager.js";
 import type { BackgroundBashManager } from "./backgroundBashManager.js";
-import { DEFAULT_TOKEN_LIMIT } from "../utils/constants.js";
 import { ChatCompletionMessageFunctionToolCall } from "openai/resources.js";
 import type { HookManager } from "../hooks/index.js";
 import type { ExtendedHookExecutionContext } from "../hooks/types.js";
@@ -25,6 +24,10 @@ export interface AIManagerOptions {
   callbacks?: AIManagerCallbacks;
   workdir: string;
   systemPrompt?: string;
+  // Resolved configuration
+  gatewayConfig: GatewayConfig;
+  modelConfig: ModelConfig;
+  tokenLimit: number;
 }
 
 export class AIManager {
@@ -39,6 +42,11 @@ export class AIManager {
   private workdir: string;
   private systemPrompt?: string;
 
+  // Configuration properties
+  private gatewayConfig: GatewayConfig;
+  private modelConfig: ModelConfig;
+  private tokenLimit: number;
+
   constructor(options: AIManagerOptions) {
     this.messageManager = options.messageManager;
     this.toolManager = options.toolManager;
@@ -48,6 +56,11 @@ export class AIManager {
     this.workdir = options.workdir;
     this.systemPrompt = options.systemPrompt;
     this.callbacks = options.callbacks ?? {};
+
+    // Store resolved configuration
+    this.gatewayConfig = options.gatewayConfig;
+    this.modelConfig = options.modelConfig;
+    this.tokenLimit = options.tokenLimit;
   }
 
   private isCompressing: boolean = false;
@@ -125,15 +138,10 @@ export class AIManager {
     // 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) {
+    // Check if token limit exceeded - use injected configuration
+    if (usage.total_tokens > this.tokenLimit) {
       this.logger?.info(
-        `Token usage exceeded ${tokenLimit}, compressing messages...`,
+        `Token usage exceeded ${this.tokenLimit}, compressing messages...`,
       );
 
       // Check if messages need compression
@@ -149,6 +157,8 @@ export class AIManager {
         this.setIsCompressing(true);
         try {
           const compressedContent = await compressMessages({
+            gatewayConfig: this.gatewayConfig,
+            modelConfig: this.modelConfig,
             messages: recentChatMessages,
             abortSignal: abortController.signal,
           });
@@ -221,6 +231,8 @@ export class AIManager {
 
       // Call AI service (non-streaming)
       const result = await callAgent({
+        gatewayConfig: this.gatewayConfig,
+        modelConfig: this.modelConfig,
         messages: recentMessages,
         sessionId: this.messageManager.getSessionId(),
         abortSignal: abortController.signal,

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);
+  }
 }