wave-agent-sdk 0.17.5 → 0.17.6

package/src/services/pluginLoader.ts

@@ -23,11 +23,13 @@ export class PluginLoader {
    */
   static async loadManifest(pluginPath: string): Promise<PluginManifest> {
     const dotWavePluginPath = path.join(pluginPath, ".wave-plugin");
-    const manifestPath = path.join(dotWavePluginPath, "plugin.json");
 
-    // T018: Ensure plugin.json is the only file in .wave-plugin/
+    // Check if .wave-plugin/ directory exists
+    let wavePluginDirExists = false;
     try {
       const entries = await fs.readdir(dotWavePluginPath);
+      wavePluginDirExists = true;
+      // T018: Ensure plugin.json is the only file in .wave-plugin/
       const misplaced = entries.filter((e) => e !== "plugin.json");
       if (misplaced.length > 0) {
         throw new Error(
@@ -39,15 +41,39 @@ export class PluginLoader {
         error instanceof Error &&
         (error as { code?: string }).code === "ENOENT"
       ) {
+        // .wave-plugin/ doesn't exist, will try .claude-plugin/ fallback below
+      } else {
+        throw error;
+      }
+    }
+
+    if (wavePluginDirExists) {
+      const manifestPath = path.join(dotWavePluginPath, "plugin.json");
+      try {
+        const content = await fs.readFile(manifestPath, "utf-8");
+        const manifest = JSON.parse(content) as PluginManifest;
+        this.validateManifest(manifest);
+        return manifest;
+      } catch (error) {
+        if (
+          error instanceof Error &&
+          (error as { code?: string }).code === "ENOENT"
+        ) {
+          throw new Error(`Plugin manifest not found at ${manifestPath}`);
+        }
         throw new Error(
-          `Plugin manifest directory not found at ${dotWavePluginPath}`,
+          `Failed to load plugin manifest at ${manifestPath}: ${
+            error instanceof Error ? error.message : String(error)
+          }`,
         );
       }
-      throw error;
     }
 
+    // Fallback to .claude-plugin/
+    const dotClaudePluginPath = path.join(pluginPath, ".claude-plugin");
+    const claudeManifestPath = path.join(dotClaudePluginPath, "plugin.json");
     try {
-      const content = await fs.readFile(manifestPath, "utf-8");
+      const content = await fs.readFile(claudeManifestPath, "utf-8");
       const manifest = JSON.parse(content) as PluginManifest;
       this.validateManifest(manifest);
       return manifest;
@@ -56,10 +82,12 @@ export class PluginLoader {
         error instanceof Error &&
         (error as { code?: string }).code === "ENOENT"
       ) {
-        throw new Error(`Plugin manifest not found at ${manifestPath}`);
+        throw new Error(
+          `Plugin manifest not found at ${dotWavePluginPath} or ${dotClaudePluginPath}`,
+        );
       }
       throw new Error(
-        `Failed to load plugin manifest at ${manifestPath}: ${
+        `Failed to load plugin manifest at ${claudeManifestPath}: ${
           error instanceof Error ? error.message : String(error)
         }`,
       );

package/src/types/skills.ts

@@ -73,6 +73,7 @@ export interface SkillToolArgs {
 
 export interface SkillManagerOptions {
   personalSkillsPath?: string;
+  personalClaudeSkillsPath?: string;
   scanTimeout?: number;
   workdir?: string;
   watch?: boolean;

package/src/utils/customCommands.ts

@@ -70,21 +70,26 @@ export function scanCommandsDirectory(dirPath: string): CustomSlashCommand[] {
  * Load all custom slash commands from both project and user directories
  */
 export function loadCustomSlashCommands(workdir: string): CustomSlashCommand[] {
-  const projectCommands = scanCommandsDirectory(getProjectCommandsDir(workdir));
-  const userCommands = scanCommandsDirectory(getUserCommandsDir());
+  const userClaudeCommands = scanCommandsDirectory(
+    join(homedir(), ".claude", "commands"),
+  );
+  const userWaveCommands = scanCommandsDirectory(getUserCommandsDir());
+  const projectClaudeCommands = scanCommandsDirectory(
+    join(workdir, ".claude", "commands"),
+  );
+  const projectWaveCommands = scanCommandsDirectory(
+    getProjectCommandsDir(workdir),
+  );
 
-  // Project commands take precedence over user commands with the same name
   const commandMap = new Map<string, CustomSlashCommand>();
-
-  // Add user commands first
-  for (const command of userCommands) {
+  // Write in priority order: lowest first, highest last (overwrites)
+  for (const command of [
+    ...userClaudeCommands,
+    ...userWaveCommands,
+    ...projectClaudeCommands,
+    ...projectWaveCommands,
+  ]) {
     commandMap.set(command.id, command);
   }
-
-  // Add project commands (will overwrite user commands with same name)
-  for (const command of projectCommands) {
-    commandMap.set(command.id, command);
-  }
-
   return Array.from(commandMap.values());
 }

package/src/utils/skillParser.ts

@@ -55,7 +55,9 @@ export function parseSkillFile(
     const skillPath = basePath || dirname(filePath);
     const skillType =
       skillPath.includes("/.wave/skills") ||
-      skillPath.includes("\\.wave\\skills")
+      skillPath.includes("\\.wave\\skills") ||
+      skillPath.includes("/.claude/skills") ||
+      skillPath.includes("\\.claude\\skills")
         ? "project"
         : "personal";
 

package/src/utils/subagentParser.ts

@@ -230,20 +230,34 @@ function scanSubagentDirectory(
 export async function loadSubagentConfigurations(
   workdir: string,
 ): Promise<SubagentConfiguration[]> {
-  const projectDir = join(workdir, ".wave", "agents");
-  const userDir = join(process.env.HOME || "~", ".wave", "agents");
+  const projectWaveDir = join(workdir, ".wave", "agents");
+  const projectClaudeDir = join(workdir, ".claude", "agents");
+  const userWaveDir = join(process.env.HOME || "~", ".wave", "agents");
+  const userClaudeDir = join(process.env.HOME || "~", ".claude", "agents");
   const builtinDir = getBuiltinSubagentsDir();
 
   // Load configurations from all sources
   const builtinConfigs = scanSubagentDirectory(builtinDir, "builtin");
-  const projectConfigs = scanSubagentDirectory(projectDir, "project");
-  const userConfigs = scanSubagentDirectory(userDir, "user");
-
-  // Merge configurations, with project configs taking highest precedence
+  const userClaudeConfigs = scanSubagentDirectory(userClaudeDir, "user");
+  const userWaveConfigs = scanSubagentDirectory(userWaveDir, "user");
+  const projectClaudeConfigs = scanSubagentDirectory(
+    projectClaudeDir,
+    "project",
+  );
+  const projectWaveConfigs = scanSubagentDirectory(projectWaveDir, "project");
+
+  // Merge configurations, with .wave taking priority over .claude
   const configMap = new Map<string, SubagentConfiguration>();
 
-  // Process in reverse priority order (built-in first, then user, then project)
-  for (const config of [...builtinConfigs, ...userConfigs, ...projectConfigs]) {
+  // Merge order: builtin → userClaude → userWave → projectClaude → projectWave
+  // Later writes override earlier ones, so .wave takes priority over .claude
+  for (const config of [
+    ...builtinConfigs,
+    ...userClaudeConfigs,
+    ...userWaveConfigs,
+    ...projectClaudeConfigs,
+    ...projectWaveConfigs,
+  ]) {
     configMap.set(config.name, config);
   }