create-byan-agent 2.7.4 → 2.7.7

package/install/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/install/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 };

package/install/src/core/workflow/workflow-executor.js

@@ -0,0 +1,220 @@
+/**
+ * Workflow Executor for BYAN v2.0
+ * Executes declarative YAML workflows with sequential step execution
+ * 
+ * @module core/workflow/workflow-executor
+ * @version 2.0.0-HYPER-MVP
+ */
+
+/**
+ * Workflow Executor - Orchestrates multi-step workflows
+ * 
+ * @class WorkflowExecutor
+ * @example
+ * const executor = new WorkflowExecutor();
+ * const result = await executor.executeWorkflow(workflow);
+ */
+class WorkflowExecutor {
+  constructor() {
+    this.currentWorkflow = null;
+    this.status = 'idle';
+    this.results = [];
+    this.isPaused = false;
+  }
+
+  /**
+   * Execute a workflow with sequential steps
+   * 
+   * @param {Object} workflow - Workflow configuration
+   * @param {string} workflow.name - Workflow name
+   * @param {Array<Object>} workflow.steps - Array of steps
+   * @returns {Promise<Object>} Execution result
+   * 
+   * @example
+   * const result = await executor.executeWorkflow({
+   *   name: 'test-workflow',
+   *   steps: [
+   *     { id: 'step1', action: 'task1' },
+   *     { id: 'step2', action: 'task2' }
+   *   ]
+   * });
+   */
+  async executeWorkflow(workflow) {
+    if (!workflow) {
+      throw new Error('Workflow is required');
+    }
+
+    if (!workflow.name) {
+      throw new Error('Workflow name is required');
+    }
+
+    if (!Array.isArray(workflow.steps) || workflow.steps.length === 0) {
+      throw new Error('Workflow must have at least one step');
+    }
+
+    this.currentWorkflow = workflow;
+    this.status = 'running';
+    this.results = [];
+    this.isPaused = false;
+
+    const startTime = Date.now();
+    let stepsCompleted = 0;
+    let hasError = false;
+
+    try {
+      for (const step of workflow.steps) {
+        if (this.isPaused) {
+          this.status = 'paused';
+          return {
+            success: false,
+            paused: true,
+            stepsCompleted,
+            message: 'Workflow paused',
+          };
+        }
+
+        // Validate step
+        if (!step.id) {
+          throw new Error('Step id is required');
+        }
+
+        // Execute step (stub simulation)
+        const stepStartTime = Date.now();
+        const stepResult = await this._executeStep(step);
+        const stepDuration = Date.now() - stepStartTime;
+
+        this.results.push({
+          stepId: step.id,
+          action: step.action,
+          duration: stepDuration,
+          result: stepResult,
+          timestamp: new Date().toISOString(),
+        });
+
+        stepsCompleted++;
+      }
+
+      const totalDuration = Date.now() - startTime;
+      this.status = 'completed';
+
+      return {
+        success: true,
+        workflowName: workflow.name,
+        stepsCompleted,
+        totalSteps: workflow.steps.length,
+        duration: totalDuration,
+        results: this.results,
+        timestamp: new Date().toISOString(),
+      };
+
+    } catch (error) {
+      this.status = 'error';
+      hasError = true;
+
+      return {
+        success: false,
+        workflowName: workflow.name,
+        stepsCompleted,
+        totalSteps: workflow.steps.length,
+        error: error.message,
+        results: this.results,
+      };
+    }
+  }
+
+  /**
+   * Execute a single step (stub implementation)
+   * 
+   * @private
+   * @param {Object} step - Step configuration
+   * @returns {Promise<Object>} Step result
+   */
+  async _executeStep(step) {
+    // Simulate async execution
+    await new Promise((resolve) => setTimeout(resolve, 10));
+
+    return {
+      status: 'completed',
+      action: step.action,
+      output: `Result of ${step.action}`,
+    };
+  }
+
+  /**
+   * Get current execution status
+   * 
+   * @returns {Object} Status information
+   * 
+   * @example
+   * const status = executor.getExecutionStatus();
+   * console.log(status.status); // 'idle' | 'running' | 'paused' | 'completed' | 'error'
+   */
+  getExecutionStatus() {
+    return {
+      status: this.status,
+      currentWorkflow: this.currentWorkflow?.name || null,
+      stepsCompleted: this.results.length,
+      totalSteps: this.currentWorkflow?.steps?.length || 0,
+      isPaused: this.isPaused,
+    };
+  }
+
+  /**
+   * Pause workflow execution
+   * 
+   * @returns {void}
+   * 
+   * @example
+   * executor.pause();
+   */
+  pause() {
+    if (this.status === 'running') {
+      this.isPaused = true;
+      this.status = 'paused';
+    }
+  }
+
+  /**
+   * Resume workflow execution
+   * 
+   * @returns {void}
+   * 
+   * @example
+   * executor.resume();
+   */
+  resume() {
+    if (this.status === 'paused') {
+      this.isPaused = false;
+      this.status = 'running';
+    }
+  }
+
+  /**
+   * Get workflow execution results
+   * 
+   * @returns {Array<Object>} Array of step results
+   * 
+   * @example
+   * const results = executor.getResults();
+   * results.forEach(result => {
+   *   console.log(`Step ${result.stepId}: ${result.result.status}`);
+   * });
+   */
+  getResults() {
+    return [...this.results];
+  }
+
+  /**
+   * Reset executor to initial state
+   * 
+   * @returns {void}
+   */
+  reset() {
+    this.currentWorkflow = null;
+    this.status = 'idle';
+    this.results = [];
+    this.isPaused = false;
+  }
+}
+
+module.exports = { WorkflowExecutor };

package/install/src/index.js

@@ -0,0 +1,139 @@
+/**
+ * BYAN v2.0 - Entry Point
+ * 
+ * Architecture 4 Pilliers:
+ * - Agent: Expertise (modèles puissants)
+ * - Context: State management hiérarchique
+ * - Workflow: Orchestration déclarative
+ * - Worker: Exécution simple (modèles légers)
+ * 
+ * @module byan-v2
+ * @version 2.0.0-alpha.1
+ */
+
+// Core Components
+const ContextLayer = require('./core/context/context');
+const SimpleCache = require('./core/cache/cache');
+const EconomicDispatcher = require('./core/dispatcher/dispatcher');
+const { WorkerPool, Worker } = require('./core/worker-pool/worker-pool');
+const { WorkflowExecutor } = require('./core/workflow/workflow-executor');
+
+// Observability Components
+const { StructuredLogger } = require('./observability/logger/structured-logger');
+const { MetricsCollector } = require('./observability/metrics/metrics-collector');
+const { printDashboard, generateSummary } = require('./observability/dashboard/dashboard');
+
+// Dashboard wrapper class for easy integration
+class Dashboard {
+  constructor(metrics, logger = null, workerPool = null) {
+    this.metrics = metrics;
+    this.logger = logger;
+    this.workerPool = workerPool;
+  }
+
+  render() {
+    return printDashboard({
+      metrics: this.metrics.getMetrics(),
+      logs: this.logger ? this.logger.getLogs() : [],
+      workers: this.workerPool ? this.workerPool.workers.map((w, i) => ({ id: w.id, status: w.status })) : [],
+      status: { version: '2.0.0-alpha.1' }
+    });
+  }
+
+  renderSummary() {
+    return generateSummary({
+      metrics: this.metrics.getStats ? this.metrics.getStats() : {},
+      logs: this.logger ? this.logger.getStats() : {}
+    });
+  }
+}
+
+/**
+ * Factory function pour initialiser BYAN v2.0
+ * 
+ * @param {Object} [options={}] - Options de configuration
+ * @param {number} [options.workerCount=2] - Nombre de workers
+ * @param {number} [options.cacheMaxSize=50] - Taille max cache (MB)
+ * @param {Object} [options.loggerOptions] - Options pour logger
+ * @returns {Object} Instance BYAN v2.0 configurée
+ * 
+ * @example
+ * const byan = createByanInstance({ workerCount: 2 });
+ * await byan.executeWorkflow('_bmad/workflows/create-prd/workflow.yaml');
+ */
+function createByanInstance(options = {}) {
+  const {
+    workerCount = 2,
+    cacheMaxSize = 50,
+    loggerOptions = {}
+  } = options;
+
+  // Initialize core components
+  const cache = new SimpleCache({ maxSizeMB: cacheMaxSize });
+  const contextLayer = new ContextLayer();  // Note: Current implementation doesn't use cache yet
+  const logger = new StructuredLogger(loggerOptions);
+  const metrics = new MetricsCollector();
+  const workerPool = new WorkerPool(workerCount);
+  const dashboard = new Dashboard(metrics, logger, workerPool);
+  const dispatcher = new EconomicDispatcher(workerPool);
+  const workflowExecutor = new WorkflowExecutor(contextLayer, dispatcher, logger);
+
+  return {
+    // Core
+    contextLayer,
+    cache,
+    dispatcher,
+    workerPool,
+    workflowExecutor,
+    
+    // Observability
+    logger,
+    metrics,
+    dashboard,
+    
+    // Convenience methods
+    async executeWorkflow(workflowPath, contextId = null) {
+      let context = {};
+      if (contextId) {
+        context = await contextLayer.loadContext('story', contextId);
+      }
+      return workflowExecutor.execute(workflowPath, context);
+    },
+    
+    async loadContext(level, id = null) {
+      return contextLayer.loadContext(level, id);
+    },
+    
+    getMetrics() {
+      return metrics.getMetrics();
+    },
+    
+    showDashboard() {
+      return dashboard.render();
+    },
+    
+    async shutdown() {
+      await workerPool.shutdown();
+      logger.info('BYAN v2.0 shutdown complete');
+    }
+  };
+}
+
+// Named exports (pour usage avancé)
+module.exports = {
+  // Factory
+  createByanInstance,
+  
+  // Core Components
+  ContextLayer,
+  SimpleCache,
+  EconomicDispatcher,
+  WorkerPool,
+  Worker,
+  WorkflowExecutor,
+  
+  // Observability
+  StructuredLogger,
+  MetricsCollector,
+  Dashboard
+};