wave-agent-sdk 0.0.1

package/src/managers/skillManager.ts

@@ -0,0 +1,404 @@
+import { readdir, stat } from "fs/promises";
+import { join } from "path";
+import { homedir } from "os";
+import type {
+  SkillManagerOptions,
+  SkillMetadata,
+  Skill,
+  SkillCollection,
+  SkillDiscoveryResult,
+  SkillToolArgs,
+  SkillInvocationContext,
+  Logger,
+} from "../types.js";
+import type { ToolPlugin, ToolResult } from "../tools/types.js";
+import { parseSkillFile, formatSkillError } from "../utils/skillParser.js";
+
+/**
+ * Manages skill discovery and loading
+ */
+export class SkillManager {
+  private personalSkillsPath: string;
+  private scanTimeout: number;
+  private logger?: Logger;
+
+  private skillMetadata = new Map<string, SkillMetadata>();
+  private skillContent = new Map<string, Skill>();
+  private initialized = false;
+
+  constructor(options: SkillManagerOptions = {}) {
+    this.personalSkillsPath =
+      options.personalSkillsPath || join(homedir(), ".wave", "skills");
+    this.scanTimeout = options.scanTimeout || 5000;
+    this.logger = options.logger;
+  }
+
+  /**
+   * Initialize the skill manager by discovering available skills
+   */
+  async initialize(): Promise<void> {
+    this.logger?.info("Initializing SkillManager...");
+
+    try {
+      // Clear existing data before discovery
+      this.skillMetadata.clear();
+      this.skillContent.clear();
+
+      const discovery = await this.discoverSkills();
+
+      // Store discovered skill metadata
+      discovery.personalSkills.forEach((skill, name) => {
+        this.skillMetadata.set(name, skill);
+      });
+      discovery.projectSkills.forEach((skill, name) => {
+        this.skillMetadata.set(name, skill);
+      });
+
+      // Log any discovery errors
+      if (discovery.errors.length > 0) {
+        this.logger?.warn(
+          `Found ${discovery.errors.length} skill discovery errors`,
+        );
+        discovery.errors.forEach((error) => {
+          this.logger?.warn(
+            `Skill error in ${error.skillPath}: ${error.message}`,
+          );
+        });
+      }
+
+      this.initialized = true;
+      this.logger?.info(
+        `SkillManager initialized with ${this.skillMetadata.size} skills`,
+      );
+    } catch (error) {
+      this.logger?.error("Failed to initialize SkillManager:", error);
+      throw error;
+    }
+  }
+
+  /**
+   * Get all available skills metadata
+   */
+  getAvailableSkills(): SkillMetadata[] {
+    if (!this.initialized) {
+      throw new Error("SkillManager not initialized. Call initialize() first.");
+    }
+
+    return Array.from(this.skillMetadata.values());
+  }
+
+  /**
+   * Load a specific skill by name
+   * Returns the skill content that was loaded during initialization
+   */
+  async loadSkill(skillName: string): Promise<Skill | null> {
+    if (!this.initialized) {
+      throw new Error("SkillManager not initialized. Call initialize() first.");
+    }
+
+    // Return skill content that was loaded during initialization
+    const skill = this.skillContent.get(skillName);
+    if (skill) {
+      this.logger?.debug(`Skill '${skillName}' retrieved from loaded content`);
+      return skill;
+    }
+
+    this.logger?.debug(`Skill '${skillName}' not found`);
+    return null;
+  }
+
+  /**
+   * Discover skills in both personal and project directories
+   */
+  private async discoverSkills(): Promise<SkillDiscoveryResult> {
+    const personalCollection = await this.discoverSkillCollection(
+      this.personalSkillsPath,
+      "personal",
+    );
+
+    const projectCollection = await this.discoverSkillCollection(
+      process.cwd(),
+      "project",
+    );
+
+    return {
+      personalSkills: personalCollection.skills,
+      projectSkills: projectCollection.skills,
+      errors: [...personalCollection.errors, ...projectCollection.errors],
+    };
+  }
+
+  /**
+   * Discover skills in a specific directory
+   */
+  private async discoverSkillCollection(
+    basePath: string,
+    type: "personal" | "project",
+  ): Promise<SkillCollection> {
+    const collection: SkillCollection = {
+      type,
+      basePath,
+      skills: new Map(),
+      errors: [],
+    };
+
+    const skillsPath =
+      type === "personal" ? basePath : join(basePath, ".wave", "skills");
+
+    try {
+      const skillDirs = await this.findSkillDirectories(skillsPath);
+      this.logger?.debug(
+        `Found ${skillDirs.length} potential skill directories in ${skillsPath}`,
+      );
+
+      for (const skillDir of skillDirs) {
+        try {
+          const skillFilePath = join(skillDir, "SKILL.md");
+
+          // Check if SKILL.md exists
+          try {
+            await stat(skillFilePath);
+          } catch {
+            continue; // Skip directories without SKILL.md
+          }
+
+          const parsed = parseSkillFile(skillFilePath, {
+            basePath: skillDir,
+            validateMetadata: true,
+          });
+
+          if (parsed.isValid) {
+            // Override the skill type with the collection type
+            const skillMetadata = {
+              ...parsed.skillMetadata,
+              type,
+            };
+
+            // Create full skill object with content
+            const skill: Skill = {
+              name: parsed.skillMetadata.name,
+              description: parsed.skillMetadata.description,
+              type: type, // Use the collection type
+              skillPath: parsed.skillMetadata.skillPath,
+              content: parsed.content,
+              frontmatter: parsed.frontmatter,
+              isValid: parsed.isValid,
+              errors: parsed.validationErrors,
+            };
+
+            collection.skills.set(skillMetadata.name, skillMetadata);
+            // Store the full skill content in the manager's skillContent map
+            this.skillContent.set(skillMetadata.name, skill);
+          } else {
+            collection.errors.push({
+              skillPath: skillDir,
+              message: parsed.validationErrors.join("; "),
+            });
+          }
+        } catch (error) {
+          collection.errors.push({
+            skillPath: skillDir,
+            message: `Failed to process skill: ${error instanceof Error ? error.message : String(error)}`,
+          });
+        }
+      }
+    } catch (error) {
+      this.logger?.debug(
+        `Could not scan ${skillsPath}: ${error instanceof Error ? error.message : String(error)}`,
+      );
+      // Not an error - the directory might not exist yet
+    }
+
+    return collection;
+  }
+
+  /**
+   * Find all directories that could contain skills
+   */
+  private async findSkillDirectories(skillsPath: string): Promise<string[]> {
+    const directories: string[] = [];
+
+    try {
+      const entries = await readdir(skillsPath, { withFileTypes: true });
+
+      for (const entry of entries) {
+        if (entry.isDirectory()) {
+          directories.push(join(skillsPath, entry.name));
+        }
+      }
+    } catch {
+      // Directory doesn't exist - return empty array
+    }
+
+    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
+   */
+  async executeSkill(
+    args: SkillToolArgs,
+  ): Promise<{ content: string; context?: SkillInvocationContext }> {
+    const { skill_name } = args;
+
+    this.logger?.info(`Invoking skill: ${skill_name}`);
+
+    try {
+      // Load the skill
+      const skill = await this.loadSkill(skill_name);
+
+      if (!skill) {
+        return {
+          content: `❌ **Skill not found**: "${skill_name}"\n\nAvailable skills:\n${this.formatAvailableSkills()}`,
+        };
+      }
+
+      if (!skill.isValid) {
+        const errorMsg = formatSkillError(skill.skillPath, skill.errors);
+        return {
+          content: `❌ **Skill validation failed**:\n\n\`\`\`\n${errorMsg}\n\`\`\``,
+        };
+      }
+
+      // Return skill content with context
+      return {
+        content: this.formatSkillContent(skill),
+        context: {
+          skillName: skill_name,
+        },
+      };
+    } catch (error) {
+      this.logger?.error(`Failed to execute skill '${skill_name}':`, error);
+      return {
+        content: `❌ **Error executing skill**: ${error instanceof Error ? error.message : String(error)}`,
+      };
+    }
+  }
+
+  /**
+   * Format skill content for output
+   */
+  private formatSkillContent(skill: Skill): string {
+    const header = `🧠 **${skill.name}** (${skill.type} skill)\n\n`;
+    const description = `*${skill.description}*\n\n`;
+    const skillPath = `📁 Skill location: \`${skill.skillPath}\`\n\n`;
+
+    // Extract content after frontmatter
+    const contentMatch = skill.content.match(/^---\n[\s\S]*?\n---\n([\s\S]*)$/);
+    const mainContent = contentMatch ? contentMatch[1].trim() : skill.content;
+
+    return header + description + skillPath + mainContent;
+  }
+
+  /**
+   * Format available skills list for error messages
+   */
+  private formatAvailableSkills(): string {
+    const skills = this.getAvailableSkills();
+
+    if (skills.length === 0) {
+      return "• No skills available\n\nTo create skills, see the Wave Skills documentation.";
+    }
+
+    return skills
+      .map(
+        (skill) => `• **${skill.name}** (${skill.type}): ${skill.description}`,
+      )
+      .join("\n");
+  }
+}

package/src/managers/slashCommandManager.ts

@@ -0,0 +1,293 @@
+import type { MessageManager } from "./messageManager.js";
+import type { AIManager } from "./aiManager.js";
+import type { SlashCommand, CustomSlashCommand, Logger } from "../types.js";
+import { loadCustomSlashCommands } from "../utils/customCommands.js";
+
+import {
+  substituteCommandParameters,
+  parseSlashCommandInput,
+  hasParameterPlaceholders,
+} from "../utils/commandArgumentParser.js";
+import {
+  BashCommandResult,
+  parseBashCommands,
+  replaceBashCommandsWithOutput,
+} from "../utils/markdownParser.js";
+import { exec } from "child_process";
+import { promisify } from "util";
+
+const execAsync = promisify(exec);
+
+export interface SlashCommandManagerOptions {
+  messageManager: MessageManager;
+  aiManager: AIManager;
+  workdir: string;
+  logger?: Logger;
+}
+
+export class SlashCommandManager {
+  private commands = new Map<string, SlashCommand>();
+  private customCommands = new Map<string, CustomSlashCommand>();
+  private messageManager: MessageManager;
+  private aiManager: AIManager;
+  private workdir: string;
+  private logger?: Logger;
+
+  constructor(options: SlashCommandManagerOptions) {
+    this.messageManager = options.messageManager;
+    this.aiManager = options.aiManager;
+    this.workdir = options.workdir;
+    this.logger = options.logger;
+
+    this.initializeBuiltinCommands();
+    this.loadCustomCommands();
+  }
+
+  private initializeBuiltinCommands(): void {
+    // 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
+   */
+  private loadCustomCommands(): void {
+    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?: string) => {
+            // 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)
+   */
+  public reloadCustomCommands(): void {
+    // Clear existing custom commands
+    for (const commandId of this.customCommands.keys()) {
+      this.unregisterCommand(commandId);
+    }
+    this.customCommands.clear();
+
+    // Reload
+    this.loadCustomCommands();
+  }
+
+  /**
+   * Register new command
+   */
+  private registerCommand(command: SlashCommand): void {
+    this.commands.set(command.id, command);
+  }
+
+  /**
+   * Unregister command
+   */
+  private unregisterCommand(commandId: string): boolean {
+    return this.commands.delete(commandId);
+  }
+
+  /**
+   * Get all available commands
+   */
+  public getCommands(): SlashCommand[] {
+    return Array.from(this.commands.values());
+  }
+
+  /**
+   * Get command by ID
+   */
+  public getCommand(commandId: string): SlashCommand | undefined {
+    return this.commands.get(commandId);
+  }
+
+  /**
+   * Execute command
+   */
+  public async executeCommand(
+    commandId: string,
+    args?: string,
+  ): Promise<boolean> {
+    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
+   */
+  public parseAndValidateSlashCommand(input: string): {
+    isValid: boolean;
+    commandId?: string;
+    args?: string;
+  } {
+    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
+   */
+  public hasCommand(commandId: string): boolean {
+    return this.commands.has(commandId);
+  }
+
+  /**
+   * Get custom command details
+   */
+  public getCustomCommand(commandId: string): CustomSlashCommand | undefined {
+    return this.customCommands.get(commandId);
+  }
+
+  /**
+   * Get all custom commands
+   */
+  public getCustomCommands(): CustomSlashCommand[] {
+    return Array.from(this.customCommands.values());
+  }
+
+  /**
+   * Execute custom command in main agent instead of sub-agent
+   */
+  private async executeCustomCommandInMainAgent(
+    commandName: string,
+    content: string,
+    config?: { model?: string; allowedTools?: string[] },
+    args?: string,
+  ): Promise<void> {
+    try {
+      // Parse bash commands from the content
+      const { commands, processedContent } = parseBashCommands(content);
+
+      // Execute bash commands if any
+      const bashResults: BashCommandResult[] = [];
+      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 as {
+            stdout?: string;
+            stderr?: string;
+            message?: string;
+            code?: number;
+          };
+          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
+   */
+  public abortCurrentCommand(): void {
+    // Abort the AI manager if it's running
+    this.aiManager.abortAIMessage();
+  }
+}