wave-agent-sdk 0.0.8 → 0.0.10

package/src/services/memoryStore.ts

@@ -1,279 +0,0 @@
-/**
- * Memory Store Service
- *
- * Provides in-memory storage for file content with automatic updates.
- * Optimizes performance by keeping frequently accessed files in memory.
- */
-
-import { promises as fs } from "fs";
-import { EventEmitter } from "events";
-import type { Logger } from "../types/index.js";
-
-export interface MemoryStoreEntry {
-  content: string;
-  path: string;
-  lastModified: number;
-  isLoaded: boolean;
-}
-
-export interface MemoryStoreStats {
-  contentSize: number;
-  lastUpdated: number;
-  updateCount: number;
-  isLoaded: boolean;
-}
-
-export interface MemoryUpdateEvent {
-  path: string;
-  reason: "file_change" | "initial_load" | "manual_reload";
-  timestamp: number;
-  previousSize?: number;
-  newSize: number;
-}
-
-export class MemoryStoreService extends EventEmitter {
-  private store: Map<string, MemoryStoreEntry> = new Map();
-  private updateCounts: Map<string, number> = new Map();
-  private logger?: Logger;
-
-  constructor(logger?: Logger) {
-    super();
-    this.logger = logger;
-  }
-
-  /**
-   * Get content from memory store (loads from file if not loaded)
-   * Maps to FR-006: Keep AGENTS.md content in memory to avoid repeated reads
-   */
-  async getContent(path: string): Promise<string> {
-    const entry = this.store.get(path);
-
-    if (entry && entry.isLoaded) {
-      this.logger?.debug(`Live Config: Memory hit for ${path}`);
-      return entry.content;
-    }
-
-    // Load from file if not in memory
-    return await this.loadFromFile(path, "initial_load");
-  }
-
-  /**
-   * Update memory content from file
-   * Maps to FR-007: Update memory content when file changes
-   */
-  async updateContent(path: string): Promise<void> {
-    const previousEntry = this.store.get(path);
-    const previousSize = previousEntry?.content.length || 0;
-
-    await this.loadFromFile(path, "file_change", previousSize);
-  }
-
-  /**
-   * Get memory store statistics
-   * For monitoring and debugging
-   */
-  getStats(path?: string): MemoryStoreStats {
-    if (path) {
-      const entry = this.store.get(path);
-      const updateCount = this.updateCounts.get(path) || 0;
-
-      return {
-        contentSize: entry?.content.length || 0,
-        lastUpdated: entry?.lastModified || 0,
-        updateCount,
-        isLoaded: entry?.isLoaded || false,
-      };
-    }
-
-    // Return aggregate stats for all entries
-    let totalSize = 0;
-    let latestUpdate = 0;
-    let totalUpdates = 0;
-    let anyLoaded = false;
-
-    for (const [entryPath, entry] of this.store) {
-      totalSize += entry.content.length;
-      latestUpdate = Math.max(latestUpdate, entry.lastModified);
-      totalUpdates += this.updateCounts.get(entryPath) || 0;
-      anyLoaded = anyLoaded || entry.isLoaded;
-    }
-
-    return {
-      contentSize: totalSize,
-      lastUpdated: latestUpdate,
-      updateCount: totalUpdates,
-      isLoaded: anyLoaded,
-    };
-  }
-
-  /**
-   * Check if content is loaded in memory
-   * For status checking
-   */
-  isLoaded(path: string): boolean {
-    const entry = this.store.get(path);
-    return entry?.isLoaded || false;
-  }
-
-  /**
-   * Manually reload content from file
-   * For force refresh scenarios
-   */
-  async reloadContent(path: string): Promise<void> {
-    const previousEntry = this.store.get(path);
-    const previousSize = previousEntry?.content.length || 0;
-
-    await this.loadFromFile(path, "manual_reload", previousSize);
-  }
-
-  /**
-   * Remove content from memory store
-   * For cleanup when file is deleted
-   */
-  removeContent(path: string): boolean {
-    const removed = this.store.delete(path);
-    this.updateCounts.delete(path);
-
-    if (removed) {
-      this.logger?.info(`Live Config: Removed ${path} from memory store`);
-    }
-
-    return removed;
-  }
-
-  /**
-   * Clear all content from memory store
-   * For cleanup and testing
-   */
-  clear(): void {
-    const pathCount = this.store.size;
-    this.store.clear();
-    this.updateCounts.clear();
-
-    if (pathCount > 0) {
-      this.logger?.info(
-        `Live Config: Cleared ${pathCount} entries from memory store`,
-      );
-    }
-  }
-
-  /**
-   * Get all stored paths
-   * For monitoring and debugging
-   */
-  getStoredPaths(): string[] {
-    return Array.from(this.store.keys());
-  }
-
-  /**
-   * Check if file exists and is accessible
-   */
-  async fileExists(path: string): Promise<boolean> {
-    try {
-      await fs.access(path);
-      return true;
-    } catch {
-      return false;
-    }
-  }
-
-  private async loadFromFile(
-    path: string,
-    reason: MemoryUpdateEvent["reason"],
-    previousSize?: number,
-  ): Promise<string> {
-    try {
-      // Check if file exists
-      const exists = await this.fileExists(path);
-      if (!exists) {
-        // Handle file deletion gracefully
-        const entry: MemoryStoreEntry = {
-          content: "",
-          path,
-          lastModified: Date.now(),
-          isLoaded: true,
-        };
-
-        this.store.set(path, entry);
-        this.incrementUpdateCount(path);
-
-        this.logger?.info(
-          `Live Config: File ${path} not found, storing empty content`,
-        );
-
-        this.emitUpdateEvent(path, reason, previousSize, 0);
-        return "";
-      }
-
-      // Read file content
-      const content = await fs.readFile(path, "utf-8");
-      const stats = await fs.stat(path);
-
-      const entry: MemoryStoreEntry = {
-        content,
-        path,
-        lastModified: stats.mtime.getTime(),
-        isLoaded: true,
-      };
-
-      this.store.set(path, entry);
-      this.incrementUpdateCount(path);
-
-      this.logger?.info(
-        `Live Config: Loaded ${content.length} bytes from ${path} into memory`,
-      );
-
-      this.emitUpdateEvent(path, reason, previousSize, content.length);
-      return content;
-    } catch (error) {
-      const errorMessage = `Live Config: Failed to load ${path} into memory: ${(error as Error).message}`;
-      this.logger?.error(errorMessage);
-
-      // Return existing content if available, otherwise empty string
-      const existingEntry = this.store.get(path);
-      if (existingEntry?.isLoaded) {
-        this.logger?.warn(
-          `Live Config: Using cached content for ${path} due to read error`,
-        );
-        return existingEntry.content;
-      }
-
-      // Store empty content as fallback
-      const entry: MemoryStoreEntry = {
-        content: "",
-        path,
-        lastModified: Date.now(),
-        isLoaded: true,
-      };
-
-      this.store.set(path, entry);
-      this.emitUpdateEvent(path, reason, previousSize, 0);
-      return "";
-    }
-  }
-
-  private incrementUpdateCount(path: string): void {
-    const current = this.updateCounts.get(path) || 0;
-    this.updateCounts.set(path, current + 1);
-  }
-
-  private emitUpdateEvent(
-    path: string,
-    reason: MemoryUpdateEvent["reason"],
-    previousSize: number | undefined,
-    newSize: number,
-  ): void {
-    const event: MemoryUpdateEvent = {
-      path,
-      reason,
-      timestamp: Date.now(),
-      previousSize,
-      newSize,
-    };
-
-    this.emit("memoryUpdate", event);
-    this.logger?.debug(
-      `Live Config: Memory update event for ${path}: ${reason}`,
-    );
-  }
-}

package/src/types/memoryStore.ts

@@ -1,94 +0,0 @@
-/**
- * Memory Store Type Definitions
- *
- * Provides TypeScript types for in-memory file storage system,
- * enabling optimized access to frequently read files like AGENTS.md.
- */
-
-export interface MemoryStore {
-  content: string; // Current file content in memory
-  lastModified: number; // File modification timestamp
-  path: string; // Absolute file path
-  isLoaded: boolean; // Whether content has been loaded
-}
-
-export interface MemoryStoreEntry {
-  content: string;
-  path: string;
-  lastModified: number;
-  isLoaded: boolean;
-}
-
-export interface MemoryStoreStats {
-  contentSize: number;
-  lastUpdated: number;
-  updateCount: number;
-  isLoaded: boolean;
-}
-
-export interface MemoryUpdateEvent {
-  path: string;
-  reason: "file_change" | "initial_load" | "manual_reload";
-  timestamp: number;
-  previousSize?: number;
-  newSize: number;
-}
-
-/**
- * Memory Store Service Interface
- * Maps to FR-006, FR-007: Memory storage and updates
- */
-export interface MemoryStoreService {
-  /**
-   * Get content from memory store (loads from file if not loaded)
-   * Maps to FR-006: Keep AGENTS.md content in memory to avoid repeated reads
-   */
-  getContent(path: string): Promise<string>;
-
-  /**
-   * Update memory content from file
-   * Maps to FR-007: Update memory content when file changes
-   */
-  updateContent(path: string): Promise<void>;
-
-  /**
-   * Get memory store statistics
-   * For monitoring and debugging
-   */
-  getStats(path?: string): MemoryStoreStats;
-
-  /**
-   * Check if content is loaded in memory
-   * For status checking
-   */
-  isLoaded(path: string): boolean;
-
-  /**
-   * Manually reload content from file
-   * For force refresh scenarios
-   */
-  reloadContent(path: string): Promise<void>;
-
-  /**
-   * Remove content from memory store
-   * For cleanup when file is deleted
-   */
-  removeContent(path: string): boolean;
-
-  /**
-   * Clear all content from memory store
-   * For cleanup and testing
-   */
-  clear(): void;
-
-  /**
-   * Get all stored paths
-   * For monitoring and debugging
-   */
-  getStoredPaths(): string[];
-
-  /**
-   * Check if file exists and is accessible
-   */
-  fileExists(path: string): Promise<boolean>;
-}

package/src/utils/configResolver.ts

@@ -1,302 +0,0 @@
-/**
- * Configuration resolver utilities for Agent Constructor Configuration
- * Resolves configuration from constructor arguments with environment fallbacks
- * Supports live configuration updates and cache invalidation
- */
-
-import {
-  GatewayConfig,
-  ModelConfig,
-  ConfigurationError,
-  CONFIG_ERRORS,
-} from "../types/index.js";
-import { DEFAULT_TOKEN_LIMIT } from "./constants.js";
-import { loadMergedWaveConfig } from "../services/hook.js";
-import { getGlobalLogger } from "./globalLogger.js";
-
-/**
- * Live configuration cache and invalidation support
- */
-interface ConfigurationCache {
-  workdir?: string;
-  lastUpdated: number;
-  environmentVars: Record<string, string>;
-  isValid: boolean;
-}
-
-let configCache: ConfigurationCache | null = null;
-
-/**
- * Initialize configuration cache with current environment variables from settings.json
- */
-function initializeConfigurationCache(workdir?: string): void {
-  try {
-    const waveConfig = workdir ? loadMergedWaveConfig(workdir) : null;
-    const envVars = waveConfig?.env || {};
-
-    configCache = {
-      workdir,
-      lastUpdated: Date.now(),
-      environmentVars: envVars,
-      isValid: true,
-    };
-
-    const logger = getGlobalLogger();
-    logger?.debug(
-      `Live Config: Configuration cache initialized with ${Object.keys(envVars).length} environment variables`,
-    );
-  } catch (error) {
-    const logger = getGlobalLogger();
-    logger?.error(
-      `Live Config: Failed to initialize configuration cache: ${(error as Error).message}`,
-    );
-    configCache = {
-      workdir,
-      lastUpdated: Date.now(),
-      environmentVars: {},
-      isValid: false,
-    };
-  }
-}
-
-/**
- * Get current environment variable value with live configuration support
- */
-function getCurrentEnvironmentValue(
-  key: string,
-  workdir?: string,
-): string | undefined {
-  // Initialize cache if not present or workdir changed
-  if (!configCache || configCache.workdir !== workdir) {
-    initializeConfigurationCache(workdir);
-  }
-
-  // Use cached environment variables if available and valid
-  if (configCache && configCache.isValid) {
-    const cachedValue = configCache.environmentVars[key];
-    if (cachedValue !== undefined) {
-      const logger = getGlobalLogger();
-      logger?.debug(
-        `Live Config: Using cached environment variable ${key}=${cachedValue}`,
-      );
-      return cachedValue;
-    }
-  }
-
-  // Fallback to process environment
-  return process.env[key];
-}
-
-export class ConfigResolver {
-  /**
-   * Resolves gateway configuration from constructor args and environment with live config support
-   * @param apiKey - API key from constructor (optional)
-   * @param baseURL - Base URL from constructor (optional)
-   * @param workdir - Working directory for loading live configuration (optional)
-   * @returns Resolved gateway configuration
-   * @throws ConfigurationError if required configuration is missing after fallbacks
-   */
-  static resolveGatewayConfig(
-    apiKey?: string,
-    baseURL?: string,
-    workdir?: string,
-  ): GatewayConfig {
-    // Resolve API key: constructor > live configuration > environment variable
-    // Note: Explicitly provided empty strings should be treated as invalid, not fall back to env
-    let resolvedApiKey: string;
-    if (apiKey !== undefined) {
-      resolvedApiKey = apiKey;
-    } else {
-      resolvedApiKey = getCurrentEnvironmentValue("AIGW_TOKEN", workdir) || "";
-    }
-
-    if (!resolvedApiKey && apiKey === undefined) {
-      const envValue = getCurrentEnvironmentValue("AIGW_TOKEN", workdir);
-      throw new ConfigurationError(CONFIG_ERRORS.MISSING_API_KEY, "apiKey", {
-        constructor: apiKey,
-        environment: envValue,
-      });
-    }
-
-    if (resolvedApiKey.trim() === "") {
-      throw new ConfigurationError(
-        CONFIG_ERRORS.EMPTY_API_KEY,
-        "apiKey",
-        resolvedApiKey,
-      );
-    }
-
-    // Resolve base URL: constructor > live configuration > environment variable
-    // Note: Explicitly provided empty strings should be treated as invalid, not fall back to env
-    let resolvedBaseURL: string;
-    if (baseURL !== undefined) {
-      resolvedBaseURL = baseURL;
-    } else {
-      resolvedBaseURL = getCurrentEnvironmentValue("AIGW_URL", workdir) || "";
-    }
-
-    if (!resolvedBaseURL && baseURL === undefined) {
-      const envValue = getCurrentEnvironmentValue("AIGW_URL", workdir);
-      throw new ConfigurationError(CONFIG_ERRORS.MISSING_BASE_URL, "baseURL", {
-        constructor: baseURL,
-        environment: envValue,
-      });
-    }
-
-    if (resolvedBaseURL.trim() === "") {
-      throw new ConfigurationError(
-        CONFIG_ERRORS.EMPTY_BASE_URL,
-        "baseURL",
-        resolvedBaseURL,
-      );
-    }
-
-    return {
-      apiKey: resolvedApiKey,
-      baseURL: resolvedBaseURL,
-    };
-  }
-
-  /**
-   * Resolves model configuration with fallbacks and live config support
-   * @param agentModel - Agent model from constructor (optional)
-   * @param fastModel - Fast model from constructor (optional)
-   * @param workdir - Working directory for loading live configuration (optional)
-   * @returns Resolved model configuration with defaults
-   */
-  static resolveModelConfig(
-    agentModel?: string,
-    fastModel?: string,
-    workdir?: string,
-  ): ModelConfig {
-    // Default values as per data-model.md
-    const DEFAULT_AGENT_MODEL = "claude-sonnet-4-20250514";
-    const DEFAULT_FAST_MODEL = "gemini-2.5-flash";
-
-    // Resolve agent model: constructor > live configuration > environment > default
-    const resolvedAgentModel =
-      agentModel ||
-      getCurrentEnvironmentValue("AIGW_MODEL", workdir) ||
-      DEFAULT_AGENT_MODEL;
-
-    // Resolve fast model: constructor > live configuration > environment > default
-    const resolvedFastModel =
-      fastModel ||
-      getCurrentEnvironmentValue("AIGW_FAST_MODEL", workdir) ||
-      DEFAULT_FAST_MODEL;
-
-    const logger = getGlobalLogger();
-    logger?.debug(
-      `Live Config: Resolved models - agent: ${resolvedAgentModel}, fast: ${resolvedFastModel}`,
-    );
-
-    return {
-      agentModel: resolvedAgentModel,
-      fastModel: resolvedFastModel,
-    };
-  }
-
-  /**
-   * Resolves token limit with fallbacks and live config support
-   * @param constructorLimit - Token limit from constructor (optional)
-   * @param workdir - Working directory for loading live configuration (optional)
-   * @returns Resolved token limit
-   */
-  static resolveTokenLimit(
-    constructorLimit?: number,
-    workdir?: string,
-  ): number {
-    // If constructor value provided, use it
-    if (constructorLimit !== undefined) {
-      return constructorLimit;
-    }
-
-    // Try live configuration then environment variable
-    const envTokenLimit = getCurrentEnvironmentValue("TOKEN_LIMIT", workdir);
-    if (envTokenLimit) {
-      const parsed = parseInt(envTokenLimit, 10);
-      if (!isNaN(parsed)) {
-        const logger = getGlobalLogger();
-        logger?.debug(
-          `Live Config: Resolved token limit from configuration: ${parsed}`,
-        );
-        return parsed;
-      }
-    }
-
-    // Use default
-    return DEFAULT_TOKEN_LIMIT;
-  }
-
-  /**
-   * Invalidate configuration cache to force reload from settings.json
-   * @param workdir - Working directory to invalidate cache for (optional)
-   */
-  static invalidateCache(workdir?: string): void {
-    if (
-      configCache &&
-      (workdir === undefined || configCache.workdir === workdir)
-    ) {
-      const logger = getGlobalLogger();
-      logger?.info(
-        `Live Config: Configuration cache invalidated for workdir: ${workdir || "global"}`,
-      );
-      configCache = null;
-    }
-  }
-
-  /**
-   * Refresh configuration cache by reloading from settings.json
-   * @param workdir - Working directory to refresh cache for (optional)
-   */
-  static refreshCache(workdir?: string): void {
-    const logger = getGlobalLogger();
-    logger?.info(
-      `Live Config: Refreshing configuration cache for workdir: ${workdir || "global"}`,
-    );
-    initializeConfigurationCache(workdir);
-  }
-
-  /**
-   * Get current cache status for monitoring
-   * @returns Cache information or null if no cache
-   */
-  static getCacheStatus(): {
-    workdir?: string;
-    lastUpdated: number;
-    envVarCount: number;
-    isValid: boolean;
-  } | null {
-    if (!configCache) {
-      return null;
-    }
-
-    return {
-      workdir: configCache.workdir,
-      lastUpdated: configCache.lastUpdated,
-      envVarCount: Object.keys(configCache.environmentVars).length,
-      isValid: configCache.isValid,
-    };
-  }
-}
-
-/**
- * Static configuration resolver instance
- * Implements ConfigurationResolver interface from types.ts with backward compatibility
- */
-export const configResolver = {
-  resolveGatewayConfig: (apiKey?: string, baseURL?: string, workdir?: string) =>
-    ConfigResolver.resolveGatewayConfig(apiKey, baseURL, workdir),
-  resolveModelConfig: (
-    agentModel?: string,
-    fastModel?: string,
-    workdir?: string,
-  ) => ConfigResolver.resolveModelConfig(agentModel, fastModel, workdir),
-  resolveTokenLimit: (constructorLimit?: number, workdir?: string) =>
-    ConfigResolver.resolveTokenLimit(constructorLimit, workdir),
-
-  // Live configuration management methods
-  invalidateCache: ConfigResolver.invalidateCache,
-  refreshCache: ConfigResolver.refreshCache,
-  getCacheStatus: ConfigResolver.getCacheStatus,
-};