create-byan-agent 2.0.1 → 2.1.1

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
+};