create-byan-agent 2.0.1 → 2.1.0

package/src/core/cache/cache.js

@@ -0,0 +1,126 @@
+/**
+ * Simple Cache with TTL support for reducing token consumption
+ * Provides in-memory caching with automatic expiration
+ * 
+ * @class SimpleCache
+ * @example
+ * const cache = new SimpleCache();
+ * cache.set('key1', 'value1', 5000); // TTL 5 seconds
+ * const value = cache.get('key1');
+ */
+class SimpleCache {
+  /**
+   * Initialize a new SimpleCache instance
+   */
+  constructor() {
+    this.store = new Map();
+  }
+
+  /**
+   * Store a value in cache with optional TTL
+   * @param {string} key - Cache key
+   * @param {*} value - Value to cache
+   * @param {number} [ttl] - Time to live in milliseconds (optional)
+   * @throws {Error} If key is not a string
+   * @returns {void}
+   */
+  set(key, value, ttl) {
+    if (typeof key !== 'string' || !key) {
+      throw new Error('Cache key must be a non-empty string');
+    }
+
+    const entry = {
+      value,
+      timestamp: Date.now(),
+      ttl: ttl || null
+    };
+
+    this.store.set(key, entry);
+  }
+
+  /**
+   * Retrieve a value from cache
+   * @param {string} key - Cache key
+   * @returns {*|null} Cached value or null if not found or expired
+   */
+  get(key) {
+    const entry = this.store.get(key);
+
+    if (!entry) {
+      return null;
+    }
+
+    // Check if TTL has expired
+    if (entry.ttl && (Date.now() - entry.timestamp) > entry.ttl) {
+      this.store.delete(key);
+      return null;
+    }
+
+    return entry.value;
+  }
+
+  /**
+   * Check if a key exists and is not expired
+   * @param {string} key - Cache key
+   * @returns {boolean} True if key exists and not expired
+   */
+  has(key) {
+    const value = this.get(key);
+    return value !== null;
+  }
+
+  /**
+   * Delete a specific cache entry
+   * @param {string} key - Cache key to delete
+   * @returns {boolean} True if key was deleted, false if not found
+   */
+  delete(key) {
+    return this.store.delete(key);
+  }
+
+  /**
+   * Clear all cache entries
+   * @returns {void}
+   */
+  clear() {
+    this.store.clear();
+  }
+
+  /**
+   * Get the number of entries in cache (includes expired but not cleaned)
+   * @returns {number} Number of cache entries
+   */
+  size() {
+    return this.store.size;
+  }
+
+  /**
+   * Get all non-expired keys
+   * @returns {string[]} Array of valid keys
+   */
+  keys() {
+    const validKeys = [];
+    for (const [key] of this.store) {
+      if (this.get(key) !== null) {
+        validKeys.push(key);
+      }
+    }
+    return validKeys;
+  }
+
+  /**
+   * Clean up expired entries
+   * @returns {number} Number of entries removed
+   */
+  cleanup() {
+    let removed = 0;
+    for (const [key] of this.store) {
+      if (this.get(key) === null) {
+        removed++;
+      }
+    }
+    return removed;
+  }
+}
+
+module.exports = SimpleCache;

package/src/core/context/context.js

@@ -0,0 +1,86 @@
+/**
+ * Context Layer for managing conversational context across agents
+ * Provides a hierarchical structure for storing and retrieving context data
+ * 
+ * @class ContextLayer
+ * @example
+ * const ctx = new ContextLayer();
+ * ctx.addLayer('user', { name: 'Yan', role: 'dev' });
+ * const userData = ctx.getLayer('user');
+ */
+class ContextLayer {
+  /**
+   * Initialize a new ContextLayer instance
+   */
+  constructor() {
+    this.layers = {};
+  }
+
+  /**
+   * Add or update a context layer
+   * @param {string} name - Layer name/identifier
+   * @param {object} data - Layer data to store
+   * @throws {Error} If name is not a string or data is not an object
+   * @returns {void}
+   */
+  addLayer(name, data) {
+    if (typeof name !== 'string' || !name) {
+      throw new Error('Layer name must be a non-empty string');
+    }
+    if (typeof data !== 'object' || data === null) {
+      throw new Error('Layer data must be an object');
+    }
+    this.layers[name] = { ...data, _timestamp: Date.now() };
+  }
+
+  /**
+   * Retrieve a specific context layer
+   * @param {string} name - Layer name to retrieve
+   * @returns {object|null} Layer data (deep copy) or null if not found
+   */
+  getLayer(name) {
+    if (!this.layers[name]) {
+      return null;
+    }
+    return JSON.parse(JSON.stringify(this.layers[name]));
+  }
+
+  /**
+   * Get all context layers
+   * @returns {object} All layers as a key-value object (deep copy)
+   */
+  getAllLayers() {
+    return JSON.parse(JSON.stringify(this.layers));
+  }
+
+  /**
+   * Remove a specific context layer
+   * @param {string} name - Layer name to remove
+   * @returns {boolean} True if layer was removed, false if not found
+   */
+  clearLayer(name) {
+    if (this.layers[name]) {
+      delete this.layers[name];
+      return true;
+    }
+    return false;
+  }
+
+  /**
+   * Serialize all layers to JSON string
+   * @returns {string} JSON representation of all layers
+   */
+  serialize() {
+    return JSON.stringify(this.layers);
+  }
+
+  /**
+   * Clear all context layers
+   * @returns {void}
+   */
+  clearAll() {
+    this.layers = {};
+  }
+}
+
+module.exports = ContextLayer;

package/src/core/dispatcher/dispatcher.js

@@ -0,0 +1,135 @@
+/**
+ * Economic Dispatcher for routing tasks to appropriate AI models
+ * Routes tasks based on complexity keywords to optimize cost/performance
+ * 
+ * @class EconomicDispatcher
+ * @example
+ * const dispatcher = new EconomicDispatcher();
+ * const model = dispatcher.dispatch('explore codebase'); // Returns 'haiku'
+ */
+class EconomicDispatcher {
+  /**
+   * Initialize a new EconomicDispatcher instance
+   */
+  constructor() {
+    // Model classification patterns
+    this.patterns = {
+      haiku: [
+        'explore', 'simple', 'quick', 'search', 'find', 'list', 'show',
+        'check', 'verify', 'read', 'get', 'view', 'display', 'basic'
+      ],
+      sonnet: [
+        'implement', 'code', 'complex', 'develop', 'create', 'build',
+        'write', 'fix', 'refactor', 'optimize', 'integrate', 'design'
+      ],
+      opus: [
+        'architect', 'critical', 'review', 'analyze', 'evaluate', 'plan',
+        'strategy', 'security', 'performance', 'scalability', 'system-design',
+        'architectural', 'mission-critical', 'production'
+      ]
+    };
+
+    // Relative costs (Haiku = 1x baseline)
+    this.costs = {
+      haiku: 1,
+      sonnet: 5,
+      opus: 15
+    };
+  }
+
+  /**
+   * Dispatch a task to the appropriate model
+   * @param {string} task - Task description
+   * @returns {string} Model name ('haiku', 'sonnet', or 'opus')
+   * @throws {Error} If task is not a string
+   */
+  dispatch(task) {
+    if (typeof task !== 'string' || !task) {
+      throw new Error('Task must be a non-empty string');
+    }
+
+    const taskLower = task.toLowerCase();
+    
+    // Helper to check for whole word match or start of compound words
+    const hasKeyword = (patterns) => {
+      return patterns.some(pattern => {
+        const regex = new RegExp(`\\b${pattern}\\b`, 'i');
+        return regex.test(task);
+      });
+    };
+
+    // Check Opus patterns first (highest priority for critical tasks)
+    if (hasKeyword(this.patterns.opus)) {
+      return 'opus';
+    }
+
+    // Check Sonnet patterns (medium complexity)
+    if (hasKeyword(this.patterns.sonnet)) {
+      return 'sonnet';
+    }
+
+    // Check Haiku patterns (simple tasks)
+    if (hasKeyword(this.patterns.haiku)) {
+      return 'haiku';
+    }
+
+    // Default to Sonnet for unclassified tasks (balanced choice)
+    return 'sonnet';
+  }
+
+  /**
+   * Get the relative cost of a model
+   * @param {string} model - Model name ('haiku', 'sonnet', or 'opus')
+   * @returns {number} Relative cost multiplier
+   * @throws {Error} If model is unknown
+   */
+  getModelCost(model) {
+    if (!this.costs[model]) {
+      throw new Error(`Unknown model: ${model}`);
+    }
+    return this.costs[model];
+  }
+
+  /**
+   * Get cost comparison between two models
+   * @param {string} model1 - First model
+   * @param {string} model2 - Second model
+   * @returns {number} Cost ratio (model1/model2)
+   */
+  compareCosts(model1, model2) {
+    const cost1 = this.getModelCost(model1);
+    const cost2 = this.getModelCost(model2);
+    return cost1 / cost2;
+  }
+
+  /**
+   * Get all available models with their costs
+   * @returns {object} Models and their costs
+   */
+  getAllModels() {
+    return { ...this.costs };
+  }
+
+  /**
+   * Estimate cost savings by using recommended model vs default
+   * @param {string} task - Task description
+   * @param {string} defaultModel - Default model to compare against
+   * @returns {object} Savings information
+   */
+  estimateSavings(task, defaultModel = 'sonnet') {
+    const recommended = this.dispatch(task);
+    const recommendedCost = this.getModelCost(recommended);
+    const defaultCost = this.getModelCost(defaultModel);
+    const savings = ((defaultCost - recommendedCost) / defaultCost) * 100;
+
+    return {
+      recommended,
+      recommendedCost,
+      defaultCost,
+      savingsPercent: Math.round(savings),
+      shouldSwitch: savings > 0
+    };
+  }
+}
+
+module.exports = EconomicDispatcher;

package/src/core/worker-pool/worker-pool.js

@@ -0,0 +1,194 @@
+/**
+ * Worker for executing tasks asynchronously
+ * Represents a single worker in the pool
+ * 
+ * @class Worker
+ */
+class Worker {
+  /**
+   * Create a new Worker
+   * @param {number} id - Unique worker identifier
+   */
+  constructor(id) {
+    this.id = id;
+    this.status = 'idle'; // idle, busy, error
+    this.currentTask = null;
+  }
+
+  /**
+   * Execute a task
+   * @param {Function|object} task - Task to execute (function or object with execute method)
+   * @returns {Promise<*>} Task result
+   */
+  async execute(task) {
+    this.status = 'busy';
+    this.currentTask = task;
+
+    try {
+      let result;
+      
+      if (typeof task === 'function') {
+        result = await task();
+      } else if (task && typeof task.execute === 'function') {
+        result = await task.execute();
+      } else {
+        throw new Error('Task must be a function or have an execute method');
+      }
+
+      this.status = 'idle';
+      this.currentTask = null;
+      return result;
+    } catch (error) {
+      this.status = 'error';
+      this.currentTask = null;
+      throw error;
+    }
+  }
+}
+
+/**
+ * Worker Pool for managing parallel task execution
+ * Provides a pool of workers with automatic task queuing
+ * 
+ * @class WorkerPool
+ * @example
+ * const pool = new WorkerPool(3);
+ * const result = await pool.submitTask(async () => { return 'done'; });
+ */
+class WorkerPool {
+  /**
+   * Create a new WorkerPool
+   * @param {number} maxWorkers - Maximum number of concurrent workers
+   * @throws {Error} If maxWorkers is not a positive number
+   */
+  constructor(maxWorkers = 4) {
+    if (typeof maxWorkers !== 'number' || maxWorkers < 1) {
+      throw new Error('maxWorkers must be a positive number');
+    }
+
+    this.maxWorkers = maxWorkers;
+    this.workers = [];
+    this.taskQueue = [];
+    this.activeTasks = 0;
+    this.isShutdown = false;
+
+    // Initialize workers
+    for (let i = 0; i < maxWorkers; i++) {
+      this.workers.push(new Worker(i));
+    }
+  }
+
+  /**
+   * Submit a task to the pool
+   * @param {Function|object} task - Task to execute
+   * @returns {Promise<*>} Promise that resolves with task result
+   */
+  submitTask(task) {
+    if (this.isShutdown) {
+      return Promise.reject(new Error('Worker pool is shutdown'));
+    }
+
+    return new Promise((resolve, reject) => {
+      this.taskQueue.push({ task, resolve, reject });
+      this._processQueue();
+    });
+  }
+
+  /**
+   * Process the task queue
+   * @private
+   */
+  async _processQueue() {
+    // Find an idle worker
+    const idleWorker = this.workers.find(w => w.status === 'idle');
+
+    if (!idleWorker || this.taskQueue.length === 0) {
+      return;
+    }
+
+    const { task, resolve, reject } = this.taskQueue.shift();
+    this.activeTasks++;
+
+    try {
+      const result = await idleWorker.execute(task);
+      this.activeTasks--;
+      resolve(result);
+      
+      // Process next task if any
+      if (this.taskQueue.length > 0) {
+        this._processQueue();
+      }
+    } catch (error) {
+      this.activeTasks--;
+      reject(error);
+      
+      // Reset worker to idle on error
+      idleWorker.status = 'idle';
+      
+      // Continue processing queue
+      if (this.taskQueue.length > 0) {
+        this._processQueue();
+      }
+    }
+  }
+
+  /**
+   * Get number of active workers
+   * @returns {number} Number of busy workers
+   */
+  getActiveWorkers() {
+    return this.workers.filter(w => w.status === 'busy').length;
+  }
+
+  /**
+   * Get number of idle workers
+   * @returns {number} Number of idle workers
+   */
+  getIdleWorkers() {
+    return this.workers.filter(w => w.status === 'idle').length;
+  }
+
+  /**
+   * Get current queue size
+   * @returns {number} Number of queued tasks
+   */
+  getQueueSize() {
+    return this.taskQueue.length;
+  }
+
+  /**
+   * Get pool statistics
+   * @returns {object} Pool statistics
+   */
+  getStats() {
+    return {
+      totalWorkers: this.workers.length,
+      activeWorkers: this.getActiveWorkers(),
+      idleWorkers: this.getIdleWorkers(),
+      queueSize: this.getQueueSize(),
+      activeTasks: this.activeTasks
+    };
+  }
+
+  /**
+   * Shutdown the pool gracefully
+   * Waits for active tasks to complete
+   * @returns {Promise<void>}
+   */
+  async shutdown() {
+    this.isShutdown = true;
+
+    // Wait for all active tasks to complete
+    while (this.activeTasks > 0) {
+      await new Promise(resolve => setTimeout(resolve, 10));
+    }
+
+    // Clear queue and reject pending tasks
+    while (this.taskQueue.length > 0) {
+      const { reject } = this.taskQueue.shift();
+      reject(new Error('Worker pool shutdown'));
+    }
+  }
+}
+
+module.exports = { WorkerPool, Worker };