create-byan-agent 2.7.7 → 2.7.9

package/install/src/core/dispatcher/dispatcher.js

@@ -1,135 +0,0 @@
-/**
- * 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

@@ -1,194 +0,0 @@
-/**
- * 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

@@ -1,220 +0,0 @@
-/**
- * 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

@@ -1,139 +0,0 @@
-/**
- * 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
-};