wave-agent-sdk 1.0.4 → 1.0.6

package/src/utils/configPaths.ts

@@ -1,220 +0,0 @@
-/**
- * Configuration Path Utilities
- *
- * Centralized utilities for resolving Wave configuration file paths.
- * Supports both regular settings.json and local settings.local.json with proper priority.
- *
- * Priority system:
- * - User configs: ~/.wave/settings.json
- * - Local configs: {workdir}/.wave/settings.local.json > {workdir}/.wave/settings.json
- * - Project configs override user configs (existing behavior)
- */
-
-import { join, dirname } from "path";
-import { homedir } from "os";
-import { existsSync } from "fs";
-import { fileURLToPath } from "url";
-import { findUpSync } from "find-up";
-
-const __filename = fileURLToPath(import.meta.url);
-const __dirname = dirname(__filename);
-
-/**
- * Resolve the package root directory by finding the nearest package.json.
- * Works correctly even when bundled (e.g. esbuild into a VS Code extension),
- * as long as vendor/ and builtin/ remain alongside package.json on disk.
- */
-let _packageRoot: string | undefined;
-export function getPackageRoot(): string {
-  if (_packageRoot) return _packageRoot;
-  const pkgPath = findUpSync("package.json", { cwd: __dirname });
-  if (pkgPath) {
-    _packageRoot = dirname(pkgPath);
-    return _packageRoot;
-  }
-  // Fallback: relative to this file (works during development)
-  _packageRoot = join(__dirname, "..", "..");
-  return _packageRoot;
-}
-
-/**
- * Get the builtin skills directory path
- */
-export function getBuiltinSkillsDir(): string {
-  return join(getPackageRoot(), "builtin", "skills");
-}
-
-/**
- * Get the builtin subagents directory path
- */
-export function getBuiltinSubagentsDir(): string {
-  return join(getPackageRoot(), "builtin", "subagents");
-}
-
-/**
- * Get the builtin plugins directory path
- */
-export function getBuiltinPluginsDir(): string {
-  return join(getPackageRoot(), "builtin", "plugins");
-}
-
-/**
- * Get the user-specific configuration file path (legacy function)
- * @deprecated Use getUserConfigPaths() for better priority support
- */
-export function getUserConfigPath(): string {
-  return join(homedir(), ".wave", "settings.json");
-}
-
-/**
- * Get the project-specific configuration file path (legacy function)
- * @deprecated Use getProjectConfigPaths() for better priority support
- */
-export function getProjectConfigPath(workdir: string): string {
-  return join(workdir, ".wave", "settings.json");
-}
-
-/**
- * Get the user-specific configuration file paths in priority order
- * Returns array with .json only
- */
-export function getUserConfigPaths(): string[] {
-  const baseDir = join(homedir(), ".wave");
-  return [join(baseDir, "settings.json")];
-}
-
-/**
- * Get the plugins directory path
- */
-export function getPluginsDir(): string {
-  return join(homedir(), ".wave", "plugins");
-}
-
-/**
- * Get the local configuration file paths in priority order
- * Returns array with .local.json first, then .json
- */
-export function getProjectConfigPaths(workdir: string): string[] {
-  const baseDir = join(workdir, ".wave");
-  return [join(baseDir, "settings.local.json"), join(baseDir, "settings.json")];
-}
-
-/**
- * Get all configuration file paths (user and project) in priority order
- * Useful for comprehensive configuration detection
- */
-export function getAllConfigPaths(workdir: string): {
-  userPaths: string[];
-  projectPaths: string[];
-  builtinPaths: string[];
-  allPaths: string[];
-} {
-  const userPaths = getUserConfigPaths();
-  const projectPaths = getProjectConfigPaths(workdir);
-  const builtinPaths = [join(getBuiltinSkillsDir(), "settings", "SKILL.md")];
-
-  return {
-    userPaths,
-    projectPaths,
-    builtinPaths,
-    allPaths: [...userPaths, ...projectPaths, ...builtinPaths],
-  };
-}
-
-/**
- * Get existing configuration file paths
- * Returns only the paths that actually exist on the filesystem
- */
-export function getExistingConfigPaths(workdir: string): {
-  userPaths: string[];
-  projectPaths: string[];
-  builtinPaths: string[];
-  existingPaths: string[];
-} {
-  const allPaths = getAllConfigPaths(workdir);
-
-  const existingUserPaths = allPaths.userPaths.filter(existsSync);
-  const existingProjectPaths = allPaths.projectPaths.filter(existsSync);
-  const existingBuiltinPaths = allPaths.builtinPaths.filter(existsSync);
-  const allExistingPaths = allPaths.allPaths.filter(existsSync);
-
-  return {
-    userPaths: existingUserPaths,
-    projectPaths: existingProjectPaths,
-    builtinPaths: existingBuiltinPaths,
-    existingPaths: allExistingPaths,
-  };
-}
-
-/**
- * Get the first existing configuration file path with the specified priority
- * @param paths Array of paths in priority order
- * @returns The first path that exists, or undefined if none exist
- */
-export function getFirstExistingPath(paths: string[]): string | undefined {
-  return paths.find((path) => existsSync(path));
-}
-
-/**
- * Get effective configuration paths (the ones that would actually be used)
- * Returns the highest priority existing path for each category
- */
-export function getEffectiveConfigPaths(workdir: string): {
-  userPath?: string;
-  projectPath?: string;
-  effectivePath?: string; // The path that takes final precedence
-} {
-  const userPaths = getUserConfigPaths();
-  const projectPaths = getProjectConfigPaths(workdir);
-
-  const userPath = getFirstExistingPath(userPaths);
-  const projectPath = getFirstExistingPath(projectPaths);
-
-  // Project path takes precedence over user path if both exist
-  const effectivePath = projectPath || userPath;
-
-  return {
-    userPath,
-    projectPath,
-    effectivePath,
-  };
-}
-
-/**
- * Check if any configuration files exist
- */
-export function hasAnyConfig(workdir: string): boolean {
-  const { existingPaths } = getExistingConfigPaths(workdir);
-  return existingPaths.length > 0;
-}
-
-/**
- * Get configuration information for debugging and monitoring
- */
-export function getConfigurationInfo(workdir: string): {
-  hasUser: boolean;
-  hasProject: boolean;
-  paths: string[];
-  userPaths: string[];
-  projectPaths: string[];
-  existingPaths: string[];
-  effectivePaths: {
-    userPath?: string;
-    projectPath?: string;
-    effectivePath?: string;
-  };
-} {
-  const allPaths = getAllConfigPaths(workdir);
-  const existingPaths = getExistingConfigPaths(workdir);
-  const effectivePaths = getEffectiveConfigPaths(workdir);
-
-  return {
-    hasUser: existingPaths.userPaths.length > 0,
-    hasProject: existingPaths.projectPaths.length > 0,
-    paths: allPaths.allPaths,
-    userPaths: allPaths.userPaths,
-    projectPaths: allPaths.projectPaths,
-    existingPaths: existingPaths.existingPaths,
-    effectivePaths,
-  };
-}

package/src/utils/configValidator.ts

@@ -1,100 +0,0 @@
-/**
- * Configuration validator utilities for Agent Constructor Configuration
- * Validates configuration values for correctness and security
- */
-
-import {
-  GatewayConfig,
-  ConfigurationError,
-  CONFIG_ERRORS,
-} from "../types/index.js";
-
-export class ConfigValidator {
-  /**
-   * Validates gateway configuration
-   * @param config - Configuration to validate
-   * @throws ConfigurationError with descriptive message if invalid
-   */
-  static validateGatewayConfig(config: GatewayConfig): void {
-    // Validate API key if provided
-    if (config.apiKey !== undefined) {
-      if (typeof config.apiKey !== "string") {
-        throw new ConfigurationError(
-          "API key must be a string if provided.",
-          "apiKey",
-          config.apiKey,
-        );
-      }
-    }
-
-    // Validate base URL if provided
-    if (config.baseURL) {
-      if (typeof config.baseURL !== "string") {
-        throw new ConfigurationError(
-          "Base URL must be a string if provided.",
-          "baseURL",
-          config.baseURL,
-        );
-      }
-
-      if (config.baseURL.trim() === "") {
-        throw new ConfigurationError(
-          CONFIG_ERRORS.EMPTY_BASE_URL,
-          "baseURL",
-          config.baseURL,
-        );
-      }
-
-      // Basic URL format validation
-      try {
-        new URL(config.baseURL);
-      } catch {
-        throw new ConfigurationError(
-          `Base URL must be a valid URL format. Received: ${config.baseURL}`,
-          "baseURL",
-          config.baseURL,
-        );
-      }
-    }
-  }
-
-  /**
-   * Validates token limit value
-   * @param maxInputTokens - Token limit to validate
-   * @throws ConfigurationError if invalid
-   */
-  static validateMaxInputTokens(maxInputTokens: number): void {
-    if (typeof maxInputTokens !== "number") {
-      throw new ConfigurationError(
-        CONFIG_ERRORS.INVALID_WAVE_MAX_INPUT_TOKENS,
-        "maxInputTokens",
-        maxInputTokens,
-      );
-    }
-
-    if (!Number.isInteger(maxInputTokens)) {
-      throw new ConfigurationError(
-        CONFIG_ERRORS.INVALID_WAVE_MAX_INPUT_TOKENS,
-        "maxInputTokens",
-        maxInputTokens,
-      );
-    }
-
-    if (maxInputTokens <= 0) {
-      throw new ConfigurationError(
-        CONFIG_ERRORS.INVALID_WAVE_MAX_INPUT_TOKENS,
-        "maxInputTokens",
-        maxInputTokens,
-      );
-    }
-  }
-}
-
-/**
- * Static configuration validator instance
- * Implements ConfigurationValidator interface from types.ts
- */
-export const configValidator = {
-  validateGatewayConfig: ConfigValidator.validateGatewayConfig,
-  validateMaxInputTokens: ConfigValidator.validateMaxInputTokens,
-};

package/src/utils/constants.ts

@@ -1,39 +0,0 @@
-/**
- * Application constants definition
- */
-
-import path from "path";
-import os from "os";
-
-/**
- * Application data storage directory
- * Used to store debug logs, command history and other data
- */
-export const DATA_DIRECTORY = path.join(os.homedir(), ".wave");
-
-/**
- * Prompt history file path
- */
-export const PROMPT_HISTORY_FILE = path.join(DATA_DIRECTORY, "history.jsonl");
-
-/**
- * Error log directory path
- */
-export const ERROR_LOG_DIRECTORY = path.join(DATA_DIRECTORY, "error-logs");
-
-/**
- * User-level memory file path
- */
-export const USER_MEMORY_FILE = path.join(DATA_DIRECTORY, "AGENTS.md");
-
-/**
- * AI related constants
- */
-export const DEFAULT_WAVE_MAX_INPUT_TOKENS = 200000; // Default token limit
-export const DEFAULT_WAVE_MAX_OUTPUT_TOKENS = 32000; // Default output token limit (aligned with Claude Code)
-
-/**
- * Default server URL for SSO authentication.
- * Overridden by WAVE_SERVER_URL env var or programmatic AgentOptions.serverUrl.
- */
-export const DEFAULT_SERVER_URL = "https://codechat.codewave.163.com";

package/src/utils/container.ts

@@ -1,92 +0,0 @@
-/**
- * A simple Dependency Injection container to manage late-binding dependencies
- * and resolve circular references.
- */
-export class Container {
-  private services = new Map<string, unknown>();
-  private factories = new Map<string, () => unknown>();
-  private parent?: Container;
-
-  constructor(parent?: Container) {
-    this.parent = parent;
-  }
-
-  /**
-   * Create a child container that inherits from this container
-   */
-  createChild(): Container {
-    return new Container(this);
-  }
-
-  /**
-   * Register a singleton instance
-   */
-  register<T>(token: string, instance: T): void {
-    this.services.set(token, instance);
-  }
-
-  /**
-   * Register a factory function for lazy resolution
-   */
-  provide<T>(token: string, factory: () => T): void {
-    this.factories.set(token, factory);
-  }
-
-  /**
-   * Resolve a service by token
-   */
-  get<T>(token: string): T | undefined {
-    if (this.services.has(token)) {
-      return this.services.get(token) as T;
-    }
-
-    const factory = this.factories.get(token);
-    if (factory) {
-      const instance = factory() as T;
-      this.services.set(token, instance);
-      return instance;
-    }
-
-    if (this.parent) {
-      return this.parent.get<T>(token);
-    }
-
-    return undefined;
-  }
-
-  /**
-   * Check if a service exists
-   */
-  has(token: string): boolean {
-    return (
-      this.services.has(token) ||
-      this.factories.has(token) ||
-      (this.parent ? this.parent.has(token) : false)
-    );
-  }
-}
-
-// Example usage for ToolManager:
-/*
-const container = new Container();
-
-// 1. Provide managers lazily
-container.provide('SubagentManager', () => new SubagentManager(...));
-container.provide('SkillManager', () => new SkillManager(...));
-
-// 2. ToolManager can now resolve them only when needed (e.g., in execute)
-class ToolManager {
-  constructor(private container: Container) {}
-
-  async execute(name: string, args: any, context: any) {
-    const enhancedContext = {
-      ...context,
-      subagentManager: this.container.has('SubagentManager') 
-        ? this.container.get('SubagentManager') 
-        : undefined,
-      // ...
-    };
-    // ...
-  }
-}
-*/