scene-capability-engine 3.0.0

package/lib/collab/dependency-manager.js

@@ -0,0 +1,280 @@
+/**
+ * DependencyManager handles dependency graph analysis and validation
+ */
+class DependencyManager {
+  constructor(metadataManager) {
+    this.metadataManager = metadataManager;
+  }
+
+  /**
+   * Build dependency graph from specs
+   * @param {Array<string>} specNames - Optional list of spec names (defaults to all)
+   * @returns {Promise<Object>} Graph with nodes and edges
+   */
+  async buildDependencyGraph(specNames = null) {
+    const allSpecs = await this.metadataManager.listAllMetadata();
+    const specsToInclude = specNames 
+      ? allSpecs.filter(s => specNames.includes(s.name))
+      : allSpecs;
+
+    const nodes = [];
+    const edges = [];
+
+    for (const { name, metadata } of specsToInclude) {
+      // Add node
+      nodes.push({
+        id: name,
+        status: metadata.status?.current || 'not-started',
+        kiroInstance: metadata.assignment?.kiroInstance || null,
+        type: metadata.type
+      });
+
+      // Add edges from dependencies
+      if (metadata.dependencies) {
+        for (const dep of metadata.dependencies) {
+          edges.push({
+            from: name,
+            to: dep.spec,
+            type: dep.type,
+            reason: dep.reason
+          });
+        }
+      }
+    }
+
+    return { nodes, edges };
+  }
+
+  /**
+   * Detect circular dependencies in graph
+   * @param {Object} graph - Graph with nodes and edges
+   * @returns {Array<string>|null} Cycle path if found, null otherwise
+   */
+  detectCircularDependencies(graph) {
+    const visited = new Set();
+    const recursionStack = new Set();
+    const path = [];
+
+    const hasCycle = (nodeId) => {
+      visited.add(nodeId);
+      recursionStack.add(nodeId);
+      path.push(nodeId);
+
+      // Get outgoing edges
+      const outgoing = graph.edges.filter(e => e.from === nodeId);
+      
+      for (const edge of outgoing) {
+        if (!visited.has(edge.to)) {
+          if (hasCycle(edge.to)) {
+            return true;
+          }
+        } else if (recursionStack.has(edge.to)) {
+          // Found cycle
+          path.push(edge.to);
+          return true;
+        }
+      }
+
+      recursionStack.delete(nodeId);
+      path.pop();
+      return false;
+    };
+
+    for (const node of graph.nodes) {
+      if (!visited.has(node.id)) {
+        if (hasCycle(node.id)) {
+          return path;
+        }
+      }
+    }
+
+    return null;
+  }
+
+  /**
+   * Get specs that are ready to start (all dependencies satisfied)
+   * @param {Object} graph - Graph with nodes and edges
+   * @returns {Array<string>} List of ready spec names
+   */
+
+  getReadySpecs(graph) {
+    const ready = [];
+
+    for (const node of graph.nodes) {
+      // Skip if already completed or in progress
+      if (node.status === 'completed' || node.status === 'in-progress') {
+        continue;
+      }
+
+      // Skip if blocked
+      if (node.status === 'blocked') {
+        continue;
+      }
+
+      // Get dependencies for this node
+      const dependencies = graph.edges.filter(e => e.from === node.id);
+      
+      // Check if all required dependencies are satisfied
+      const allSatisfied = dependencies.every(dep => {
+        // Optional dependencies don't block
+        if (dep.type === 'optional') {
+          return true;
+        }
+
+        // Find the dependency node
+        const depNode = graph.nodes.find(n => n.id === dep.to);
+        
+        if (!depNode) {
+          // Dependency not found - not ready
+          return false;
+        }
+
+        // For requires-completion, dependency must be completed
+        if (dep.type === 'requires-completion') {
+          return depNode.status === 'completed';
+        }
+
+        // For requires-interface, dependency must have interface defined
+        // (we'll check this in contract manager)
+        if (dep.type === 'requires-interface') {
+          return depNode.status === 'completed' || depNode.status === 'in-progress';
+        }
+
+        return false;
+      });
+
+      if (allSatisfied) {
+        ready.push(node.id);
+      }
+    }
+
+    return ready;
+  }
+
+  /**
+   * Get critical path (longest dependency chain)
+   * @param {Object} graph - Graph with nodes and edges
+   * @returns {Array<string>} Spec names in critical path
+   */
+  getCriticalPath(graph) {
+    const memo = new Map();
+
+    const getLongestPath = (nodeId) => {
+      if (memo.has(nodeId)) {
+        return memo.get(nodeId);
+      }
+
+      // Get incoming edges (dependencies)
+      const incoming = graph.edges.filter(e => e.to === nodeId);
+      
+      if (incoming.length === 0) {
+        memo.set(nodeId, [nodeId]);
+        return [nodeId];
+      }
+
+      let longestPath = [];
+      for (const edge of incoming) {
+        const path = getLongestPath(edge.from);
+        if (path.length > longestPath.length) {
+          longestPath = path;
+        }
+      }
+
+      const result = [...longestPath, nodeId];
+      memo.set(nodeId, result);
+      return result;
+    };
+
+    let criticalPath = [];
+    for (const node of graph.nodes) {
+      const path = getLongestPath(node.id);
+      if (path.length > criticalPath.length) {
+        criticalPath = path;
+      }
+    }
+
+    return criticalPath;
+  }
+
+  /**
+   * Validate a dependency relationship
+   * @param {string} fromSpec - Spec that depends on another
+   * @param {string} toSpec - Spec being depended on
+   * @param {string} type - Dependency type
+   * @returns {Promise<Object>} Validation result
+   */
+  async validateDependency(fromSpec, toSpec, type) {
+    // Check if specs exist
+    const fromMetadata = await this.metadataManager.readMetadata(fromSpec);
+    const toMetadata = await this.metadataManager.readMetadata(toSpec);
+
+    if (!fromMetadata) {
+      return {
+        valid: false,
+        error: `Spec '${fromSpec}' not found`
+      };
+    }
+
+    if (!toMetadata) {
+      return {
+        valid: false,
+        error: `Dependency '${toSpec}' not found`
+      };
+    }
+
+    // Check for self-dependency
+    if (fromSpec === toSpec) {
+      return {
+        valid: false,
+        error: 'Spec cannot depend on itself'
+      };
+    }
+
+    // Build graph with new dependency and check for cycles
+    const graph = await this.buildDependencyGraph();
+    
+    // Add the new edge temporarily
+    graph.edges.push({ from: fromSpec, to: toSpec, type });
+    
+    const cycle = this.detectCircularDependencies(graph);
+    if (cycle) {
+      return {
+        valid: false,
+        error: `Circular dependency detected: ${cycle.join(' → ')}`
+      };
+    }
+
+    return { valid: true };
+  }
+
+  /**
+   * Update dependent specs when a spec is completed
+   * @param {string} completedSpec - Name of completed spec
+   * @returns {Promise<Array<string>>} List of specs that became ready
+   */
+  async updateDependentSpecs(completedSpec) {
+    const graph = await this.buildDependencyGraph();
+    
+    // Find specs that depend on the completed spec
+    const dependents = graph.edges
+      .filter(e => e.to === completedSpec)
+      .map(e => e.from);
+
+    // Check which dependents are now ready
+    const nowReady = [];
+    for (const depSpec of dependents) {
+      const depMetadata = await this.metadataManager.readMetadata(depSpec);
+      if (depMetadata && depMetadata.status.current === 'not-started') {
+        // Check if all dependencies are satisfied
+        const ready = this.getReadySpecs(graph);
+        if (ready.includes(depSpec)) {
+          nowReady.push(depSpec);
+        }
+      }
+    }
+
+    return nowReady;
+  }
+}
+
+module.exports = DependencyManager;

package/lib/collab/index.js

@@ -0,0 +1,20 @@
+/**
+ * Collab module exports
+ * @module lib/collab
+ */
+
+const { AgentRegistry } = require('./agent-registry');
+const { Coordinator } = require('./coordinator');
+const { MergeCoordinator } = require('./merge-coordinator');
+const { MultiAgentConfig } = require('./multi-agent-config');
+const { SpecLifecycleManager } = require('./spec-lifecycle-manager');
+const { SyncBarrier } = require('./sync-barrier');
+
+module.exports = {
+  AgentRegistry,
+  Coordinator,
+  MergeCoordinator,
+  MultiAgentConfig,
+  SpecLifecycleManager,
+  SyncBarrier
+};

package/lib/collab/integration-manager.js

@@ -0,0 +1,202 @@
+const fs = require('fs').promises;
+const path = require('path');
+
+/**
+ * IntegrationManager handles cross-Spec integration testing
+ */
+class IntegrationManager {
+  constructor(workspaceRoot, metadataManager) {
+    this.workspaceRoot = workspaceRoot;
+    this.metadataManager = metadataManager;
+    this.specsDir = path.join(workspaceRoot, '.kiro', 'specs');
+  }
+
+  /**
+   * Discover integration tests for a spec
+   * @param {string} specName - Name of the spec
+   * @returns {Promise<Array<string>>} List of test file paths
+   */
+  async discoverTests(specName) {
+    const testsDir = path.join(this.specsDir, specName, 'integration-tests');
+    
+    try {
+      const files = await fs.readdir(testsDir);
+      return files
+        .filter(f => f.endsWith('.js'))
+        .map(f => path.join(testsDir, f));
+    } catch (error) {
+      if (error.code === 'ENOENT') {
+        return [];
+      }
+      throw error;
+    }
+  }
+
+  /**
+   * Run a single integration test
+   * @param {string} testPath - Path to test file
+   * @returns {Promise<Object>} Test result
+   */
+  async runTest(testPath) {
+    try {
+      // Load test module
+      const test = require(testPath);
+      
+      // Validate test structure
+      if (!test.name || !test.specs || !test.test) {
+        return {
+          success: false,
+          error: 'Invalid test structure: must have name, specs, and test function'
+        };
+      }
+
+      // Validate dependencies
+      const validation = await this.validateTestDependencies(test);
+      if (!validation.valid) {
+        return {
+          success: false,
+          error: validation.error,
+          blocked: true
+        };
+      }
+
+      // Run setup if provided
+      if (test.setup) {
+        await test.setup();
+      }
+
+      // Run test
+      await test.test();
+      
+      // Run teardown if provided
+      if (test.teardown) {
+        await test.teardown();
+      }
+
+      return {
+        success: true,
+        name: test.name,
+        specs: test.specs
+      };
+    } catch (error) {
+      return {
+        success: false,
+        error: error.message,
+        stack: error.stack
+      };
+    }
+  }
+
+  /**
+   * Run all integration tests for specified specs
+   * @param {Array<string>} specNames - Specs to test
+   * @returns {Promise<Object>} Test results
+   */
+  async runAllTests(specNames) {
+    const results = [];
+    
+    for (const specName of specNames) {
+      const tests = await this.discoverTests(specName);
+      
+      for (const testPath of tests) {
+        const result = await this.runTest(testPath);
+        results.push({
+          spec: specName,
+          testPath,
+          ...result
+        });
+      }
+    }
+
+    const passed = results.filter(r => r.success).length;
+    const failed = results.filter(r => !r.success && !r.blocked).length;
+    const blocked = results.filter(r => r.blocked).length;
+
+    return {
+      total: results.length,
+      passed,
+      failed,
+      blocked,
+      results
+    };
+  }
+
+  /**
+   * Generate integration test report
+   * @param {Object} results - Test results from runAllTests
+   * @returns {string} Formatted report
+   */
+  generateReport(results) {
+    const lines = [];
+    
+    lines.push('Integration Test Report');
+    lines.push('======================');
+    lines.push('');
+    lines.push(`Total: ${results.total}`);
+    lines.push(`Passed: ${results.passed}`);
+    lines.push(`Failed: ${results.failed}`);
+    lines.push(`Blocked: ${results.blocked}`);
+    lines.push('');
+
+    if (results.failed > 0) {
+      lines.push('Failed Tests:');
+      lines.push('-------------');
+      for (const result of results.results) {
+        if (!result.success && !result.blocked) {
+          lines.push(`  ${result.name || path.basename(result.testPath)}`);
+          lines.push(`    Spec: ${result.spec}`);
+          lines.push(`    Error: ${result.error}`);
+          lines.push('');
+        }
+      }
+    }
+
+    if (results.blocked > 0) {
+      lines.push('Blocked Tests:');
+      lines.push('--------------');
+      for (const result of results.results) {
+        if (result.blocked) {
+          lines.push(`  ${result.name || path.basename(result.testPath)}`);
+          lines.push(`    Reason: ${result.error}`);
+          lines.push('');
+        }
+      }
+    }
+
+    return lines.join('\n');
+  }
+
+  /**
+   * Validate that all required specs for a test are available
+   * @param {Object} test - Test definition
+   * @returns {Promise<Object>} Validation result
+   */
+  async validateTestDependencies(test) {
+    if (!test.specs || !Array.isArray(test.specs)) {
+      return {
+        valid: false,
+        error: 'Test must specify required specs'
+      };
+    }
+
+    const missing = [];
+    
+    for (const specName of test.specs) {
+      const metadata = await this.metadataManager.readMetadata(specName);
+      if (!metadata) {
+        missing.push(specName);
+      }
+    }
+
+    if (missing.length > 0) {
+      return {
+        valid: false,
+        error: `Missing required specs: ${missing.join(', ')}`
+      };
+    }
+
+    return { valid: true };
+  }
+}
+
+module.exports = IntegrationManager;