wave-agent-sdk 1.0.4 → 1.0.6

package/src/managers/planManager.ts

@@ -1,112 +0,0 @@
-import path from "node:path";
-import fs from "node:fs/promises";
-import os from "node:os";
-import { generateRandomName } from "../utils/nameGenerator.js";
-
-import { Container } from "../utils/container.js";
-import { MessageManager } from "./messageManager.js";
-import { PermissionManager } from "./permissionManager.js";
-import type { PermissionMode } from "../types/permissions.js";
-
-/**
- * Manages plan files for plan mode
- */
-import { logger } from "../utils/globalLogger.js";
-
-export class PlanManager {
-  private planDir: string;
-  private currentPlanFilePath: string | null = null;
-  private planEntryReminderPending: boolean = false;
-
-  constructor(private container: Container) {
-    this.planDir = path.join(os.homedir(), ".wave", "plans");
-  }
-
-  /**
-   * Ensures the plan directory exists and generates a new plan file path with a random name
-   */
-  public async getOrGeneratePlanFilePath(seed?: string): Promise<{
-    path: string;
-    name: string;
-  }> {
-    try {
-      await fs.mkdir(this.planDir, { recursive: true });
-    } catch (error) {
-      logger?.error(`Failed to create plan directory: ${this.planDir}`, error);
-      throw error;
-    }
-    const name = generateRandomName(seed);
-    const filePath = path.join(this.planDir, `${name}.md`);
-
-    if (this.currentPlanFilePath !== filePath) {
-      try {
-        await fs.unlink(filePath);
-      } catch (error) {
-        if (
-          error instanceof Error &&
-          (error as Error & { code?: string }).code !== "ENOENT"
-        ) {
-          logger?.error(
-            `Failed to remove existing plan file: ${filePath}`,
-            error,
-          );
-        }
-      }
-      this.currentPlanFilePath = filePath;
-    }
-
-    logger?.info(`Generated plan file path: ${filePath}`);
-    return { path: filePath, name };
-  }
-
-  /**
-   * Returns the directory where plan files are stored
-   */
-  public getPlanDir(): string {
-    return this.planDir;
-  }
-
-  /**
-   * Handle plan mode transition, generating or clearing plan file path
-   * @param mode - The current effective permission mode
-   */
-  public handlePlanModeTransition(mode: PermissionMode): void {
-    const permissionManager =
-      this.container.get<PermissionManager>("PermissionManager");
-    const messageManager = this.container.get<MessageManager>("MessageManager");
-
-    const previousMode = this.container.get<PermissionMode>("PermissionMode");
-
-    if (mode === "plan") {
-      // Entering plan mode: clear any pending exit attachment
-      // (prevents sending both plan_mode and plan_mode_exit on rapid toggle)
-      permissionManager?.setNeedsPlanModeExitAttachment(false);
-      this.planEntryReminderPending = true;
-
-      this.getOrGeneratePlanFilePath(messageManager?.getRootSessionId())
-        .then(({ path }) => {
-          logger?.debug("Plan file path generated", { path });
-          permissionManager?.setPlanFilePath(path);
-        })
-        .catch((error) => {
-          logger?.error("Failed to generate plan file path", error);
-        });
-    } else if (previousMode === "plan") {
-      // Leaving plan mode: set flags for exit notification and re-entry detection
-      permissionManager?.setHasExitedPlanMode(true);
-      permissionManager?.setNeedsPlanModeExitAttachment(true);
-      permissionManager?.setPlanFilePath(undefined);
-      this.planEntryReminderPending = false;
-    } else {
-      permissionManager?.setPlanFilePath(undefined);
-    }
-  }
-
-  public isPlanEntryReminderPending(): boolean {
-    return this.planEntryReminderPending;
-  }
-
-  public consumePlanEntryReminder(): void {
-    this.planEntryReminderPending = false;
-  }
-}

package/src/managers/pluginManager.ts

@@ -1,330 +0,0 @@
-import { logger } from "../utils/globalLogger.js";
-import { Plugin, PluginConfig } from "../types/index.js";
-import { PluginLoader } from "../services/pluginLoader.js";
-import * as path from "path";
-import { existsSync, readdirSync } from "fs";
-import { getBuiltinPluginsDir } from "../utils/configPaths.js";
-import { SkillManager } from "./skillManager.js";
-import { HookManager } from "./hookManager.js";
-import { LspManager } from "./lspManager.js";
-import { McpManager } from "./mcpManager.js";
-import { SlashCommandManager } from "./slashCommandManager.js";
-import { SubagentManager } from "./subagentManager.js";
-import { MarketplaceService } from "../services/MarketplaceService.js";
-import { ConfigurationService } from "../services/configurationService.js";
-import { Container } from "../utils/container.js";
-
-export interface PluginManagerOptions {
-  workdir: string;
-  enabledPlugins?: Record<string, boolean>;
-}
-
-export class PluginManager {
-  private plugins = new Map<string, Plugin>();
-  private workdir: string;
-  private enabledPlugins: Record<string, boolean>;
-
-  constructor(
-    private container: Container,
-    options: PluginManagerOptions,
-  ) {
-    this.workdir = options.workdir;
-    this.enabledPlugins = options.enabledPlugins || {};
-  }
-
-  private get skillManager(): SkillManager | undefined {
-    return this.container.get<SkillManager>("SkillManager");
-  }
-
-  private get hookManager(): HookManager | undefined {
-    return this.container.get<HookManager>("HookManager");
-  }
-
-  private get lspManager(): LspManager | undefined {
-    return this.container.get<LspManager>("LspManager");
-  }
-
-  private get mcpManager(): McpManager | undefined {
-    return this.container.get<McpManager>("McpManager");
-  }
-
-  private get slashCommandManager(): SlashCommandManager | undefined {
-    return this.container.get<SlashCommandManager>("SlashCommandManager");
-  }
-
-  private get configurationService(): ConfigurationService | undefined {
-    return this.container.get<ConfigurationService>("ConfigurationService");
-  }
-
-  private get subagentManager(): SubagentManager | undefined {
-    return this.container.get<SubagentManager>("SubagentManager");
-  }
-
-  /**
-   * Update enabled plugins configuration
-   */
-  updateEnabledPlugins(enabledPlugins: Record<string, boolean>): void {
-    this.enabledPlugins = enabledPlugins;
-  }
-
-  /**
-   * Load plugins installed via marketplace
-   */
-  private async loadInstalledPlugins(): Promise<void> {
-    try {
-      // If configurationService is provided, use it to get the latest merged enabled plugins
-      if (this.configurationService) {
-        this.enabledPlugins = this.configurationService.getMergedEnabledPlugins(
-          this.workdir,
-        );
-      }
-
-      const marketplaceService = new MarketplaceService(
-        this.workdir,
-        this.configurationService,
-      );
-
-      // Trigger auto-update for marketplaces in the background
-      if (!process.env.VITEST) {
-        marketplaceService.autoUpdateAll().catch((error) => {
-          logger?.error("Background marketplace auto-update failed:", error);
-        });
-      }
-
-      let installedRegistry = await marketplaceService.getInstalledPlugins();
-      const knownMarketplaces = await marketplaceService.listMarketplaces();
-
-      // Identify missing enabled plugins and auto-install them if marketplace is known
-      for (const pluginId of Object.keys(this.enabledPlugins)) {
-        if (this.enabledPlugins[pluginId] !== true) continue;
-
-        const [name, marketplaceName] = pluginId.split("@");
-        if (!name || !marketplaceName) continue;
-        // `@builtin` entries are loaded by loadBuiltinPlugins, not the marketplace.
-        if (marketplaceName === "builtin") continue;
-
-        const isInstalled = installedRegistry.plugins.some(
-          (p) => p.name === name && p.marketplace === marketplaceName,
-        );
-
-        if (!isInstalled) {
-          const isMarketplaceKnown = knownMarketplaces.some(
-            (m) => m.name === marketplaceName,
-          );
-
-          if (isMarketplaceKnown) {
-            // Pre-check: verify the plugin still exists in the marketplace manifest
-            // before acquiring the lock in installPlugin (which can block ~8s during autoUpdate)
-            const marketplace = knownMarketplaces.find(
-              (m) => m.name === marketplaceName,
-            );
-            if (!marketplace) continue;
-            try {
-              const marketplacePath = marketplaceService.getMarketplacePath(
-                marketplace.source,
-              );
-              const manifest =
-                await marketplaceService.loadMarketplaceManifest(
-                  marketplacePath,
-                );
-              const pluginExists = manifest.plugins.some(
-                (p) => p.name === name,
-              );
-              if (!pluginExists) {
-                logger?.warn(
-                  `Plugin ${pluginId} is enabled but no longer exists in marketplace ${marketplaceName}. Removing from enabledPlugins.`,
-                );
-                await this.configurationService?.removeEnabledPlugin(
-                  this.workdir,
-                  "user",
-                  pluginId,
-                );
-                continue;
-              }
-            } catch {
-              // Manifest read failed — marketplace may not be cloned yet, try to clone/update it
-              try {
-                await marketplaceService.updateMarketplace(marketplaceName);
-              } catch (updateError) {
-                logger?.warn(
-                  `Failed to clone/update marketplace ${marketplaceName}: ${updateError instanceof Error ? updateError.message : String(updateError)}`,
-                );
-              }
-            }
-
-            logger?.info(`Auto-installing missing plugin: ${pluginId}`);
-            try {
-              await marketplaceService.installPlugin(pluginId);
-            } catch (installError) {
-              if (
-                installError instanceof Error &&
-                installError.message.includes("not found in marketplace")
-              ) {
-                logger?.warn(
-                  `Plugin ${pluginId} no longer found in marketplace. Removing from enabledPlugins.`,
-                );
-                await this.configurationService?.removeEnabledPlugin(
-                  this.workdir,
-                  "user",
-                  pluginId,
-                );
-              } else {
-                logger?.error(
-                  `Failed to auto-install plugin ${pluginId}:`,
-                  installError,
-                );
-              }
-            }
-          } else {
-            logger?.warn(
-              `Plugin ${pluginId} is enabled but marketplace ${marketplaceName} is unknown. Skipping auto-install.`,
-            );
-          }
-        }
-      }
-
-      // Refresh registry after potential auto-installs
-      installedRegistry = await marketplaceService.getInstalledPlugins();
-
-      for (const p of installedRegistry.plugins) {
-        const pluginId = `${p.name}@${p.marketplace}`;
-        if (this.enabledPlugins[pluginId] !== true) {
-          logger?.debug(`Plugin ${pluginId} is not enabled via configuration`);
-          continue;
-        }
-        await this.loadSinglePlugin(p.cachePath);
-      }
-    } catch (error) {
-      logger?.error("Failed to load installed plugins:", error);
-    }
-  }
-
-  /**
-   * Load a single plugin from an absolute path
-   */
-  private async loadSinglePlugin(absolutePath: string): Promise<void> {
-    try {
-      const manifest = await PluginLoader.loadManifest(absolutePath);
-
-      if (this.plugins.has(manifest.name)) {
-        // If already loaded (e.g. via explicit config), skip
-        logger?.warn(`Plugin with name '${manifest.name}' is already loaded`);
-        return;
-      }
-
-      const plugin: Plugin = {
-        ...manifest,
-        path: absolutePath,
-        commands: PluginLoader.loadCommands(absolutePath),
-        skills: await PluginLoader.loadSkills(absolutePath),
-        agents: await PluginLoader.loadAgents(absolutePath),
-        lspConfig: await PluginLoader.loadLspConfig(absolutePath),
-        mcpConfig: await PluginLoader.loadMcpConfig(absolutePath),
-        hooksConfig: await PluginLoader.loadHooksConfig(absolutePath),
-      };
-
-      // Register components with managers
-      if (this.slashCommandManager && plugin.commands.length > 0) {
-        this.slashCommandManager.registerPluginCommands(
-          plugin.name,
-          plugin.commands,
-        );
-      }
-
-      if (this.skillManager && plugin.skills.length > 0) {
-        this.skillManager.registerPluginSkills(plugin.name, plugin.skills);
-      }
-
-      if (this.lspManager && plugin.lspConfig) {
-        for (const [language, config] of Object.entries(plugin.lspConfig)) {
-          const configWithPluginRoot = { ...config, pluginRoot: plugin.path };
-          this.lspManager.registerServer(language, configWithPluginRoot);
-        }
-      }
-
-      if (this.mcpManager && plugin.mcpConfig) {
-        for (const [name, config] of Object.entries(
-          plugin.mcpConfig.mcpServers,
-        )) {
-          const configWithPluginRoot = { ...config, pluginRoot: plugin.path };
-          this.mcpManager.addServer(name, configWithPluginRoot);
-        }
-      }
-
-      if (this.hookManager && plugin.hooksConfig) {
-        this.hookManager.registerPluginHooks(plugin.path, plugin.hooksConfig);
-      }
-
-      if (this.subagentManager && plugin.agents.length > 0) {
-        this.subagentManager.registerPluginAgents(plugin.name, plugin.agents);
-      }
-
-      this.plugins.set(manifest.name, plugin);
-      logger?.debug(`Loaded plugin: ${manifest.name} v${manifest.version}`);
-    } catch (error) {
-      logger?.error(`Failed to load plugin from ${absolutePath}`, error);
-    }
-  }
-
-  /**
-   * Load plugins from configuration
-   * @param configs Array of plugin configurations
-   */
-  async loadPlugins(configs: PluginConfig[]): Promise<void> {
-    // Load plugins from configuration (e.g. --plugin-dir) first to give them higher priority
-    for (const config of configs) {
-      if (config.type !== "local") {
-        logger?.warn(`Unsupported plugin type: ${config.type}`);
-        continue;
-      }
-
-      const absolutePath = path.isAbsolute(config.path)
-        ? config.path
-        : path.resolve(this.workdir, config.path);
-
-      await this.loadSinglePlugin(absolutePath);
-    }
-
-    // Load installed plugins from marketplace
-    await this.loadInstalledPlugins();
-
-    // Load built-in plugins bundled with the SDK (lowest priority)
-    await this.loadBuiltinPlugins();
-  }
-
-  /**
-   * Load built-in plugins bundled with the SDK (e.g. sdd).
-   * Opt-in via `enabledPlugins`, keyed `<name>@builtin` (default off, consistent
-   * with marketplace plugins). Lowest priority: explicit config and marketplace
-   * plugins win on name conflicts (loadSinglePlugin skips duplicates).
-   */
-  private async loadBuiltinPlugins(): Promise<void> {
-    try {
-      const builtinDir = getBuiltinPluginsDir();
-      if (!existsSync(builtinDir)) return;
-
-      // The builtin plugin directory name is the plugin name by convention.
-      for (const entry of readdirSync(builtinDir, { withFileTypes: true })) {
-        if (!entry.isDirectory()) continue;
-        if (this.enabledPlugins[`${entry.name}@builtin`] !== true) continue;
-        await this.loadSinglePlugin(path.join(builtinDir, entry.name));
-      }
-    } catch (error) {
-      logger?.error("Failed to load built-in plugins:", error);
-    }
-  }
-
-  /**
-   * Get all loaded plugins
-   */
-  getPlugins(): Plugin[] {
-    return Array.from(this.plugins.values());
-  }
-
-  /**
-   * Get a plugin by name
-   */
-  getPlugin(name: string): Plugin | undefined {
-    return this.plugins.get(name);
-  }
-}

package/src/managers/pluginScopeManager.ts

@@ -1,124 +0,0 @@
-import { ConfigurationService } from "../services/configurationService.js";
-import { PluginManager } from "./pluginManager.js";
-import { Logger } from "../types/index.js";
-import { Scope } from "../types/configuration.js";
-
-export interface PluginScopeManagerOptions {
-  workdir: string;
-  configurationService: ConfigurationService;
-  pluginManager: PluginManager;
-  logger?: Logger;
-}
-
-export class PluginScopeManager {
-  private workdir: string;
-  private configurationService: ConfigurationService;
-  private pluginManager: PluginManager;
-  private logger?: Logger;
-
-  constructor(options: PluginScopeManagerOptions) {
-    this.workdir = options.workdir;
-    this.configurationService = options.configurationService;
-    this.pluginManager = options.pluginManager;
-    this.logger = options.logger;
-  }
-
-  /**
-   * Enable a plugin in the specified scope
-   */
-  async enablePlugin(scope: Scope, pluginId: string): Promise<void> {
-    await this.configurationService.updateEnabledPlugin(
-      this.workdir,
-      scope,
-      pluginId,
-      true,
-    );
-    this.logger?.info(`Enabled plugin ${pluginId} in ${scope} scope`);
-    this.refreshPluginManager();
-  }
-
-  /**
-   * Disable a plugin in the specified scope
-   */
-  async disablePlugin(scope: Scope, pluginId: string): Promise<void> {
-    await this.configurationService.updateEnabledPlugin(
-      this.workdir,
-      scope,
-      pluginId,
-      false,
-    );
-    this.logger?.info(`Disabled plugin ${pluginId} in ${scope} scope`);
-    this.refreshPluginManager();
-  }
-
-  /**
-   * Get the merged enabled state of all plugins
-   */
-  getMergedEnabledPlugins(): Record<string, boolean> {
-    return this.configurationService.getMergedEnabledPlugins(this.workdir);
-  }
-
-  /**
-   * Find the scope where a plugin is currently enabled/disabled.
-   * Priority: local > project > user
-   */
-  findPluginScope(pluginId: string): Scope | null {
-    const projectPaths = this.configurationService.getConfigurationPaths(
-      this.workdir,
-    ).projectPaths; // [local, json]
-    const userPaths = this.configurationService.getConfigurationPaths(
-      this.workdir,
-    ).userPaths; // [local, json]
-
-    const checkPaths: { path: string; scope: Scope }[] = [
-      { path: projectPaths[0], scope: "local" },
-      { path: projectPaths[1], scope: "project" },
-      { path: userPaths[0], scope: "user" }, // user local is still user scope
-      { path: userPaths[1], scope: "user" },
-    ];
-
-    for (const { path, scope } of checkPaths) {
-      const config = this.configurationService.loadWaveConfigFromFile(path);
-      if (config?.enabledPlugins && pluginId in config.enabledPlugins) {
-        return scope;
-      }
-    }
-
-    return null;
-  }
-
-  /**
-   * Remove a plugin from all scopes (user, project, local)
-   * This is useful when uninstalling a plugin to clean up all configuration
-   */
-  async removePluginFromAllScopes(pluginId: string): Promise<void> {
-    const scopes: Scope[] = ["user", "project", "local"];
-
-    for (const scope of scopes) {
-      try {
-        await this.configurationService.removeEnabledPlugin(
-          this.workdir,
-          scope,
-          pluginId,
-        );
-      } catch (error) {
-        // Continue removing from other scopes even if one fails
-        this.logger?.warn(
-          `Failed to remove plugin ${pluginId} from ${scope} scope: ${error instanceof Error ? error.message : String(error)}`,
-        );
-      }
-    }
-
-    this.refreshPluginManager();
-  }
-
-  /**
-   * Refresh the plugin manager with the latest configuration
-   * Note: This only updates the configuration, it doesn't reload plugins.
-   * Reloading plugins might require a more complex logic (unloading/loading).
-   */
-  private refreshPluginManager(): void {
-    const enabledPlugins = this.getMergedEnabledPlugins();
-    this.pluginManager.updateEnabledPlugins(enabledPlugins);
-  }
-}