create-byan-agent 2.0.1 → 2.1.1

package/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/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('_byan/workflows/create-agent/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
+};

package/src/observability/dashboard/dashboard.js

@@ -0,0 +1,191 @@
+/**
+ * Dashboard for BYAN v2.0
+ * Provides formatted console output for system status, metrics, and logs
+ * 
+ * @module observability/dashboard/dashboard
+ * @version 2.0.0-HYPER-MVP
+ */
+
+/**
+ * Print dashboard to console with formatted output
+ * 
+ * @param {Object} data - Dashboard data
+ * @param {Object} [data.metrics={}] - Metrics from MetricsCollector
+ * @param {Array} [data.logs=[]] - Recent logs from StructuredLogger
+ * @param {Array} [data.workers=[]] - Active workers
+ * @param {Object} [data.status={}] - System status
+ * @returns {string} Formatted dashboard output
+ * 
+ * @example
+ * const output = printDashboard({
+ *   metrics: metricsCollector.getMetrics(),
+ *   logs: logger.getLogs().slice(-5),
+ *   workers: pool.getActiveWorkers(),
+ *   status: { uptime: 3600, version: '2.0.0' }
+ * });
+ * console.log(output);
+ */
+function printDashboard(data = {}) {
+  // Handle null data
+  if (!data) {
+    data = {};
+  }
+  const { metrics = {}, logs = [], workers = [], status = {} } = data;
+
+  const lines = [];
+
+  // Header
+  lines.push('╔═══════════════════════════════════════════════════════════╗');
+  lines.push('║           BYAN v2.0 Dashboard                             ║');
+  lines.push('╚═══════════════════════════════════════════════════════════╝');
+  lines.push('');
+
+  // Status Section
+  lines.push('┌─ Status ──────────────────────────────────────────────────┐');
+  if (Object.keys(status).length > 0) {
+    Object.entries(status).forEach(([key, value]) => {
+      lines.push(`│ ${_padRight(key, 15)}: ${value}`);
+    });
+  } else {
+    lines.push('│ No status information available');
+  }
+  lines.push('└───────────────────────────────────────────────────────────┘');
+  lines.push('');
+
+  // Metrics Section
+  lines.push('┌─ Metrics ─────────────────────────────────────────────────┐');
+  const metricsArray = Object.entries(metrics);
+  if (metricsArray.length > 0) {
+    metricsArray.slice(0, 10).forEach(([key, metric]) => {
+      const displayKey = key.length > 30 ? key.substring(0, 27) + '...' : key;
+      const displayValue = _formatMetricValue(metric.value);
+      lines.push(`│ ${_padRight(displayKey, 30)}: ${displayValue}`);
+    });
+    if (metricsArray.length > 10) {
+      lines.push(`│ ... and ${metricsArray.length - 10} more metrics`);
+    }
+  } else {
+    lines.push('│ No metrics available');
+  }
+  lines.push('└───────────────────────────────────────────────────────────┘');
+  lines.push('');
+
+  // Recent Logs Section
+  lines.push('┌─ Recent Logs ─────────────────────────────────────────────┐');
+  if (logs.length > 0) {
+    logs.slice(-5).forEach((log) => {
+      const level = _padRight(`[${log.level.toUpperCase()}]`, 8);
+      const message = log.message.length > 40 ? log.message.substring(0, 37) + '...' : log.message;
+      lines.push(`│ ${level} ${message}`);
+    });
+  } else {
+    lines.push('│ No recent logs');
+  }
+  lines.push('└───────────────────────────────────────────────────────────┘');
+  lines.push('');
+
+  // Workers Section
+  lines.push('┌─ Workers ─────────────────────────────────────────────────┐');
+  if (workers.length > 0) {
+    workers.forEach((worker) => {
+      const id = _padRight(`Worker ${worker.id}`, 15);
+      const status = worker.status || 'unknown';
+      lines.push(`│ ${id}: ${status}`);
+    });
+  } else {
+    lines.push('│ No active workers');
+  }
+  lines.push('└───────────────────────────────────────────────────────────┘');
+
+  return lines.join('\n');
+}
+
+/**
+ * Pad string to right with spaces
+ * 
+ * @private
+ * @param {string} str - String to pad
+ * @param {number} length - Target length
+ * @returns {string} Padded string
+ */
+function _padRight(str, length) {
+  const s = String(str);
+  return s.length >= length ? s : s + ' '.repeat(length - s.length);
+}
+
+/**
+ * Format metric value for display
+ * 
+ * @private
+ * @param {number} value - Metric value
+ * @returns {string} Formatted value
+ */
+function _formatMetricValue(value) {
+  if (typeof value !== 'number') {
+    return String(value);
+  }
+
+  // Format large numbers with separators
+  if (value >= 1000) {
+    return value.toLocaleString();
+  }
+
+  // Format decimals
+  if (value % 1 !== 0) {
+    return value.toFixed(2);
+  }
+
+  return String(value);
+}
+
+/**
+ * Generate summary dashboard
+ * 
+ * @param {Object} data - Dashboard data
+ * @returns {string} Summary output
+ * 
+ * @example
+ * const summary = generateSummary({
+ *   metrics: metricsCollector.getStats(),
+ *   logs: logger.getStats()
+ * });
+ */
+function generateSummary(data = {}) {
+  // Handle null data
+  if (!data) {
+    data = {};
+  }
+  const { metrics = {}, logs = {} } = data;
+
+  const lines = [];
+
+  lines.push('═══ BYAN v2.0 Summary ═══');
+  lines.push('');
+
+  if (metrics.total !== undefined) {
+    lines.push(`Metrics: ${metrics.total} total`);
+    if (metrics.byType) {
+      Object.entries(metrics.byType).forEach(([type, count]) => {
+        lines.push(`  - ${type}: ${count}`);
+      });
+    }
+  }
+
+  lines.push('');
+
+  if (logs.debug !== undefined || logs.info !== undefined) {
+    const totalLogs = (logs.debug || 0) + (logs.info || 0) + (logs.warn || 0) + (logs.error || 0);
+    lines.push(`Logs: ${totalLogs} total`);
+    lines.push(`  - debug: ${logs.debug || 0}`);
+    lines.push(`  - info: ${logs.info || 0}`);
+    lines.push(`  - warn: ${logs.warn || 0}`);
+    lines.push(`  - error: ${logs.error || 0}`);
+  }
+
+  return lines.join('\n');
+}
+
+module.exports = {
+  printDashboard,
+  generateSummary,
+};