sinapse-ai 1.19.2 → 1.20.1

package/.sinapse-ai/core/execution/wave-executor.js

@@ -1,401 +0,0 @@
-/**
- * Wave Executor
- * Story 10.1 - Parallel Agent Execution
- *
- * Executes task waves in parallel, leveraging the WaveAnalyzer
- * for dependency-aware scheduling.
- */
-
-const EventEmitter = require('events');
-const _path = require('path');
-
-// Import dependencies with fallbacks
-let WaveAnalyzer;
-try {
-  // Named export — the module exports { WaveAnalyzer, ... }. Requiring the
-  // whole object and calling `new WaveAnalyzer()` (line ~37) would throw
-  // "not a constructor". Destructure the class.
-  ({ WaveAnalyzer } = require('../../workflow-intelligence/engine/wave-analyzer'));
-} catch {
-  WaveAnalyzer = null;
-}
-
-let RateLimitManager;
-try {
-  RateLimitManager = require('./rate-limit-manager');
-} catch {
-  RateLimitManager = null;
-}
-
-class WaveExecutor extends EventEmitter {
-  constructor(config = {}) {
-    super();
-
-    // Configuration
-    this.maxParallel = config.maxParallel || 4;
-    this.taskTimeout = config.taskTimeout || 10 * 60 * 1000; // 10 minutes
-    this.continueOnNonCriticalFailure = config.continueOnNonCriticalFailure !== false;
-
-    // Dependencies
-    this.waveAnalyzer = config.waveAnalyzer || (WaveAnalyzer ? new WaveAnalyzer() : null);
-    this.taskExecutor = config.taskExecutor || null;
-    this.rateLimitManager =
-      config.rateLimitManager || (RateLimitManager ? new RateLimitManager() : null);
-
-    // State
-    this.activeExecutions = new Map();
-    this.completedWaves = [];
-    this.currentWaveIndex = 0;
-  }
-
-  /**
-   * Execute all waves for a workflow
-   * @param {string} workflowId - Workflow identifier
-   * @param {Object} context - Execution context
-   * @returns {Promise<Object>} - Execution results
-   */
-  async executeWaves(workflowId, context = {}) {
-    const startTime = Date.now();
-
-    // Get wave analysis
-    let analysis;
-    if (this.waveAnalyzer) {
-      analysis = this.waveAnalyzer.analyze(workflowId);
-    } else {
-      // Fallback: single wave with all tasks
-      analysis = {
-        waves: [
-          {
-            index: 1,
-            tasks: context.tasks || [],
-          },
-        ],
-      };
-    }
-
-    if (!analysis.waves || analysis.waves.length === 0) {
-      return {
-        workflowId,
-        success: true,
-        waves: [],
-        totalDuration: 0,
-        message: 'No waves to execute',
-      };
-    }
-
-    this.emit('execution_started', { workflowId, totalWaves: analysis.waves.length });
-
-    const results = [];
-    let aborted = false;
-
-    for (const wave of analysis.waves) {
-      if (aborted) break;
-
-      this.currentWaveIndex = wave.index;
-      this.emit('wave_started', {
-        waveIndex: wave.index,
-        tasks: wave.tasks.map((t) => ({ id: t.id, description: t.description })),
-        totalTasks: wave.tasks.length,
-      });
-
-      const waveResult = await this.executeWave(wave, context);
-
-      results.push({
-        wave: wave.index,
-        results: waveResult,
-        allSucceeded: waveResult.every((r) => r.success),
-        duration: waveResult.reduce((sum, r) => sum + (r.duration || 0), 0),
-      });
-
-      this.emit('wave_completed', {
-        waveIndex: wave.index,
-        results: waveResult,
-        success: waveResult.every((r) => r.success),
-      });
-
-      // Check if we should continue
-      const criticalFailed = waveResult.some((r) => !r.success && r.critical);
-      if (criticalFailed) {
-        this.emit('wave_failed', {
-          waveIndex: wave.index,
-          reason: 'critical_task_failed',
-          failedTasks: waveResult.filter((r) => !r.success && r.critical),
-        });
-
-        if (!this.continueOnNonCriticalFailure) {
-          aborted = true;
-        }
-      }
-    }
-
-    const totalDuration = Date.now() - startTime;
-
-    const executionResult = {
-      workflowId,
-      waves: results,
-      success: !aborted && results.every((w) => w.allSucceeded),
-      aborted,
-      totalDuration,
-      metrics: this.calculateMetrics(results),
-    };
-
-    this.emit('execution_completed', executionResult);
-
-    return executionResult;
-  }
-
-  /**
-   * Execute a single wave with parallel task execution
-   * @param {Object} wave - Wave definition
-   * @param {Object} context - Execution context
-   * @returns {Promise<Array>} - Task results
-   */
-  async executeWave(wave, context) {
-    const tasks = wave.tasks || [];
-
-    if (tasks.length === 0) {
-      return [];
-    }
-
-    // Split tasks into chunks based on maxParallel
-    const chunks = this.chunkArray(tasks, this.maxParallel);
-    const allResults = [];
-
-    for (const chunk of chunks) {
-      // Execute chunk in parallel
-      const promises = chunk.map((task) => this.executeTaskWithTimeout(task, context));
-
-      const chunkResults = await Promise.allSettled(promises);
-
-      // Process results
-      for (let i = 0; i < chunkResults.length; i++) {
-        const result = chunkResults[i];
-        const task = chunk[i];
-
-        if (result.status === 'fulfilled') {
-          allResults.push({
-            taskId: task.id,
-            success: result.value.success,
-            result: result.value,
-            critical: task.critical || false,
-            duration: result.value.duration || 0,
-          });
-        } else {
-          allResults.push({
-            taskId: task.id,
-            success: false,
-            error: result.reason?.message || 'Unknown error',
-            critical: task.critical || false,
-            duration: 0,
-          });
-        }
-
-        this.emit('task_completed', {
-          taskId: task.id,
-          success: result.status === 'fulfilled' && result.value?.success,
-          waveIndex: wave.index,
-        });
-      }
-    }
-
-    return allResults;
-  }
-
-  /**
-   * Execute a task with timeout
-   * @param {Object} task - Task to execute
-   * @param {Object} context - Execution context
-   * @returns {Promise<Object>} - Task result
-   */
-  async executeTaskWithTimeout(task, context) {
-    const startTime = Date.now();
-
-    // Track active execution
-    this.activeExecutions.set(task.id, {
-      task,
-      startTime,
-      status: 'running',
-    });
-
-    this.emit('task_started', { taskId: task.id, description: task.description });
-
-    try {
-      // Create timeout promise
-      const timeoutPromise = new Promise((_, reject) => {
-        setTimeout(() => {
-          reject(new Error(`Task ${task.id} timed out after ${this.taskTimeout}ms`));
-        }, this.taskTimeout);
-      });
-
-      // Execute task with rate limiting if available
-      let executionPromise;
-      if (this.taskExecutor) {
-        if (this.rateLimitManager) {
-          executionPromise = this.rateLimitManager.executeWithRetry(
-            () => this.taskExecutor(task, context),
-            { taskId: task.id },
-          );
-        } else {
-          executionPromise = this.taskExecutor(task, context);
-        }
-      } else {
-        // Default executor (no-op)
-        executionPromise = this.defaultExecutor(task, context);
-      }
-
-      // Race between execution and timeout
-      const result = await Promise.race([executionPromise, timeoutPromise]);
-
-      // Update active execution
-      this.activeExecutions.set(task.id, {
-        task,
-        startTime,
-        endTime: Date.now(),
-        status: 'completed',
-        success: result.success,
-      });
-
-      return {
-        ...result,
-        duration: Date.now() - startTime,
-      };
-    } catch (error) {
-      // Update active execution
-      this.activeExecutions.set(task.id, {
-        task,
-        startTime,
-        endTime: Date.now(),
-        status: 'failed',
-        error: error.message,
-      });
-
-      return {
-        success: false,
-        error: error.message,
-        duration: Date.now() - startTime,
-      };
-    } finally {
-      // Remove from active after a delay (for monitoring)
-      setTimeout(() => {
-        this.activeExecutions.delete(task.id);
-      }, 5000);
-    }
-  }
-
-  /**
-   * Default task executor (placeholder)
-   * @param {Object} task - Task to execute
-   * @param {Object} context - Execution context
-   * @returns {Promise<Object>} - Execution result
-   */
-  async defaultExecutor(task, _context) {
-    // This should be overridden or configured
-    console.log(`[WaveExecutor] Executing task: ${task.id}`);
-    return { success: true, output: 'Default executor - no action taken' };
-  }
-
-  /**
-   * Split array into chunks
-   * @param {Array} array - Array to split
-   * @param {number} size - Chunk size
-   * @returns {Array<Array>} - Chunked arrays
-   */
-  chunkArray(array, size) {
-    const chunks = [];
-    for (let i = 0; i < array.length; i += size) {
-      chunks.push(array.slice(i, i + size));
-    }
-    return chunks;
-  }
-
-  /**
-   * Calculate execution metrics
-   * @param {Array} waveResults - Results from all waves
-   * @returns {Object} - Metrics
-   */
-  calculateMetrics(waveResults) {
-    const allTasks = waveResults.flatMap((w) => w.results);
-    const successful = allTasks.filter((t) => t.success).length;
-    const failed = allTasks.filter((t) => !t.success).length;
-    const totalDuration = allTasks.reduce((sum, t) => sum + (t.duration || 0), 0);
-
-    // Calculate wall time (actual elapsed time)
-    const wallTime = waveResults.reduce((sum, w) => {
-      const maxDuration = Math.max(...w.results.map((r) => r.duration || 0));
-      return sum + maxDuration;
-    }, 0);
-
-    return {
-      totalTasks: allTasks.length,
-      successful,
-      failed,
-      successRate: allTasks.length > 0 ? (successful / allTasks.length) * 100 : 100,
-      totalDuration,
-      wallTime,
-      parallelEfficiency: wallTime > 0 ? totalDuration / wallTime : 1,
-      totalWaves: waveResults.length,
-    };
-  }
-
-  /**
-   * Get current execution status
-   * @returns {Object} - Current status
-   */
-  getStatus() {
-    const active = [];
-    for (const [taskId, execution] of this.activeExecutions) {
-      active.push({
-        taskId,
-        status: execution.status,
-        elapsed: Date.now() - execution.startTime,
-      });
-    }
-
-    return {
-      currentWave: this.currentWaveIndex,
-      activeExecutions: active,
-      completedWaves: this.completedWaves.length,
-    };
-  }
-
-  /**
-   * Format status for CLI output
-   * @returns {string} - Formatted status
-   */
-  formatStatus() {
-    const status = this.getStatus();
-
-    let output = '🌊 Wave Executor Status\n';
-    output += '━'.repeat(40) + '\n\n';
-
-    output += `Current Wave: ${status.currentWave}\n`;
-    output += `Completed Waves: ${status.completedWaves}\n`;
-    output += `Active Executions: ${status.activeExecutions.length}\n\n`;
-
-    if (status.activeExecutions.length > 0) {
-      output += '**Active Tasks:**\n';
-      for (const exec of status.activeExecutions) {
-        const elapsed = Math.round(exec.elapsed / 1000);
-        const icon = exec.status === 'running' ? '🔄' : exec.status === 'completed' ? '✅' : '❌';
-        output += `  ${icon} ${exec.taskId} - ${elapsed}s\n`;
-      }
-    }
-
-    return output;
-  }
-
-  /**
-   * Cancel all active executions
-   */
-  cancelAll() {
-    for (const [taskId, execution] of this.activeExecutions) {
-      execution.status = 'cancelled';
-      this.emit('task_cancelled', { taskId });
-    }
-    this.emit('execution_cancelled', { reason: 'user_requested' });
-  }
-}
-
-module.exports = WaveExecutor;
-module.exports.WaveExecutor = WaveExecutor;
-

package/.sinapse-ai/development/tasks/waves.md

@@ -1,205 +0,0 @@
-# Task: `*waves` - Wave Analysis
-
-<!-- Story: WIS-4 - Wave Analysis Engine -->
-<!-- Version: 1.0.0 -->
-<!-- Created: 2025-12-25 -->
-
-## Overview
-
-Analyzes workflow task dependencies to identify waves of tasks that can execute in parallel. Shows optimization opportunities and critical path.
-
-## Usage
-
-```
-*waves [workflow-name] [options]
-```
-
-## Arguments
-
-| Argument | Type | Required | Description |
-|----------|------|----------|-------------|
-| `workflow` | string | No | Workflow name to analyze (default: auto-detect from context) |
-
-## Options
-
-| Option | Type | Description |
-|--------|------|-------------|
-| `--visual` | flag | Show ASCII visualization of wave structure |
-| `--json` | flag | Output as JSON format |
-| `--help` | flag | Show this help message |
-
-## Examples
-
-```bash
-# Analyze current workflow (auto-detected)
-*waves
-
-# Analyze specific workflow
-*waves story_development
-
-# Visual ASCII representation
-*waves story_development --visual
-
-# JSON output for programmatic use
-*waves story_development --json
-```
-
-## Output
-
-### Standard Output
-
-```
-Wave Analysis: story_development
-════════════════════════════════════════
-
-Wave 1 (parallel):
-  └─ read-story
-  └─ setup-branch
-
-Wave 2:
-  └─ implement
-
-Wave 3 (parallel):
-  └─ write-tests
-  └─ update-docs
-
-Wave 4:
-  └─ run-tests
-
-Total Sequential: 57min
-Total Parallel:   42min
-Optimization:     26% faster
-
-Critical Path: read-story → implement → write-tests → run-tests
-```
-
-### Visual Output (--visual)
-
-```
-Wave Analysis: story_development
-════════════════════════════════════════
-
-Wave 1 ──┬── read-story (5min)
-         └── setup-branch (2min)
-              │
-Wave 2 ──────── implement (30min)
-              │
-Wave 3 ──┬── write-tests (10min)
-         └── update-docs (5min)
-              │
-Wave 4 ──────── run-tests (5min)
-
-Total Sequential: 57min
-Total Parallel:   42min
-Optimization:     26% faster
-
-Critical Path: read-story → implement → write-tests → run-tests
-```
-
-### JSON Output (--json)
-
-```json
-{
-  "workflowId": "story_development",
-  "totalTasks": 6,
-  "waves": [
-    {
-      "waveNumber": 1,
-      "tasks": ["read-story", "setup-branch"],
-      "parallel": true,
-      "dependsOn": [],
-      "estimatedDuration": "5min"
-    }
-  ],
-  "optimizationGain": "26%",
-  "criticalPath": ["read-story", "implement", "write-tests", "run-tests"]
-}
-```
-
-## Circular Dependency Handling
-
-If circular dependencies are detected, the command will show an error:
-
-```
-❌ Circular Dependency Detected!
-
-Cycle: task-a → task-b → task-c → task-a
-
-Suggestion: Remove dependency from task-c to task-a
-```
-
-## Integration
-
-### With `*next` Command
-
-The `*waves` analysis integrates with the `*next` command to show wave context:
-
-```
-🧭 Workflow: story_development
-📍 State: in_development (Wave 2 of 4)
-
-Current Wave (parallel):
-  ├─ `*write-tests` - Write unit tests ⏳
-  └─ `*update-docs` - Update documentation ⏳
-
-Next Wave (after current completes):
-  └─ `*run-tests` - Execute test suite
-
-💡 Tip: Run both current wave tasks in parallel to save ~15min
-```
-
-## Implementation
-
-```javascript
-// Task implementation
-const { analyzeWaves, createWaveAnalyzer } = require('.sinapse-ai/workflow-intelligence');
-
-async function executeWaves(args, options) {
-  const workflowId = args[0] || await detectCurrentWorkflow();
-  const analyzer = createWaveAnalyzer();
-
-  try {
-    const result = analyzer.analyzeWaves(workflowId);
-    const output = analyzer.formatOutput(result, {
-      visual: options.visual,
-      json: options.json
-    });
-    console.log(output);
-  } catch (error) {
-    if (error.name === 'CircularDependencyError') {
-      console.error('❌ Circular Dependency Detected!\n');
-      console.error(`Cycle: ${error.cycle.join(' → ')}`);
-      console.error(`\nSuggestion: ${error.getSuggestion()}`);
-      process.exit(1);
-    }
-    throw error;
-  }
-}
-```
-
-## Performance
-
-| Workflow Size | Analysis Time |
-|--------------|---------------|
-| Small (5 tasks) | <10ms |
-| Medium (20 tasks) | <30ms |
-| Large (50 tasks) | <50ms |
-
-## Related Commands
-
-- `*next` - Get next command suggestions (integrates wave context)
-- `*workflow` - Show workflow status
-- `*help` - Show all available commands
-
-## Agent Integration
-
-This task is available for:
-- `@developer` - Developer Agent
-
----
-
-## Change Log
-
-| Version | Date | Changes |
-|---------|------|---------|
-| 1.0.0 | 2025-12-25 | Initial implementation (WIS-4) |

package/.sinapse-ai/lib/build.json

@@ -1 +0,0 @@
-{"built": true}