@dollhousemcp/mcp-server 1.5.2 → 1.6.0

package/dist/utils/ToolCache.d.ts

@@ -0,0 +1,82 @@
+/**
+ * Generic caching utility for tool discovery with TTL and memory limits
+ */
+import { Tool } from "@modelcontextprotocol/sdk/types.js";
+export interface CacheEntry<T> {
+    value: T;
+    timestamp: number;
+    hits: number;
+}
+export interface CacheStats {
+    hits: number;
+    misses: number;
+    size: number;
+    maxSize: number;
+    hitRate: number;
+}
+/**
+ * Generic cache with TTL support and memory limit protection
+ */
+export declare class ToolCache<T = any> {
+    private cache;
+    private readonly maxEntries;
+    private readonly ttlMs;
+    private stats;
+    constructor(maxEntries?: number, ttlMinutes?: number);
+    /**
+     * Get cached value if valid, otherwise return undefined
+     */
+    get(key: string): T | undefined;
+    /**
+     * Set cached value with automatic memory limit enforcement
+     */
+    set(key: string, value: T): void;
+    /**
+     * Check if key exists and is not expired
+     */
+    has(key: string): boolean;
+    /**
+     * Clear specific cache entry
+     */
+    delete(key: string): boolean;
+    /**
+     * Clear all cached entries
+     */
+    clear(): void;
+    /**
+     * Get cache statistics
+     */
+    getStats(): CacheStats;
+    /**
+     * Remove oldest entries when cache is full
+     */
+    private evictOldest;
+    /**
+     * Clean up expired entries (can be called periodically)
+     */
+    cleanup(): number;
+}
+/**
+ * Specialized cache for MCP Tool discovery results
+ */
+export declare class ToolDiscoveryCache extends ToolCache<Tool[]> {
+    private static readonly CACHE_KEY;
+    constructor();
+    /**
+     * Get cached tool list
+     */
+    getToolList(): Tool[] | undefined;
+    /**
+     * Cache tool list
+     */
+    setToolList(tools: Tool[]): void;
+    /**
+     * Invalidate cached tool list
+     */
+    invalidateToolList(): void;
+    /**
+     * Log performance metrics
+     */
+    logPerformance(): void;
+}
+//# sourceMappingURL=ToolCache.d.ts.map

package/dist/utils/ToolCache.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ToolCache.d.ts","sourceRoot":"","sources":["../../src/utils/ToolCache.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,OAAO,EAAE,IAAI,EAAE,MAAM,oCAAoC,CAAC;AAG1D,MAAM,WAAW,UAAU,CAAC,CAAC;IAC3B,KAAK,EAAE,CAAC,CAAC;IACT,SAAS,EAAE,MAAM,CAAC;IAClB,IAAI,EAAE,MAAM,CAAC;CACd;AAED,MAAM,WAAW,UAAU;IACzB,IAAI,EAAE,MAAM,CAAC;IACb,MAAM,EAAE,MAAM,CAAC;IACf,IAAI,EAAE,MAAM,CAAC;IACb,OAAO,EAAE,MAAM,CAAC;IAChB,OAAO,EAAE,MAAM,CAAC;CACjB;AAED;;GAEG;AACH,qBAAa,SAAS,CAAC,CAAC,GAAG,GAAG;IAC5B,OAAO,CAAC,KAAK,CAAyC;IACtD,OAAO,CAAC,QAAQ,CAAC,UAAU,CAAS;IACpC,OAAO,CAAC,QAAQ,CAAC,KAAK,CAAS;IAC/B,OAAO,CAAC,KAAK,CAGX;gBAEU,UAAU,GAAE,MAAY,EAAE,UAAU,GAAE,MAAU;IAK5D;;OAEG;IACH,GAAG,CAAC,GAAG,EAAE,MAAM,GAAG,CAAC,GAAG,SAAS;IAwB/B;;OAEG;IACH,GAAG,CAAC,GAAG,EAAE,MAAM,EAAE,KAAK,EAAE,CAAC,GAAG,IAAI;IAiBhC;;OAEG;IACH,GAAG,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO;IAIzB;;OAEG;IACH,MAAM,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO;IAQ5B;;OAEG;IACH,KAAK,IAAI,IAAI;IAOb;;OAEG;IACH,QAAQ,IAAI,UAAU;IAWtB;;OAEG;IACH,OAAO,CAAC,WAAW;IAoBnB;;OAEG;IACH,OAAO,IAAI,MAAM;CAiBlB;AAED;;GAEG;AACH,qBAAa,kBAAmB,SAAQ,SAAS,CAAC,IAAI,EAAE,CAAC;IACvD,OAAO,CAAC,MAAM,CAAC,QAAQ,CAAC,SAAS,CAAyB;;IAO1D;;OAEG;IACH,WAAW,IAAI,IAAI,EAAE,GAAG,SAAS;IAgBjC;;OAEG;IACH,WAAW,CAAC,KAAK,EAAE,IAAI,EAAE,GAAG,IAAI;IAYhC;;OAEG;IACH,kBAAkB,IAAI,IAAI;IAO1B;;OAEG;IACH,cAAc,IAAI,IAAI;CAUvB"}

package/dist/utils/ToolCache.js

@@ -0,0 +1,196 @@
+/**
+ * Generic caching utility for tool discovery with TTL and memory limits
+ */
+import { logger } from './logger.js';
+/**
+ * Generic cache with TTL support and memory limit protection
+ */
+export class ToolCache {
+    cache = new Map();
+    maxEntries;
+    ttlMs;
+    stats = {
+        hits: 0,
+        misses: 0
+    };
+    constructor(maxEntries = 100, ttlMinutes = 1) {
+        this.maxEntries = maxEntries;
+        this.ttlMs = ttlMinutes * 60 * 1000; // Convert minutes to milliseconds
+    }
+    /**
+     * Get cached value if valid, otherwise return undefined
+     */
+    get(key) {
+        const entry = this.cache.get(key);
+        if (!entry) {
+            this.stats.misses++;
+            return undefined;
+        }
+        // Check if entry has expired
+        const now = Date.now();
+        if (now - entry.timestamp > this.ttlMs) {
+            this.cache.delete(key);
+            this.stats.misses++;
+            logger.debug('ToolCache: Cache entry expired', { key, age: now - entry.timestamp });
+            return undefined;
+        }
+        // Entry is valid
+        entry.hits++;
+        this.stats.hits++;
+        logger.debug('ToolCache: Cache hit', { key, hits: entry.hits, age: now - entry.timestamp });
+        return entry.value;
+    }
+    /**
+     * Set cached value with automatic memory limit enforcement
+     */
+    set(key, value) {
+        const now = Date.now();
+        // Enforce memory limit by removing oldest entries if needed
+        while (this.cache.size >= this.maxEntries && !this.cache.has(key)) {
+            this.evictOldest();
+        }
+        this.cache.set(key, {
+            value,
+            timestamp: now,
+            hits: 0
+        });
+        logger.debug('ToolCache: Cache set', { key, cacheSize: this.cache.size });
+    }
+    /**
+     * Check if key exists and is not expired
+     */
+    has(key) {
+        return this.get(key) !== undefined;
+    }
+    /**
+     * Clear specific cache entry
+     */
+    delete(key) {
+        const deleted = this.cache.delete(key);
+        if (deleted) {
+            logger.debug('ToolCache: Cache entry deleted', { key });
+        }
+        return deleted;
+    }
+    /**
+     * Clear all cached entries
+     */
+    clear() {
+        this.cache.clear();
+        this.stats.hits = 0;
+        this.stats.misses = 0;
+        logger.debug('ToolCache: Cache cleared');
+    }
+    /**
+     * Get cache statistics
+     */
+    getStats() {
+        const totalRequests = this.stats.hits + this.stats.misses;
+        return {
+            hits: this.stats.hits,
+            misses: this.stats.misses,
+            size: this.cache.size,
+            maxSize: this.maxEntries,
+            hitRate: totalRequests > 0 ? this.stats.hits / totalRequests : 0
+        };
+    }
+    /**
+     * Remove oldest entries when cache is full
+     */
+    evictOldest() {
+        if (this.cache.size === 0)
+            return;
+        // Find the oldest entry (lowest timestamp)
+        let oldestKey;
+        let oldestTimestamp = Date.now();
+        for (const [key, entry] of this.cache.entries()) {
+            if (entry.timestamp < oldestTimestamp) {
+                oldestTimestamp = entry.timestamp;
+                oldestKey = key;
+            }
+        }
+        if (oldestKey) {
+            this.cache.delete(oldestKey);
+            logger.debug('ToolCache: Evicted oldest entry', { key: oldestKey, age: Date.now() - oldestTimestamp });
+        }
+    }
+    /**
+     * Clean up expired entries (can be called periodically)
+     */
+    cleanup() {
+        const now = Date.now();
+        let cleaned = 0;
+        for (const [key, entry] of this.cache.entries()) {
+            if (now - entry.timestamp > this.ttlMs) {
+                this.cache.delete(key);
+                cleaned++;
+            }
+        }
+        if (cleaned > 0) {
+            logger.debug('ToolCache: Cleaned up expired entries', { cleaned, remaining: this.cache.size });
+        }
+        return cleaned;
+    }
+}
+/**
+ * Specialized cache for MCP Tool discovery results
+ */
+export class ToolDiscoveryCache extends ToolCache {
+    static CACHE_KEY = 'tool_discovery_list';
+    constructor() {
+        // 1-minute TTL, max 100 entries (though we'll likely only use 1 key)
+        super(100, 1);
+    }
+    /**
+     * Get cached tool list
+     */
+    getToolList() {
+        const startTime = Date.now();
+        const result = this.get(ToolDiscoveryCache.CACHE_KEY);
+        const duration = Date.now() - startTime;
+        if (result) {
+            logger.info('ToolDiscoveryCache: Retrieved cached tool list', {
+                toolCount: result.length,
+                duration: `${duration}ms`,
+                stats: this.getStats()
+            });
+        }
+        return result;
+    }
+    /**
+     * Cache tool list
+     */
+    setToolList(tools) {
+        const startTime = Date.now();
+        this.set(ToolDiscoveryCache.CACHE_KEY, tools);
+        const duration = Date.now() - startTime;
+        logger.info('ToolDiscoveryCache: Cached tool list', {
+            toolCount: tools.length,
+            duration: `${duration}ms`,
+            stats: this.getStats()
+        });
+    }
+    /**
+     * Invalidate cached tool list
+     */
+    invalidateToolList() {
+        const deleted = this.delete(ToolDiscoveryCache.CACHE_KEY);
+        if (deleted) {
+            logger.info('ToolDiscoveryCache: Invalidated cached tool list');
+        }
+    }
+    /**
+     * Log performance metrics
+     */
+    logPerformance() {
+        const stats = this.getStats();
+        logger.info('ToolDiscoveryCache: Performance metrics', {
+            hitRate: `${(stats.hitRate * 100).toFixed(1)}%`,
+            hits: stats.hits,
+            misses: stats.misses,
+            cacheSize: stats.size,
+            efficiency: stats.hits > 0 ? 'GOOD' : 'NEEDS_WARMUP'
+        });
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"ToolCache.js","sourceRoot":"","sources":["../../src/utils/ToolCache.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * Generic caching utility for tool discovery with TTL and memory limits\n */\n\nimport { Tool } from \"@modelcontextprotocol/sdk/types.js\";\nimport { logger } from './logger.js';\n\nexport interface CacheEntry<T> {\n  value: T;\n  timestamp: number;\n  hits: number;\n}\n\nexport interface CacheStats {\n  hits: number;\n  misses: number;\n  size: number;\n  maxSize: number;\n  hitRate: number;\n}\n\n/**\n * Generic cache with TTL support and memory limit protection\n */\nexport class ToolCache<T = any> {\n  private cache: Map<string, CacheEntry<T>> = new Map();\n  private readonly maxEntries: number;\n  private readonly ttlMs: number;\n  private stats = {\n    hits: 0,\n    misses: 0\n  };\n\n  constructor(maxEntries: number = 100, ttlMinutes: number = 1) {\n    this.maxEntries = maxEntries;\n    this.ttlMs = ttlMinutes * 60 * 1000; // Convert minutes to milliseconds\n  }\n\n  /**\n   * Get cached value if valid, otherwise return undefined\n   */\n  get(key: string): T | undefined {\n    const entry = this.cache.get(key);\n    \n    if (!entry) {\n      this.stats.misses++;\n      return undefined;\n    }\n\n    // Check if entry has expired\n    const now = Date.now();\n    if (now - entry.timestamp > this.ttlMs) {\n      this.cache.delete(key);\n      this.stats.misses++;\n      logger.debug('ToolCache: Cache entry expired', { key, age: now - entry.timestamp });\n      return undefined;\n    }\n\n    // Entry is valid\n    entry.hits++;\n    this.stats.hits++;\n    logger.debug('ToolCache: Cache hit', { key, hits: entry.hits, age: now - entry.timestamp });\n    return entry.value;\n  }\n\n  /**\n   * Set cached value with automatic memory limit enforcement\n   */\n  set(key: string, value: T): void {\n    const now = Date.now();\n    \n    // Enforce memory limit by removing oldest entries if needed\n    while (this.cache.size >= this.maxEntries && !this.cache.has(key)) {\n      this.evictOldest();\n    }\n\n    this.cache.set(key, {\n      value,\n      timestamp: now,\n      hits: 0\n    });\n\n    logger.debug('ToolCache: Cache set', { key, cacheSize: this.cache.size });\n  }\n\n  /**\n   * Check if key exists and is not expired\n   */\n  has(key: string): boolean {\n    return this.get(key) !== undefined;\n  }\n\n  /**\n   * Clear specific cache entry\n   */\n  delete(key: string): boolean {\n    const deleted = this.cache.delete(key);\n    if (deleted) {\n      logger.debug('ToolCache: Cache entry deleted', { key });\n    }\n    return deleted;\n  }\n\n  /**\n   * Clear all cached entries\n   */\n  clear(): void {\n    this.cache.clear();\n    this.stats.hits = 0;\n    this.stats.misses = 0;\n    logger.debug('ToolCache: Cache cleared');\n  }\n\n  /**\n   * Get cache statistics\n   */\n  getStats(): CacheStats {\n    const totalRequests = this.stats.hits + this.stats.misses;\n    return {\n      hits: this.stats.hits,\n      misses: this.stats.misses,\n      size: this.cache.size,\n      maxSize: this.maxEntries,\n      hitRate: totalRequests > 0 ? this.stats.hits / totalRequests : 0\n    };\n  }\n\n  /**\n   * Remove oldest entries when cache is full\n   */\n  private evictOldest(): void {\n    if (this.cache.size === 0) return;\n\n    // Find the oldest entry (lowest timestamp)\n    let oldestKey: string | undefined;\n    let oldestTimestamp = Date.now();\n\n    for (const [key, entry] of this.cache.entries()) {\n      if (entry.timestamp < oldestTimestamp) {\n        oldestTimestamp = entry.timestamp;\n        oldestKey = key;\n      }\n    }\n\n    if (oldestKey) {\n      this.cache.delete(oldestKey);\n      logger.debug('ToolCache: Evicted oldest entry', { key: oldestKey, age: Date.now() - oldestTimestamp });\n    }\n  }\n\n  /**\n   * Clean up expired entries (can be called periodically)\n   */\n  cleanup(): number {\n    const now = Date.now();\n    let cleaned = 0;\n\n    for (const [key, entry] of this.cache.entries()) {\n      if (now - entry.timestamp > this.ttlMs) {\n        this.cache.delete(key);\n        cleaned++;\n      }\n    }\n\n    if (cleaned > 0) {\n      logger.debug('ToolCache: Cleaned up expired entries', { cleaned, remaining: this.cache.size });\n    }\n\n    return cleaned;\n  }\n}\n\n/**\n * Specialized cache for MCP Tool discovery results\n */\nexport class ToolDiscoveryCache extends ToolCache<Tool[]> {\n  private static readonly CACHE_KEY = 'tool_discovery_list';\n\n  constructor() {\n    // 1-minute TTL, max 100 entries (though we'll likely only use 1 key)\n    super(100, 1);\n  }\n\n  /**\n   * Get cached tool list\n   */\n  getToolList(): Tool[] | undefined {\n    const startTime = Date.now();\n    const result = this.get(ToolDiscoveryCache.CACHE_KEY);\n    const duration = Date.now() - startTime;\n    \n    if (result) {\n      logger.info('ToolDiscoveryCache: Retrieved cached tool list', { \n        toolCount: result.length, \n        duration: `${duration}ms`,\n        stats: this.getStats()\n      });\n    }\n    \n    return result;\n  }\n\n  /**\n   * Cache tool list\n   */\n  setToolList(tools: Tool[]): void {\n    const startTime = Date.now();\n    this.set(ToolDiscoveryCache.CACHE_KEY, tools);\n    const duration = Date.now() - startTime;\n    \n    logger.info('ToolDiscoveryCache: Cached tool list', { \n      toolCount: tools.length, \n      duration: `${duration}ms`,\n      stats: this.getStats()\n    });\n  }\n\n  /**\n   * Invalidate cached tool list\n   */\n  invalidateToolList(): void {\n    const deleted = this.delete(ToolDiscoveryCache.CACHE_KEY);\n    if (deleted) {\n      logger.info('ToolDiscoveryCache: Invalidated cached tool list');\n    }\n  }\n\n  /**\n   * Log performance metrics\n   */\n  logPerformance(): void {\n    const stats = this.getStats();\n    logger.info('ToolDiscoveryCache: Performance metrics', {\n      hitRate: `${(stats.hitRate * 100).toFixed(1)}%`,\n      hits: stats.hits,\n      misses: stats.misses,\n      cacheSize: stats.size,\n      efficiency: stats.hits > 0 ? 'GOOD' : 'NEEDS_WARMUP'\n    });\n  }\n}"]}

package/dist/utils/errorCodes.d.ts

@@ -0,0 +1,136 @@
+/**
+ * Centralized error codes for consistent error handling across the application.
+ * Error codes follow the pattern: CATEGORY_SPECIFIC_ERROR
+ */
+/**
+ * Validation error codes - Input validation failures
+ */
+export declare const ValidationErrorCodes: {
+    readonly INVALID_INPUT: "VALIDATION_INVALID_INPUT";
+    readonly REQUIRED_FIELD: "VALIDATION_REQUIRED_FIELD";
+    readonly INVALID_FORMAT: "VALIDATION_INVALID_FORMAT";
+    readonly INVALID_LENGTH: "VALIDATION_INVALID_LENGTH";
+    readonly INVALID_RANGE: "VALIDATION_INVALID_RANGE";
+    readonly INVALID_TYPE: "VALIDATION_INVALID_TYPE";
+    readonly INVALID_PERSONA_ID: "VALIDATION_INVALID_PERSONA_ID";
+    readonly INVALID_SEARCH_QUERY: "VALIDATION_INVALID_SEARCH_QUERY";
+    readonly INVALID_COLLECTION_PATH: "VALIDATION_INVALID_COLLECTION_PATH";
+    readonly INVALID_URL: "VALIDATION_INVALID_URL";
+    readonly INVALID_FILENAME: "VALIDATION_INVALID_FILENAME";
+    readonly INVALID_PATH: "VALIDATION_INVALID_PATH";
+    readonly PATH_TRAVERSAL: "VALIDATION_PATH_TRAVERSAL";
+    readonly INVALID_CHARACTER: "VALIDATION_INVALID_CHARACTER";
+    readonly CONFIRMATION_REQUIRED: "VALIDATION_CONFIRMATION_REQUIRED";
+    readonly INVALID_CATEGORY: "VALIDATION_INVALID_CATEGORY";
+    readonly CONTENT_TOO_LARGE: "VALIDATION_CONTENT_TOO_LARGE";
+    readonly TEMPLATE_TOO_LARGE: "VALIDATION_TEMPLATE_TOO_LARGE";
+    readonly TOO_MANY_VARIABLES: "VALIDATION_TOO_MANY_VARIABLES";
+    readonly INVALID_INCLUDE_PATH: "VALIDATION_INVALID_INCLUDE_PATH";
+    readonly MAX_INCLUDE_DEPTH: "VALIDATION_MAX_INCLUDE_DEPTH";
+    readonly REQUIRED_VARIABLE: "VALIDATION_REQUIRED_VARIABLE";
+    readonly DANGEROUS_PATTERN: "VALIDATION_DANGEROUS_PATTERN";
+    readonly PATTERN_TOO_COMPLEX: "VALIDATION_PATTERN_TOO_COMPLEX";
+    readonly PATTERN_MISMATCH: "VALIDATION_PATTERN_MISMATCH";
+    readonly INVALID_PATTERN: "VALIDATION_INVALID_PATTERN";
+    readonly INVALID_OPTIONS: "VALIDATION_INVALID_OPTIONS";
+    readonly INVALID_NUMBER: "VALIDATION_INVALID_NUMBER";
+    readonly INVALID_DATE: "VALIDATION_INVALID_DATE";
+    readonly INVALID_ARRAY: "VALIDATION_INVALID_ARRAY";
+    readonly INVALID_OBJECT: "VALIDATION_INVALID_OBJECT";
+    readonly INVALID_FRAMEWORK: "VALIDATION_INVALID_FRAMEWORK";
+    readonly INVALID_RISK_TOLERANCE: "VALIDATION_INVALID_RISK_TOLERANCE";
+    readonly MAX_GOALS_EXCEEDED: "VALIDATION_MAX_GOALS_EXCEEDED";
+    readonly GOAL_TOO_SHORT: "VALIDATION_GOAL_TOO_SHORT";
+    readonly HARMFUL_CONTENT: "VALIDATION_HARMFUL_CONTENT";
+    readonly DEPENDENCY_CYCLE: "VALIDATION_DEPENDENCY_CYCLE";
+    readonly GOAL_NOT_FOUND: "VALIDATION_GOAL_NOT_FOUND";
+    readonly INVALID_GOAL_STATUS: "VALIDATION_INVALID_GOAL_STATUS";
+    readonly CONTEXT_TOO_LARGE: "VALIDATION_CONTEXT_TOO_LARGE";
+    readonly STATE_TOO_LARGE: "VALIDATION_STATE_TOO_LARGE";
+};
+/**
+ * Network error codes - API and network failures
+ */
+export declare const NetworkErrorCodes: {
+    readonly REQUEST_FAILED: "NETWORK_REQUEST_FAILED";
+    readonly INVALID_RESPONSE: "NETWORK_INVALID_RESPONSE";
+    readonly RESPONSE_TOO_LARGE: "NETWORK_RESPONSE_TOO_LARGE";
+    readonly API_ERROR: "NETWORK_API_ERROR";
+    readonly RATE_LIMIT_EXCEEDED: "NETWORK_RATE_LIMIT_EXCEEDED";
+    readonly FETCH_FAILED: "NETWORK_FETCH_FAILED";
+};
+/**
+ * System error codes - Internal system failures
+ */
+export declare const SystemErrorCodes: {
+    readonly LOAD_FAILED: "SYSTEM_LOAD_FAILED";
+    readonly SAVE_FAILED: "SYSTEM_SAVE_FAILED";
+    readonly DELETE_FAILED: "SYSTEM_DELETE_FAILED";
+    readonly IMPORT_FAILED: "SYSTEM_IMPORT_FAILED";
+    readonly EXPORT_FAILED: "SYSTEM_EXPORT_FAILED";
+    readonly DESERIALIZATION_FAILED: "SYSTEM_DESERIALIZATION_FAILED";
+    readonly UNKNOWN_FRAMEWORK: "SYSTEM_UNKNOWN_FRAMEWORK";
+    readonly UNSUPPORTED_FORMAT: "SYSTEM_UNSUPPORTED_FORMAT";
+};
+/**
+ * All error codes combined for easy access
+ */
+export declare const ErrorCodes: {
+    readonly LOAD_FAILED: "SYSTEM_LOAD_FAILED";
+    readonly SAVE_FAILED: "SYSTEM_SAVE_FAILED";
+    readonly DELETE_FAILED: "SYSTEM_DELETE_FAILED";
+    readonly IMPORT_FAILED: "SYSTEM_IMPORT_FAILED";
+    readonly EXPORT_FAILED: "SYSTEM_EXPORT_FAILED";
+    readonly DESERIALIZATION_FAILED: "SYSTEM_DESERIALIZATION_FAILED";
+    readonly UNKNOWN_FRAMEWORK: "SYSTEM_UNKNOWN_FRAMEWORK";
+    readonly UNSUPPORTED_FORMAT: "SYSTEM_UNSUPPORTED_FORMAT";
+    readonly REQUEST_FAILED: "NETWORK_REQUEST_FAILED";
+    readonly INVALID_RESPONSE: "NETWORK_INVALID_RESPONSE";
+    readonly RESPONSE_TOO_LARGE: "NETWORK_RESPONSE_TOO_LARGE";
+    readonly API_ERROR: "NETWORK_API_ERROR";
+    readonly RATE_LIMIT_EXCEEDED: "NETWORK_RATE_LIMIT_EXCEEDED";
+    readonly FETCH_FAILED: "NETWORK_FETCH_FAILED";
+    readonly INVALID_INPUT: "VALIDATION_INVALID_INPUT";
+    readonly REQUIRED_FIELD: "VALIDATION_REQUIRED_FIELD";
+    readonly INVALID_FORMAT: "VALIDATION_INVALID_FORMAT";
+    readonly INVALID_LENGTH: "VALIDATION_INVALID_LENGTH";
+    readonly INVALID_RANGE: "VALIDATION_INVALID_RANGE";
+    readonly INVALID_TYPE: "VALIDATION_INVALID_TYPE";
+    readonly INVALID_PERSONA_ID: "VALIDATION_INVALID_PERSONA_ID";
+    readonly INVALID_SEARCH_QUERY: "VALIDATION_INVALID_SEARCH_QUERY";
+    readonly INVALID_COLLECTION_PATH: "VALIDATION_INVALID_COLLECTION_PATH";
+    readonly INVALID_URL: "VALIDATION_INVALID_URL";
+    readonly INVALID_FILENAME: "VALIDATION_INVALID_FILENAME";
+    readonly INVALID_PATH: "VALIDATION_INVALID_PATH";
+    readonly PATH_TRAVERSAL: "VALIDATION_PATH_TRAVERSAL";
+    readonly INVALID_CHARACTER: "VALIDATION_INVALID_CHARACTER";
+    readonly CONFIRMATION_REQUIRED: "VALIDATION_CONFIRMATION_REQUIRED";
+    readonly INVALID_CATEGORY: "VALIDATION_INVALID_CATEGORY";
+    readonly CONTENT_TOO_LARGE: "VALIDATION_CONTENT_TOO_LARGE";
+    readonly TEMPLATE_TOO_LARGE: "VALIDATION_TEMPLATE_TOO_LARGE";
+    readonly TOO_MANY_VARIABLES: "VALIDATION_TOO_MANY_VARIABLES";
+    readonly INVALID_INCLUDE_PATH: "VALIDATION_INVALID_INCLUDE_PATH";
+    readonly MAX_INCLUDE_DEPTH: "VALIDATION_MAX_INCLUDE_DEPTH";
+    readonly REQUIRED_VARIABLE: "VALIDATION_REQUIRED_VARIABLE";
+    readonly DANGEROUS_PATTERN: "VALIDATION_DANGEROUS_PATTERN";
+    readonly PATTERN_TOO_COMPLEX: "VALIDATION_PATTERN_TOO_COMPLEX";
+    readonly PATTERN_MISMATCH: "VALIDATION_PATTERN_MISMATCH";
+    readonly INVALID_PATTERN: "VALIDATION_INVALID_PATTERN";
+    readonly INVALID_OPTIONS: "VALIDATION_INVALID_OPTIONS";
+    readonly INVALID_NUMBER: "VALIDATION_INVALID_NUMBER";
+    readonly INVALID_DATE: "VALIDATION_INVALID_DATE";
+    readonly INVALID_ARRAY: "VALIDATION_INVALID_ARRAY";
+    readonly INVALID_OBJECT: "VALIDATION_INVALID_OBJECT";
+    readonly INVALID_FRAMEWORK: "VALIDATION_INVALID_FRAMEWORK";
+    readonly INVALID_RISK_TOLERANCE: "VALIDATION_INVALID_RISK_TOLERANCE";
+    readonly MAX_GOALS_EXCEEDED: "VALIDATION_MAX_GOALS_EXCEEDED";
+    readonly GOAL_TOO_SHORT: "VALIDATION_GOAL_TOO_SHORT";
+    readonly HARMFUL_CONTENT: "VALIDATION_HARMFUL_CONTENT";
+    readonly DEPENDENCY_CYCLE: "VALIDATION_DEPENDENCY_CYCLE";
+    readonly GOAL_NOT_FOUND: "VALIDATION_GOAL_NOT_FOUND";
+    readonly INVALID_GOAL_STATUS: "VALIDATION_INVALID_GOAL_STATUS";
+    readonly CONTEXT_TOO_LARGE: "VALIDATION_CONTEXT_TOO_LARGE";
+    readonly STATE_TOO_LARGE: "VALIDATION_STATE_TOO_LARGE";
+};
+export type ErrorCode = typeof ErrorCodes[keyof typeof ErrorCodes];
+//# sourceMappingURL=errorCodes.d.ts.map

package/dist/utils/errorCodes.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"errorCodes.d.ts","sourceRoot":"","sources":["../../src/utils/errorCodes.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH;;GAEG;AACH,eAAO,MAAM,oBAAoB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAiDvB,CAAC;AAEX;;GAEG;AACH,eAAO,MAAM,iBAAiB;;;;;;;CAOpB,CAAC;AAEX;;GAEG;AACH,eAAO,MAAM,gBAAgB;;;;;;;;;CASnB,CAAC;AAEX;;GAEG;AACH,eAAO,MAAM,UAAU;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAIb,CAAC;AAEX,MAAM,MAAM,SAAS,GAAG,OAAO,UAAU,CAAC,MAAM,OAAO,UAAU,CAAC,CAAC"}

package/dist/utils/errorCodes.js

@@ -0,0 +1,87 @@
+/**
+ * Centralized error codes for consistent error handling across the application.
+ * Error codes follow the pattern: CATEGORY_SPECIFIC_ERROR
+ */
+/**
+ * Validation error codes - Input validation failures
+ */
+export const ValidationErrorCodes = {
+    // General validation
+    INVALID_INPUT: 'VALIDATION_INVALID_INPUT',
+    REQUIRED_FIELD: 'VALIDATION_REQUIRED_FIELD',
+    INVALID_FORMAT: 'VALIDATION_INVALID_FORMAT',
+    INVALID_LENGTH: 'VALIDATION_INVALID_LENGTH',
+    INVALID_RANGE: 'VALIDATION_INVALID_RANGE',
+    INVALID_TYPE: 'VALIDATION_INVALID_TYPE',
+    // Specific validation
+    INVALID_PERSONA_ID: 'VALIDATION_INVALID_PERSONA_ID',
+    INVALID_SEARCH_QUERY: 'VALIDATION_INVALID_SEARCH_QUERY',
+    INVALID_COLLECTION_PATH: 'VALIDATION_INVALID_COLLECTION_PATH',
+    INVALID_URL: 'VALIDATION_INVALID_URL',
+    INVALID_FILENAME: 'VALIDATION_INVALID_FILENAME',
+    INVALID_PATH: 'VALIDATION_INVALID_PATH',
+    PATH_TRAVERSAL: 'VALIDATION_PATH_TRAVERSAL',
+    INVALID_CHARACTER: 'VALIDATION_INVALID_CHARACTER',
+    CONFIRMATION_REQUIRED: 'VALIDATION_CONFIRMATION_REQUIRED',
+    INVALID_CATEGORY: 'VALIDATION_INVALID_CATEGORY',
+    CONTENT_TOO_LARGE: 'VALIDATION_CONTENT_TOO_LARGE',
+    // Template validation
+    TEMPLATE_TOO_LARGE: 'VALIDATION_TEMPLATE_TOO_LARGE',
+    TOO_MANY_VARIABLES: 'VALIDATION_TOO_MANY_VARIABLES',
+    INVALID_INCLUDE_PATH: 'VALIDATION_INVALID_INCLUDE_PATH',
+    MAX_INCLUDE_DEPTH: 'VALIDATION_MAX_INCLUDE_DEPTH',
+    REQUIRED_VARIABLE: 'VALIDATION_REQUIRED_VARIABLE',
+    DANGEROUS_PATTERN: 'VALIDATION_DANGEROUS_PATTERN',
+    PATTERN_TOO_COMPLEX: 'VALIDATION_PATTERN_TOO_COMPLEX',
+    PATTERN_MISMATCH: 'VALIDATION_PATTERN_MISMATCH',
+    INVALID_PATTERN: 'VALIDATION_INVALID_PATTERN',
+    INVALID_OPTIONS: 'VALIDATION_INVALID_OPTIONS',
+    INVALID_NUMBER: 'VALIDATION_INVALID_NUMBER',
+    INVALID_DATE: 'VALIDATION_INVALID_DATE',
+    INVALID_ARRAY: 'VALIDATION_INVALID_ARRAY',
+    INVALID_OBJECT: 'VALIDATION_INVALID_OBJECT',
+    // Agent validation
+    INVALID_FRAMEWORK: 'VALIDATION_INVALID_FRAMEWORK',
+    INVALID_RISK_TOLERANCE: 'VALIDATION_INVALID_RISK_TOLERANCE',
+    MAX_GOALS_EXCEEDED: 'VALIDATION_MAX_GOALS_EXCEEDED',
+    GOAL_TOO_SHORT: 'VALIDATION_GOAL_TOO_SHORT',
+    HARMFUL_CONTENT: 'VALIDATION_HARMFUL_CONTENT',
+    DEPENDENCY_CYCLE: 'VALIDATION_DEPENDENCY_CYCLE',
+    GOAL_NOT_FOUND: 'VALIDATION_GOAL_NOT_FOUND',
+    INVALID_GOAL_STATUS: 'VALIDATION_INVALID_GOAL_STATUS',
+    CONTEXT_TOO_LARGE: 'VALIDATION_CONTEXT_TOO_LARGE',
+    STATE_TOO_LARGE: 'VALIDATION_STATE_TOO_LARGE',
+};
+/**
+ * Network error codes - API and network failures
+ */
+export const NetworkErrorCodes = {
+    REQUEST_FAILED: 'NETWORK_REQUEST_FAILED',
+    INVALID_RESPONSE: 'NETWORK_INVALID_RESPONSE',
+    RESPONSE_TOO_LARGE: 'NETWORK_RESPONSE_TOO_LARGE',
+    API_ERROR: 'NETWORK_API_ERROR',
+    RATE_LIMIT_EXCEEDED: 'NETWORK_RATE_LIMIT_EXCEEDED',
+    FETCH_FAILED: 'NETWORK_FETCH_FAILED',
+};
+/**
+ * System error codes - Internal system failures
+ */
+export const SystemErrorCodes = {
+    LOAD_FAILED: 'SYSTEM_LOAD_FAILED',
+    SAVE_FAILED: 'SYSTEM_SAVE_FAILED',
+    DELETE_FAILED: 'SYSTEM_DELETE_FAILED',
+    IMPORT_FAILED: 'SYSTEM_IMPORT_FAILED',
+    EXPORT_FAILED: 'SYSTEM_EXPORT_FAILED',
+    DESERIALIZATION_FAILED: 'SYSTEM_DESERIALIZATION_FAILED',
+    UNKNOWN_FRAMEWORK: 'SYSTEM_UNKNOWN_FRAMEWORK',
+    UNSUPPORTED_FORMAT: 'SYSTEM_UNSUPPORTED_FORMAT',
+};
+/**
+ * All error codes combined for easy access
+ */
+export const ErrorCodes = {
+    ...ValidationErrorCodes,
+    ...NetworkErrorCodes,
+    ...SystemErrorCodes,
+};
+//# sourceMappingURL=data:application/json;base64,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

package/dist/utils/index.d.ts

@@ -4,4 +4,7 @@
 export * from './git.js';
 export * from './filesystem.js';
 export * from './version.js';
+export * from './SecureDownloader.js';
+export * from './RateLimiter.js';
+export * from './ToolCache.js';
 //# sourceMappingURL=index.d.ts.map

package/dist/utils/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/utils/index.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,cAAc,UAAU,CAAC;AACzB,cAAc,iBAAiB,CAAC;AAChC,cAAc,cAAc,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/utils/index.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,cAAc,UAAU,CAAC;AACzB,cAAc,iBAAiB,CAAC;AAChC,cAAc,cAAc,CAAC;AAC7B,cAAc,uBAAuB,CAAC;AACtC,cAAc,kBAAkB,CAAC;AACjC,cAAc,gBAAgB,CAAC"}

package/dist/utils/index.js

@@ -4,4 +4,7 @@
 export * from './git.js';
 export * from './filesystem.js';
 export * from './version.js';
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvdXRpbHMvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUE7O0dBRUc7QUFFSCxjQUFjLFVBQVUsQ0FBQztBQUN6QixjQUFjLGlCQUFpQixDQUFDO0FBQ2hDLGNBQWMsY0FBYyxDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiLyoqXG4gKiBVdGlsaXRpZXMgbW9kdWxlIGV4cG9ydHNcbiAqL1xuXG5leHBvcnQgKiBmcm9tICcuL2dpdC5qcyc7XG5leHBvcnQgKiBmcm9tICcuL2ZpbGVzeXN0ZW0uanMnO1xuZXhwb3J0ICogZnJvbSAnLi92ZXJzaW9uLmpzJzsiXX0=
+export * from './SecureDownloader.js';
+export * from './RateLimiter.js';
+export * from './ToolCache.js';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvdXRpbHMvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUE7O0dBRUc7QUFFSCxjQUFjLFVBQVUsQ0FBQztBQUN6QixjQUFjLGlCQUFpQixDQUFDO0FBQ2hDLGNBQWMsY0FBYyxDQUFDO0FBQzdCLGNBQWMsdUJBQXVCLENBQUM7QUFDdEMsY0FBYyxrQkFBa0IsQ0FBQztBQUNqQyxjQUFjLGdCQUFnQixDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiLyoqXG4gKiBVdGlsaXRpZXMgbW9kdWxlIGV4cG9ydHNcbiAqL1xuXG5leHBvcnQgKiBmcm9tICcuL2dpdC5qcyc7XG5leHBvcnQgKiBmcm9tICcuL2ZpbGVzeXN0ZW0uanMnO1xuZXhwb3J0ICogZnJvbSAnLi92ZXJzaW9uLmpzJztcbmV4cG9ydCAqIGZyb20gJy4vU2VjdXJlRG93bmxvYWRlci5qcyc7XG5leHBvcnQgKiBmcm9tICcuL1JhdGVMaW1pdGVyLmpzJztcbmV4cG9ydCAqIGZyb20gJy4vVG9vbENhY2hlLmpzJzsiXX0=

package/dist/utils/installation.d.ts

@@ -5,7 +5,7 @@
 export type InstallationType = 'npm' | 'git' | 'unknown';
 export declare class InstallationDetector {
     private static cachedType;
-    private static get MAX_SEARCH_DEPTH();
+    private static readonly MAX_SEARCH_DEPTH;
     /**
      * Detect the installation type (npm global, git clone, or unknown)
      */

package/dist/utils/installation.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"installation.d.ts","sourceRoot":"","sources":["../../src/utils/installation.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAQH,MAAM,MAAM,gBAAgB,GAAG,KAAK,GAAG,KAAK,GAAG,SAAS,CAAC;AAEzD,qBAAa,oBAAoB;IAC/B,OAAO,CAAC,MAAM,CAAC,UAAU,CAAiC;IAG1D,OAAO,CAAC,MAAM,KAAK,gBAAgB,GAElC;IAED;;OAEG;IACH,MAAM,CAAC,mBAAmB,IAAI,gBAAgB;IA8D9C;;OAEG;IACH,MAAM,CAAC,gBAAgB,IAAI,MAAM,GAAG,IAAI;IA2BxC;;OAEG;IACH,MAAM,CAAC,oBAAoB,IAAI,MAAM,GAAG,IAAI;IA4B5C;;OAEG;IACH,MAAM,CAAC,0BAA0B,IAAI,MAAM;IAqB3C;;OAEG;IACH,MAAM,CAAC,UAAU,IAAI,IAAI;CAG1B"}
+{"version":3,"file":"installation.d.ts","sourceRoot":"","sources":["../../src/utils/installation.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAOH,MAAM,MAAM,gBAAgB,GAAG,KAAK,GAAG,KAAK,GAAG,SAAS,CAAC;AAEzD,qBAAa,oBAAoB;IAC/B,OAAO,CAAC,MAAM,CAAC,UAAU,CAAiC;IAG1D,OAAO,CAAC,MAAM,CAAC,QAAQ,CAAC,gBAAgB,CAAM;IAE9C;;OAEG;IACH,MAAM,CAAC,mBAAmB,IAAI,gBAAgB;IAgE9C;;OAEG;IACH,MAAM,CAAC,gBAAgB,IAAI,MAAM,GAAG,IAAI;IA6BxC;;OAEG;IACH,MAAM,CAAC,oBAAoB,IAAI,MAAM,GAAG,IAAI;IA4B5C;;OAEG;IACH,MAAM,CAAC,0BAA0B,IAAI,MAAM;IAqB3C;;OAEG;IACH,MAAM,CAAC,UAAU,IAAI,IAAI;CAG1B"}