wave-agent-sdk 1.0.5 → 1.0.7

package/src/constants/subagents.ts

@@ -1,4 +0,0 @@
-export const BASH_SUBAGENT_TYPE = "Bash";
-export const EXPLORE_SUBAGENT_TYPE = "Explore";
-export const PLAN_SUBAGENT_TYPE = "Plan";
-export const GENERAL_PURPOSE_SUBAGENT_TYPE = "general-purpose";

package/src/constants/toolLimits.ts

@@ -1,15 +0,0 @@
-/**
- * Tool output size limits matching Claude Code patterns.
- */
-
-/** System-wide default max result size in characters. */
-export const DEFAULT_MAX_RESULT_SIZE_CHARS = 50_000;
-
-/** Per-command cap for bash tool output before persistence. */
-export const BASH_MAX_OUTPUT_CHARS = 30_000;
-
-/** Per-command cap for skill bash substitution (inline/block). */
-export const SKILL_BASH_MAX_OUTPUT_CHARS = 30_000;
-
-/** Preview size in characters when output is persisted to disk. */
-export const PREVIEW_SIZE_BYTES = 2_048;

package/src/constants/tools.ts

@@ -1,24 +0,0 @@
-export const ASK_USER_QUESTION_TOOL_NAME = "AskUserQuestion";
-export const BASH_TOOL_NAME = "Bash";
-export const TASK_STOP_TOOL_NAME = "TaskStop";
-export const EDIT_TOOL_NAME = "Edit";
-export const ENTER_PLAN_MODE_TOOL_NAME = "EnterPlanMode";
-export const EXIT_PLAN_MODE_TOOL_NAME = "ExitPlanMode";
-export const GLOB_TOOL_NAME = "Glob";
-export const GREP_TOOL_NAME = "Grep";
-export const LSP_TOOL_NAME = "LSP";
-export const READ_TOOL_NAME = "Read";
-export const SKILL_TOOL_NAME = "Skill";
-export const AGENT_TOOL_NAME = "Agent";
-export const TASK_CREATE_TOOL_NAME = "TaskCreate";
-export const TASK_GET_TOOL_NAME = "TaskGet";
-export const TASK_UPDATE_TOOL_NAME = "TaskUpdate";
-export const TASK_LIST_TOOL_NAME = "TaskList";
-export const WRITE_TOOL_NAME = "Write";
-export const CRON_CREATE_TOOL_NAME = "CronCreate";
-export const CRON_DELETE_TOOL_NAME = "CronDelete";
-export const CRON_LIST_TOOL_NAME = "CronList";
-export const WEB_FETCH_TOOL_NAME = "WebFetch";
-export const ENTER_WORKTREE_TOOL_NAME = "EnterWorktree";
-export const EXIT_WORKTREE_TOOL_NAME = "ExitWorktree";
-export const WORKFLOW_TOOL_NAME = "Workflow";

package/src/core/plugin.ts

@@ -1,237 +0,0 @@
-import { Container } from "../utils/container.js";
-import { PluginManager } from "../managers/pluginManager.js";
-import { PluginScopeManager } from "../managers/pluginScopeManager.js";
-import { MarketplaceService } from "../services/MarketplaceService.js";
-import { ConfigurationService } from "../services/configurationService.js";
-import {
-  Scope,
-  InstalledPlugin,
-  KnownMarketplace,
-  MarketplaceManifest,
-  InstalledPluginsRegistry,
-  MarketplacePluginStatus,
-} from "../types/index.js";
-
-/**
- * PluginCore
- *
- * Encapsulates plugin management logic, providing a high-level API for
- * installing, uninstalling, enabling, and disabling plugins.
- */
-export class PluginCore {
-  private container: Container;
-  private pluginManager: PluginManager;
-  private pluginScopeManager: PluginScopeManager;
-  private marketplaceService: MarketplaceService;
-  private configurationService: ConfigurationService;
-  private workdir: string;
-
-  constructor(workdir: string = process.cwd()) {
-    this.workdir = workdir;
-    this.container = new Container();
-    this.configurationService = new ConfigurationService();
-    this.marketplaceService = new MarketplaceService(
-      this.workdir,
-      this.configurationService,
-    );
-
-    // Wire up ConfigurationService in the container for PluginManager to use
-    this.container.register("ConfigurationService", this.configurationService);
-
-    this.pluginManager = new PluginManager(this.container, {
-      workdir: this.workdir,
-    });
-
-    this.pluginScopeManager = new PluginScopeManager({
-      workdir: this.workdir,
-      configurationService: this.configurationService,
-      pluginManager: this.pluginManager,
-    });
-  }
-
-  /**
-   * Installs a plugin from a marketplace
-   */
-  async installPlugin(
-    pluginId: string,
-    scope?: Scope,
-  ): Promise<InstalledPlugin> {
-    const installedPlugin =
-      await this.marketplaceService.installPlugin(pluginId);
-    if (scope) {
-      await this.enablePlugin(pluginId, scope);
-    }
-    return installedPlugin;
-  }
-
-  /**
-   * Uninstalls a plugin and removes it from all configuration scopes
-   */
-  async uninstallPlugin(pluginId: string): Promise<void> {
-    await this.marketplaceService.uninstallPlugin(pluginId);
-    await this.pluginScopeManager.removePluginFromAllScopes(pluginId);
-  }
-
-  /**
-   * Enables a plugin in the specified scope. If no scope is provided, it tries to find
-   * the scope where the plugin is already configured, or defaults to "user".
-   */
-  async enablePlugin(pluginId: string, scope?: Scope): Promise<Scope> {
-    const targetScope = scope || this.findPluginScope(pluginId) || "user";
-    await this.pluginScopeManager.enablePlugin(targetScope, pluginId);
-    return targetScope;
-  }
-
-  /**
-   * Disables a plugin in the specified scope. If no scope is provided, it tries to find
-   * the scope where the plugin is already configured, or defaults to "user".
-   */
-  async disablePlugin(pluginId: string, scope?: Scope): Promise<Scope> {
-    const targetScope = scope || this.findPluginScope(pluginId) || "user";
-    await this.pluginScopeManager.disablePlugin(targetScope, pluginId);
-    return targetScope;
-  }
-
-  /**
-   * Updates an installed plugin to the latest version from its marketplace
-   */
-  async updatePlugin(pluginId: string): Promise<InstalledPlugin> {
-    return await this.marketplaceService.updatePlugin(pluginId);
-  }
-
-  /**
-   * Toggles auto-update for a marketplace
-   */
-  async toggleAutoUpdate(name: string, enabled: boolean): Promise<void> {
-    await this.marketplaceService.toggleAutoUpdate(name, enabled);
-  }
-
-  /**
-   * Lists all plugins from all registered marketplaces with their installation and enabled status
-   */
-  async listPlugins(): Promise<{
-    plugins: MarketplacePluginStatus[];
-    mergedEnabled: Record<string, boolean>;
-  }> {
-    const installedPlugins =
-      await this.marketplaceService.getInstalledPlugins();
-    const marketplaces = await this.marketplaceService.listMarketplaces();
-    const mergedEnabled = this.configurationService.getMergedEnabledPlugins(
-      this.workdir,
-    );
-
-    const allMarketplacePlugins: MarketplacePluginStatus[] = [];
-
-    for (const m of marketplaces) {
-      try {
-        const manifest = await this.marketplaceService.loadMarketplaceManifest(
-          this.marketplaceService.getMarketplacePath(m.source),
-        );
-        manifest.plugins.forEach((p) => {
-          const pluginId = `${p.name}@${m.name}`;
-          const installed = installedPlugins.plugins.find(
-            (ip) => ip.name === p.name && ip.marketplace === m.name,
-          );
-          allMarketplacePlugins.push({
-            ...p,
-            marketplace: m.name,
-            installed: !!installed,
-            version: installed?.version,
-            cachePath: installed?.cachePath,
-            projectPath: installed?.projectPath,
-            scope:
-              this.pluginScopeManager.findPluginScope(pluginId) || undefined,
-          });
-        });
-      } catch {
-        // Skip marketplaces that fail to load
-      }
-    }
-
-    return {
-      plugins: allMarketplacePlugins,
-      mergedEnabled,
-    };
-  }
-
-  /**
-   * Adds a new marketplace
-   */
-  async addMarketplace(
-    input: string,
-    scope: Scope = "user",
-  ): Promise<KnownMarketplace> {
-    return await this.marketplaceService.addMarketplace(input, scope);
-  }
-
-  /**
-   * Removes a marketplace by name
-   */
-  async removeMarketplace(name: string, scope?: Scope): Promise<void> {
-    await this.marketplaceService.removeMarketplace(name, scope);
-  }
-
-  /**
-   * Updates a specific marketplace or all marketplaces
-   */
-  async updateMarketplace(name?: string): Promise<void> {
-    await this.marketplaceService.updateMarketplace(name);
-  }
-
-  /**
-   * Lists all registered marketplaces
-   */
-  async listMarketplaces(): Promise<KnownMarketplace[]> {
-    return await this.marketplaceService.listMarketplaces();
-  }
-
-  /**
-   * Gets the registry of all installed plugins
-   */
-  async getInstalledPlugins(): Promise<InstalledPluginsRegistry> {
-    return await this.marketplaceService.getInstalledPlugins();
-  }
-
-  /**
-   * Gets the merged enabled state of all plugins across all scopes
-   */
-  getMergedEnabledPlugins(): Record<string, boolean> {
-    return this.configurationService.getMergedEnabledPlugins(this.workdir);
-  }
-
-  /**
-   * Loads a marketplace manifest from a local path
-   */
-  async loadMarketplaceManifest(
-    marketplacePath: string,
-  ): Promise<MarketplaceManifest> {
-    return await this.marketplaceService.loadMarketplaceManifest(
-      marketplacePath,
-    );
-  }
-
-  /**
-   * Resolves the local path for a marketplace
-   */
-  getMarketplacePath(marketplace: KnownMarketplace): string {
-    return this.marketplaceService.getMarketplacePath(marketplace.source);
-  }
-
-  /**
-   * Finds the scope where a plugin is currently enabled/disabled
-   */
-  findPluginScope(pluginId: string): Scope | null {
-    return this.pluginScopeManager.findPluginScope(pluginId);
-  }
-
-  /**
-   * Removes a plugin from the enabled plugins in the specified scope
-   */
-  async removeEnabledPlugin(scope: Scope, pluginId: string): Promise<void> {
-    await this.configurationService.removeEnabledPlugin(
-      this.workdir,
-      scope,
-      pluginId,
-    );
-  }
-}

package/src/core/session.ts

@@ -1,9 +0,0 @@
-export {
-  listSessions,
-  listAllSessions,
-  truncateContent,
-  loadSessionFromJsonl,
-  loadFullMessageThread,
-  deleteSession,
-} from "../services/session.js";
-export type { SessionMetadata, SessionData } from "../services/session.js";

package/src/index.ts

@@ -1,38 +0,0 @@
-// Export all services
-export * from "./core/session.js";
-export * from "./services/authService.js";
-
-// Export constants
-export * from "./constants/tools.js";
-
-// Export main agent
-export * from "./agent.js";
-export * from "./core/plugin.js";
-export * from "./managers/cronManager.js";
-export * from "./managers/messageQueue.js";
-
-// Export all utilities
-export * from "./utils/bashParser.js";
-export * from "./utils/convertMessagesForAPI.js";
-export * from "./utils/modelCapabilities.js";
-export * from "./utils/fileSearch.js";
-export * from "./utils/globalLogger.js";
-export * from "./utils/mcpUtils.js";
-export * from "./utils/messageOperations.js";
-export * from "./utils/notificationXml.js";
-export * from "./utils/path.js";
-export * from "./utils/promptHistory.js";
-export * from "./utils/stringUtils.js";
-export * from "./utils/customCommands.js";
-export * from "./utils/hookMatcher.js";
-export * from "./utils/tokenCalculation.js";
-export * from "./utils/gitUtils.js";
-export * from "./utils/nameGenerator.js";
-export * from "./utils/worktreeSession.js";
-export * from "./utils/worktreeUtils.js";
-export { loadMergedWaveConfig } from "./services/configurationService.js";
-export * from "./types/index.js";
-
-// Export tool building utilities
-export * from "./tools/buildTool.js";
-export type { ToolPlugin, ToolResult, ToolContext } from "./tools/types.js";

package/src/managers/MemoryRuleManager.ts

@@ -1,198 +0,0 @@
-import type { MemoryRule } from "../types/memoryRule.js";
-import { MemoryRuleService } from "../services/MemoryRuleService.js";
-import * as fs from "node:fs/promises";
-import * as path from "node:path";
-import * as os from "node:os";
-import { logger } from "../utils/globalLogger.js";
-
-import { Container } from "../utils/container.js";
-
-export interface MemoryRuleRegistryState {
-  /** All discovered rules, indexed by ID */
-  rules: Record<string, MemoryRule>;
-  /** Set of active rule IDs based on the current context */
-  activeRuleIds: Set<string>;
-}
-
-export interface MemoryRuleManagerOptions {
-  workdir: string;
-}
-
-export class MemoryRuleManager {
-  private state: MemoryRuleRegistryState = {
-    rules: {},
-    activeRuleIds: new Set(),
-  };
-
-  private workdir: string;
-  private service: MemoryRuleService;
-
-  constructor(
-    private container: Container,
-    options: MemoryRuleManagerOptions,
-  ) {
-    this.workdir = options.workdir;
-    this.service = new MemoryRuleService();
-  }
-
-  /**
-   * Scans .wave/rules and ~/.wave/rules for memory rule files.
-   */
-  async discoverRules(): Promise<void> {
-    const projectWaveRulesDir = path.join(this.workdir, ".wave", "rules");
-    const projectClaudeRulesDir = path.join(this.workdir, ".claude", "rules");
-    const userWaveRulesDir = path.join(os.homedir(), ".wave", "rules");
-    const userClaudeRulesDir = path.join(os.homedir(), ".claude", "rules");
-
-    logger.debug(`Scanning for modular memory rules...`);
-    logger.debug(`  User rules directory: ${userWaveRulesDir}`);
-    logger.debug(`  Project rules directory: ${projectWaveRulesDir}`);
-
-    const newRules: Record<string, MemoryRule> = {};
-
-    // Scan order: userClaude → userWave → projectClaude → projectWave
-    // Later writes override, so .wave takes priority over .claude
-    await this.scanDirectory(userClaudeRulesDir, "user", newRules);
-    await this.scanDirectory(userWaveRulesDir, "user", newRules);
-    await this.scanDirectory(projectClaudeRulesDir, "project", newRules);
-    await this.scanDirectory(projectWaveRulesDir, "project", newRules);
-
-    this.state.rules = newRules;
-    const ruleCount = Object.keys(newRules).length;
-    logger.debug(`Discovered ${ruleCount} modular memory rules`);
-  }
-
-  private async scanDirectory(
-    dir: string,
-    source: "project" | "user",
-    registry: Record<string, MemoryRule>,
-    visited: Set<string> = new Set(),
-  ): Promise<void> {
-    const realDir = await fs.realpath(dir).catch(() => dir);
-    if (visited.has(realDir)) {
-      logger.warn(
-        `Circular symlink detected or directory already visited: ${dir}`,
-      );
-      return;
-    }
-    visited.add(realDir);
-
-    try {
-      const entries = await fs.readdir(dir, { withFileTypes: true });
-      for (const entry of entries) {
-        const fullPath = path.join(dir, entry.name);
-        const isDirectory =
-          typeof entry.isDirectory === "function" ? entry.isDirectory() : false;
-        const isSymbolicLink =
-          typeof entry.isSymbolicLink === "function"
-            ? entry.isSymbolicLink()
-            : false;
-        const isFile =
-          typeof entry.isFile === "function" ? entry.isFile() : false;
-
-        if (isDirectory) {
-          await this.scanDirectory(fullPath, source, registry, visited);
-        } else if (isSymbolicLink) {
-          const stats = await fs.stat(fullPath);
-          if (stats.isDirectory()) {
-            await this.scanDirectory(fullPath, source, registry, visited);
-          } else if (stats.isFile() && entry.name.endsWith(".md")) {
-            await this.loadRuleFile(fullPath, source, registry);
-          }
-        } else if (isFile && entry.name.endsWith(".md")) {
-          await this.loadRuleFile(fullPath, source, registry);
-        } else if (
-          !isDirectory &&
-          !isSymbolicLink &&
-          !isFile &&
-          entry.name.endsWith(".md")
-        ) {
-          // Fallback for simple string arrays or incomplete mocks
-          await this.loadRuleFile(fullPath, source, registry);
-        }
-      }
-    } catch (error) {
-      // Ignore if directory doesn't exist
-      if ((error as NodeJS.ErrnoException).code !== "ENOENT") {
-        logger.error(`Error scanning memory rules directory ${dir}:`, error);
-      }
-    }
-  }
-
-  private async loadRuleFile(
-    filePath: string,
-    source: "project" | "user",
-    registry: Record<string, MemoryRule>,
-  ): Promise<void> {
-    try {
-      const content = await fs.readFile(filePath, "utf-8");
-      const rule = this.service.parseRule(content, filePath, source);
-
-      // Determine rulesRoot dynamically based on actual file path
-      let rulesRoot: string;
-      if (source === "project") {
-        if (filePath.includes(path.join(".claude", "rules"))) {
-          rulesRoot = path.join(this.workdir, ".claude", "rules");
-        } else {
-          rulesRoot = path.join(this.workdir, ".wave", "rules");
-        }
-      } else {
-        if (filePath.includes(path.join(".claude", "rules"))) {
-          rulesRoot = path.join(os.homedir(), ".claude", "rules");
-        } else {
-          rulesRoot = path.join(os.homedir(), ".wave", "rules");
-        }
-      }
-
-      const relativeId = path.relative(rulesRoot, filePath);
-      rule.id = relativeId;
-      registry[rule.id] = rule;
-      logger.debug(`Loaded memory rule: ${relativeId} from ${filePath}`);
-    } catch (error) {
-      logger.error(`Failed to parse memory rule at ${filePath}:`, error);
-    }
-  }
-
-  /**
-   * Returns the union of all active memory rules based on the provided file paths.
-   */
-  getActiveRules(filesInContext: string[]): MemoryRule[] {
-    const activeRules: MemoryRule[] = [];
-    for (const rule of Object.values(this.state.rules)) {
-      if (this.service.isRuleActive(rule, filesInContext, this.workdir)) {
-        activeRules.push(rule);
-      }
-    }
-    return activeRules;
-  }
-
-  /**
-   * Returns rules split by type:
-   * - unconditional: rules with no `paths` metadata (always active)
-   * - conditional: rules with `paths` metadata that match filesInContext
-   */
-  getActiveRulesSplit(filesInContext: string[]): {
-    unconditional: MemoryRule[];
-    conditional: MemoryRule[];
-  } {
-    const unconditional: MemoryRule[] = [];
-    const conditional: MemoryRule[] = [];
-    for (const rule of Object.values(this.state.rules)) {
-      if (!rule.metadata.paths || rule.metadata.paths.length === 0) {
-        unconditional.push(rule);
-      } else if (
-        this.service.isRuleActive(rule, filesInContext, this.workdir)
-      ) {
-        conditional.push(rule);
-      }
-    }
-    return { unconditional, conditional };
-  }
-
-  /**
-   * Reloads rules from disk.
-   */
-  async reload(): Promise<void> {
-    await this.discoverRules();
-  }
-}