wave-agent-sdk 0.17.4 → 0.17.6

package/src/managers/skillManager.ts

@@ -29,6 +29,7 @@ import { logger } from "../utils/globalLogger.js";
  */
 export class SkillManager extends EventEmitter {
   private personalSkillsPath: string;
+  private personalClaudeSkillsPath: string;
   private scanTimeout: number;
   private workdir: string;
 
@@ -47,6 +48,8 @@ export class SkillManager extends EventEmitter {
     super();
     this.personalSkillsPath =
       options.personalSkillsPath || join(homedir(), ".wave", "skills");
+    this.personalClaudeSkillsPath =
+      options.personalClaudeSkillsPath || join(homedir(), ".claude", "skills");
     this.scanTimeout = options.scanTimeout || 5000;
     this.workdir = options.workdir || process.cwd();
     this.watchEnabled = options.watch ?? false;
@@ -127,7 +130,9 @@ export class SkillManager extends EventEmitter {
 
     const pathsToWatch = [
       this.personalSkillsPath,
+      this.personalClaudeSkillsPath,
       join(this.workdir, ".wave", "skills"),
+      join(this.workdir, ".claude", "skills"),
     ];
 
     logger?.debug(`Setting up skill watcher for: ${pathsToWatch.join(", ")}`);
@@ -220,6 +225,11 @@ export class SkillManager extends EventEmitter {
       "builtin",
     );
 
+    const personalClaudeCollection = await this.discoverSkillCollection(
+      this.personalClaudeSkillsPath,
+      "personal",
+    );
+
     const personalCollection = await this.discoverSkillCollection(
       this.personalSkillsPath,
       "personal",
@@ -232,10 +242,14 @@ export class SkillManager extends EventEmitter {
 
     return {
       builtinSkills: builtinCollection.skills,
-      personalSkills: personalCollection.skills,
+      personalSkills: new Map([
+        ...personalClaudeCollection.skills,
+        ...personalCollection.skills, // .wave overrides .claude
+      ]),
       projectSkills: projectCollection.skills,
       errors: [
         ...builtinCollection.errors,
+        ...personalClaudeCollection.errors,
         ...personalCollection.errors,
         ...projectCollection.errors,
       ],
@@ -256,77 +270,88 @@ export class SkillManager extends EventEmitter {
       errors: [],
     };
 
-    let skillsPath: string;
-    if (type === "personal") {
-      skillsPath = basePath;
-    } else if (type === "builtin") {
-      skillsPath = basePath;
+    if (type === "project") {
+      // Scan .claude/skills first, then .wave/skills (wave overrides)
+      const claudePath = join(basePath, ".claude", "skills");
+      const wavePath = join(basePath, ".wave", "skills");
+      await this.scanSkillPath(claudePath, collection);
+      await this.scanSkillPath(wavePath, collection);
     } else {
-      skillsPath = join(basePath, ".wave", "skills");
+      await this.scanSkillPath(basePath, collection);
     }
 
+    return collection;
+  }
+
+  private async scanSkillPath(
+    skillsPath: string,
+    collection: SkillCollection,
+  ): Promise<void> {
     try {
       const skillDirs = await this.findSkillDirectories(skillsPath);
       logger?.debug(
         `Found ${skillDirs.length} potential skill directories in ${skillsPath}`,
       );
+      await this.processSkillDirs(skillDirs, collection);
+    } catch (error) {
+      logger?.debug(
+        `Could not scan ${skillsPath}: ${error instanceof Error ? error.message : String(error)}`,
+      );
+    }
+  }
 
-      for (const skillDir of skillDirs) {
-        try {
-          const skillFilePath = join(skillDir, "SKILL.md");
+  private async processSkillDirs(
+    skillDirs: string[],
+    collection: SkillCollection,
+  ): Promise<void> {
+    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,
-          });
+        // Check if SKILL.md exists
+        try {
+          await stat(skillFilePath);
+        } catch {
+          continue; // Skip directories without SKILL.md
+        }
 
-          if (parsed.isValid) {
-            // Override the skill type with the collection type
-            const skillMetadata: SkillMetadata = {
-              ...parsed.skillMetadata,
-              type,
-            };
-
-            // Create full skill object with content
-            const skill: Skill = {
-              ...skillMetadata,
-              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) {
+        const parsed = parseSkillFile(skillFilePath, {
+          basePath: skillDir,
+          validateMetadata: true,
+        });
+
+        if (parsed.isValid) {
+          // Override the skill type with the collection type
+          const skillMetadata: SkillMetadata = {
+            ...parsed.skillMetadata,
+            type: collection.type,
+          };
+
+          // Create full skill object with content
+          const skill: Skill = {
+            ...skillMetadata,
+            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: `Failed to process skill: ${error instanceof Error ? error.message : String(error)}`,
+            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) {
-      logger?.debug(
-        `Could not scan ${skillsPath}: ${error instanceof Error ? error.message : String(error)}`,
-      );
-      // Not an error - the directory might not exist yet
     }
-
-    return collection;
   }
 
   /**
@@ -450,15 +475,23 @@ export class SkillManager extends EventEmitter {
     // 1. Substitute parameters ($1, $ARGUMENTS, etc.)
     mainContent = substituteCommandParameters(mainContent, argsString);
 
-    // 2. Substitute ${WAVE_SKILL_DIR} with the skill's directory path
+    // 2. Substitute ${WAVE_SKILL_DIR} and ${CLAUDE_SKILL_DIR}
     mainContent = mainContent.replace(/\$\{WAVE_SKILL_DIR\}/g, skill.skillPath);
+    mainContent = mainContent.replace(
+      /\$\{CLAUDE_SKILL_DIR\}/g,
+      skill.skillPath,
+    );
 
-    // 3. Substitute ${WAVE_PLUGIN_ROOT} with the skill's plugin root path
+    // 3. Substitute ${WAVE_PLUGIN_ROOT} and ${CLAUDE_PLUGIN_ROOT}
     if (skill.pluginRoot) {
       mainContent = mainContent.replace(
         /\$\{WAVE_PLUGIN_ROOT\}/g,
         skill.pluginRoot,
       );
+      mainContent = mainContent.replace(
+        /\$\{CLAUDE_PLUGIN_ROOT\}/g,
+        skill.pluginRoot,
+      );
     }
 
     return skillPath + mainContent;

package/src/services/MarketplaceService.ts

@@ -68,6 +68,9 @@ export class MarketplaceService {
 
     this.ensureDirectoryStructure();
     this.runMigration();
+    // Stored dynamically to avoid widening keyof MarketplaceService
+    (this as Record<string, unknown>)._seedComplete =
+      this.seedBuiltinMarketplace();
   }
 
   /**
@@ -121,6 +124,63 @@ export class MarketplaceService {
     }
   }
 
+  /**
+   * Seeds the builtin marketplace on first startup.
+   * Adds it to user-scope settings and marks the cache as seeded.
+   */
+  private async seedBuiltinMarketplace(): Promise<void> {
+    try {
+      const cache = await this.getCacheRegistry();
+      if (cache?.builtinSeeded) return;
+
+      const builtin = MarketplaceService.BUILTIN_MARKETPLACE;
+
+      // Add to user-scope settings if not already in any scope
+      const scoped = this.configurationService.getMergedMarketplaces(
+        this.workdir,
+      );
+      if (!scoped[builtin.name]) {
+        await this.configurationService.addMarketplaceToScope(
+          this.workdir,
+          "user",
+          builtin.name,
+          { source: builtin.source, autoUpdate: builtin.autoUpdate },
+        );
+      }
+
+      // Update cache: add entry + set builtinSeeded flag
+      await this.updateCacheMarketplace(builtin.name, {
+        source: builtin.source,
+        autoUpdate: builtin.autoUpdate,
+        isBuiltin: true,
+        declaredScope: "builtin",
+      });
+      await this.setBuiltinSeeded(true);
+    } catch {
+      // Seeding failure should not block startup
+    }
+  }
+
+  /**
+   * Sets the builtinSeeded flag in the cache registry, preserving all other fields.
+   */
+  private async setBuiltinSeeded(value: boolean): Promise<void> {
+    const registry = await this.getCacheRegistry();
+    const tmpPath = `${this.knownMarketplacesPath}.tmp`;
+    await fs.writeFile(
+      tmpPath,
+      JSON.stringify(
+        {
+          builtinSeeded: value,
+          marketplaces: registry?.marketplaces ?? [],
+        },
+        null,
+        2,
+      ),
+    );
+    await fs.rename(tmpPath, this.knownMarketplacesPath);
+  }
+
   /**
    * Check if a lock file is stale by reading its PID and checking if the process is alive.
    * Returns true if the lock is stale and safe to remove.
@@ -258,7 +318,17 @@ export class MarketplaceService {
       });
     }
     const tmpPath = `${this.knownMarketplacesPath}.tmp`;
-    await fs.writeFile(tmpPath, JSON.stringify({ marketplaces }, null, 2));
+    await fs.writeFile(
+      tmpPath,
+      JSON.stringify(
+        {
+          builtinSeeded: registry?.builtinSeeded ?? false,
+          marketplaces,
+        },
+        null,
+        2,
+      ),
+    );
     await fs.rename(tmpPath, this.knownMarketplacesPath);
   }
 
@@ -272,7 +342,14 @@ export class MarketplaceService {
     const tmpPath = `${this.knownMarketplacesPath}.tmp`;
     await fs.writeFile(
       tmpPath,
-      JSON.stringify({ marketplaces: filtered }, null, 2),
+      JSON.stringify(
+        {
+          builtinSeeded: registry?.builtinSeeded ?? false,
+          marketplaces: filtered,
+        },
+        null,
+        2,
+      ),
     );
     await fs.rename(tmpPath, this.knownMarketplacesPath);
   }
@@ -313,13 +390,21 @@ export class MarketplaceService {
   async loadMarketplaceManifest(
     marketplacePath: string,
   ): Promise<MarketplaceManifest> {
-    const manifestPath = path.join(
+    let manifestPath = path.join(
       marketplacePath,
       ".wave-plugin",
       "marketplace.json",
     );
     if (!existsSync(manifestPath)) {
-      throw new Error(`Marketplace manifest not found at ${manifestPath}`);
+      // Fallback to .claude-plugin/marketplace.json
+      manifestPath = path.join(
+        marketplacePath,
+        ".claude-plugin",
+        "marketplace.json",
+      );
+      if (!existsSync(manifestPath)) {
+        throw new Error(`Marketplace manifest not found at ${manifestPath}`);
+      }
     }
     const content = await fs.readFile(manifestPath, "utf-8");
     const manifest = JSON.parse(content);
@@ -536,6 +621,9 @@ export class MarketplaceService {
       const targetScope =
         scope || this.getMarketplaceDeclaringSource(name) || "user";
 
+      // Uninstall all plugins from this marketplace
+      await this.uninstallPluginsByMarketplace(name);
+
       if (targetScope !== "builtin") {
         await this.configurationService.removeMarketplaceFromScope(
           this.workdir,
@@ -549,6 +637,54 @@ export class MarketplaceService {
     });
   }
 
+  /**
+   * Uninstalls all plugins belonging to a given marketplace.
+   * Removes them from installed_plugins.json, deletes cache files,
+   * and cleans up enabledPlugins entries from all scopes.
+   */
+  private async uninstallPluginsByMarketplace(
+    marketplaceName: string,
+  ): Promise<void> {
+    const installedRegistry = await this.getInstalledPlugins();
+    const pluginsFromMarketplace = installedRegistry.plugins.filter(
+      (p) => p.marketplace === marketplaceName,
+    );
+
+    if (pluginsFromMarketplace.length === 0) return;
+
+    // Remove all plugins from this marketplace from the registry
+    installedRegistry.plugins = installedRegistry.plugins.filter(
+      (p) => p.marketplace !== marketplaceName,
+    );
+    await this.saveInstalledPlugins(installedRegistry);
+
+    // Delete cache files that are no longer referenced
+    const remainingCachePaths = new Set(
+      installedRegistry.plugins.map((p) => p.cachePath),
+    );
+    for (const plugin of pluginsFromMarketplace) {
+      if (
+        !remainingCachePaths.has(plugin.cachePath) &&
+        existsSync(plugin.cachePath)
+      ) {
+        await fs.rm(plugin.cachePath, { recursive: true, force: true });
+      }
+    }
+
+    // Remove enabledPlugins entries from all scopes
+    const scopes: Scope[] = ["user", "project", "local"];
+    for (const plugin of pluginsFromMarketplace) {
+      const pluginId = `${plugin.name}@${plugin.marketplace}`;
+      for (const s of scopes) {
+        await this.configurationService.removeEnabledPlugin(
+          this.workdir,
+          s,
+          pluginId,
+        );
+      }
+    }
+  }
+
   /**
    * Updates a specific marketplace or all marketplaces
    */
@@ -771,13 +907,23 @@ export class MarketplaceService {
           pluginSrcPath = path.resolve(marketplacePath, pluginEntry.source);
         }
 
-        const pluginManifestPath = path.join(
+        let pluginManifestPath = path.join(
           pluginSrcPath,
           ".wave-plugin",
           "plugin.json",
         );
         if (!existsSync(pluginManifestPath)) {
-          throw new Error(`Plugin manifest not found at ${pluginManifestPath}`);
+          // Fallback to .claude-plugin/plugin.json
+          pluginManifestPath = path.join(
+            pluginSrcPath,
+            ".claude-plugin",
+            "plugin.json",
+          );
+          if (!existsSync(pluginManifestPath)) {
+            throw new Error(
+              `Plugin manifest not found at ${pluginManifestPath}`,
+            );
+          }
         }
 
         const pluginManifestContent = await fs.readFile(

package/src/services/memory.ts

@@ -130,6 +130,27 @@ export class MemoryService {
         userMemoryFile: USER_MEMORY_FILE,
         contentLength: content.length,
       });
+
+      // If the file is still the default empty template, fallback to ~/.claude/AGENTS.md
+      const defaultTemplate =
+        "# User Memory\n\nThis is the user-level memory file, recording important information and context across projects.\n\n";
+      if (content === defaultTemplate) {
+        const claudeMemoryPath = path.join(homedir(), ".claude", "AGENTS.md");
+        try {
+          const claudeContent = await fs.readFile(claudeMemoryPath, "utf-8");
+          logger.debug(
+            "User memory content read from ~/.claude/AGENTS.md fallback",
+            {
+              claudeMemoryPath,
+              contentLength: claudeContent.length,
+            },
+          );
+          return claudeContent;
+        } catch {
+          // CLAUDE.md doesn't exist or can't be read, return the default template
+        }
+      }
+
       return content;
     } catch (error) {
       logger.error("Failed to read user memory:", error);
@@ -139,8 +160,6 @@ export class MemoryService {
 
   async readMemoryFile(workdir: string): Promise<string> {
     const memoryFilePath = path.join(workdir, "AGENTS.md");
-
-    // Direct file access
     try {
       const content = await fs.readFile(memoryFilePath, "utf-8");
       logger.debug("Memory file read successfully via direct file access", {
@@ -150,10 +169,28 @@ export class MemoryService {
       return content;
     } catch (error) {
       if ((error as NodeJS.ErrnoException).code === "ENOENT") {
-        logger.debug("Memory file does not exist, returning empty content", {
-          memoryFilePath,
-        });
-        return "";
+        // Fallback to CLAUDE.md
+        const claudeMemoryPath = path.join(workdir, "CLAUDE.md");
+        try {
+          const content = await fs.readFile(claudeMemoryPath, "utf-8");
+          logger.debug("Memory file read from CLAUDE.md fallback", {
+            memoryFilePath: claudeMemoryPath,
+            contentLength: content.length,
+          });
+          return content;
+        } catch (claudeError) {
+          if ((claudeError as NodeJS.ErrnoException).code === "ENOENT") {
+            logger.debug("Neither AGENTS.md nor CLAUDE.md found", {
+              memoryFilePath,
+            });
+            return "";
+          }
+          logger.error("Failed to read CLAUDE.md fallback", {
+            memoryFilePath: claudeMemoryPath,
+            error: claudeError,
+          });
+          return "";
+        }
       }
       logger.error("Failed to read memory file", { memoryFilePath, error });
       return "";

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/marketplace.ts

@@ -53,6 +53,7 @@ export interface KnownMarketplace {
 }
 
 export interface KnownMarketplacesRegistry {
+  builtinSeeded?: boolean;
   marketplaces: KnownMarketplace[];
 }
 

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";