bmad-fh 6.0.0-alpha.052779ef

package/test/test-scope-system.js

@@ -0,0 +1,781 @@
+/**
+ * Scope System Test Suite
+ *
+ * Tests for multi-scope parallel artifacts system including:
+ * - ScopeValidator: ID validation, schema validation, circular dependency detection
+ * - ScopeManager: CRUD operations, path resolution
+ * - ArtifactResolver: Read/write access control
+ * - StateLock: File locking and optimistic versioning
+ *
+ * Usage: node test/test-scope-system.js
+ * Exit codes: 0 = all tests pass, 1 = test failures
+ */
+
+const fs = require('node:fs');
+const path = require('node:path');
+const os = require('node:os');
+
+// ANSI color codes
+const colors = {
+  reset: '\u001B[0m',
+  green: '\u001B[32m',
+  red: '\u001B[31m',
+  yellow: '\u001B[33m',
+  blue: '\u001B[34m',
+  cyan: '\u001B[36m',
+  dim: '\u001B[2m',
+};
+
+// Test utilities
+let testCount = 0;
+let passCount = 0;
+let failCount = 0;
+const failures = [];
+
+function test(name, fn) {
+  testCount++;
+  try {
+    fn();
+    passCount++;
+    console.log(`  ${colors.green}✓${colors.reset} ${name}`);
+  } catch (error) {
+    failCount++;
+    console.log(`  ${colors.red}✗${colors.reset} ${name}`);
+    console.log(`    ${colors.red}${error.message}${colors.reset}`);
+    failures.push({ name, error: error.message });
+  }
+}
+
+function assertEqual(actual, expected, message = '') {
+  if (actual !== expected) {
+    throw new Error(`${message}\n    Expected: ${expected}\n    Actual: ${actual}`);
+  }
+}
+
+function assertTrue(value, message = 'Expected true') {
+  if (!value) {
+    throw new Error(message);
+  }
+}
+
+function assertFalse(value, message = 'Expected false') {
+  if (value) {
+    throw new Error(message);
+  }
+}
+
+function assertThrows(fn, expectedMessage = null) {
+  let threw = false;
+  let actualMessage = null;
+  try {
+    fn();
+  } catch (error) {
+    threw = true;
+    actualMessage = error.message;
+  }
+  if (!threw) {
+    throw new Error('Expected function to throw');
+  }
+  if (expectedMessage && !actualMessage.includes(expectedMessage)) {
+    throw new Error(`Expected error message to contain "${expectedMessage}", got "${actualMessage}"`);
+  }
+}
+
+function assertArrayEqual(actual, expected, message = '') {
+  if (JSON.stringify(actual) !== JSON.stringify(expected)) {
+    throw new Error(`${message}\n    Expected: ${JSON.stringify(expected)}\n    Actual: ${JSON.stringify(actual)}`);
+  }
+}
+
+// Create temporary test directory
+function createTempDir() {
+  const tmpDir = path.join(os.tmpdir(), `bmad-test-${Date.now()}-${Math.random().toString(36).slice(2)}`);
+  fs.mkdirSync(tmpDir, { recursive: true });
+  return tmpDir;
+}
+
+function cleanupTempDir(tmpDir) {
+  fs.rmSync(tmpDir, { recursive: true, force: true });
+}
+
+// ============================================================================
+// ScopeValidator Tests
+// ============================================================================
+
+function testScopeValidator() {
+  console.log(`\n${colors.blue}ScopeValidator Tests${colors.reset}`);
+
+  const { ScopeValidator } = require('../src/core/lib/scope/scope-validator');
+  const validator = new ScopeValidator();
+
+  // Valid scope IDs
+  test('validates simple scope ID', () => {
+    assertTrue(validator.isValidScopeId('auth'), 'auth should be valid');
+  });
+
+  test('validates hyphenated scope ID', () => {
+    assertTrue(validator.isValidScopeId('user-service'), 'user-service should be valid');
+  });
+
+  test('validates scope ID with numbers', () => {
+    assertTrue(validator.isValidScopeId('api-v2'), 'api-v2 should be valid');
+  });
+
+  test('validates minimum length scope ID', () => {
+    assertTrue(validator.isValidScopeId('ab'), 'ab (2 chars) should be valid');
+  });
+
+  // Invalid scope IDs
+  test('rejects single character scope ID', () => {
+    assertFalse(validator.isValidScopeId('a'), 'single char should be invalid');
+  });
+
+  test('rejects scope ID starting with number', () => {
+    assertFalse(validator.isValidScopeId('1auth'), 'starting with number should be invalid');
+  });
+
+  test('rejects scope ID with uppercase', () => {
+    assertFalse(validator.isValidScopeId('Auth'), 'uppercase should be invalid');
+  });
+
+  test('rejects scope ID with underscore', () => {
+    assertFalse(validator.isValidScopeId('user_service'), 'underscore should be invalid');
+  });
+
+  test('rejects scope ID ending with hyphen', () => {
+    assertFalse(validator.isValidScopeId('auth-'), 'ending with hyphen should be invalid');
+  });
+
+  test('rejects scope ID starting with hyphen', () => {
+    assertFalse(validator.isValidScopeId('-auth'), 'starting with hyphen should be invalid');
+  });
+
+  test('rejects scope ID with spaces', () => {
+    assertFalse(validator.isValidScopeId('auth service'), 'spaces should be invalid');
+  });
+
+  // Reserved IDs
+  test('rejects reserved ID _shared', () => {
+    assertFalse(validator.isValidScopeId('_shared'), '_shared is reserved');
+  });
+
+  test('rejects reserved ID _events', () => {
+    assertFalse(validator.isValidScopeId('_events'), '_events is reserved');
+  });
+
+  test('rejects reserved ID _config', () => {
+    assertFalse(validator.isValidScopeId('_config'), '_config is reserved');
+  });
+
+  test('rejects reserved ID global', () => {
+    assertFalse(validator.isValidScopeId('global'), 'global is reserved');
+  });
+
+  // Circular dependency detection
+  test('detects direct circular dependency', () => {
+    const scopes = {
+      auth: { dependencies: ['payments'] },
+      payments: { dependencies: ['auth'] },
+    };
+    const result = validator.detectCircularDependencies(scopes);
+    assertTrue(result.hasCircular, 'Should detect circular dependency');
+    assertTrue(result.cycles.length > 0, 'Should report cycles');
+  });
+
+  test('detects indirect circular dependency', () => {
+    const scopes = {
+      aa: { dependencies: ['bb'] },
+      bb: { dependencies: ['cc'] },
+      cc: { dependencies: ['aa'] },
+    };
+    const result = validator.detectCircularDependencies(scopes);
+    assertTrue(result.hasCircular, 'Should detect indirect circular dependency');
+  });
+
+  test('accepts valid dependency graph', () => {
+    const scopes = {
+      auth: { dependencies: [] },
+      payments: { dependencies: ['auth'] },
+      orders: { dependencies: ['auth', 'payments'] },
+    };
+    const result = validator.detectCircularDependencies(scopes);
+    assertFalse(result.hasCircular, 'Should not detect circular dependency');
+  });
+}
+
+// ============================================================================
+// ScopeManager Tests
+// ============================================================================
+
+function testScopeManager() {
+  console.log(`\n${colors.blue}ScopeManager Tests${colors.reset}`);
+
+  const { ScopeManager } = require('../src/core/lib/scope/scope-manager');
+
+  let tmpDir;
+
+  // Setup/teardown for each test
+  function setup() {
+    tmpDir = createTempDir();
+    // Create minimal BMAD structure
+    fs.mkdirSync(path.join(tmpDir, '_bmad', '_config'), { recursive: true });
+    fs.mkdirSync(path.join(tmpDir, '_bmad-output'), { recursive: true });
+    return new ScopeManager({ projectRoot: tmpDir });
+  }
+
+  function teardown() {
+    if (tmpDir) {
+      cleanupTempDir(tmpDir);
+    }
+  }
+
+  // Test initialization
+  test('initializes scope system', async () => {
+    const manager = setup();
+    try {
+      await manager.initialize();
+      const scopesPath = path.join(tmpDir, '_bmad', '_config', 'scopes.yaml');
+      assertTrue(fs.existsSync(scopesPath), 'scopes.yaml should be created');
+    } finally {
+      teardown();
+    }
+  });
+
+  // Test scope creation
+  test('creates new scope', async () => {
+    const manager = setup();
+    try {
+      await manager.initialize();
+      const scope = await manager.createScope('auth', { name: 'Authentication' });
+      assertEqual(scope.id, 'auth', 'Scope ID should match');
+      assertEqual(scope.name, 'Authentication', 'Scope name should match');
+      assertEqual(scope.status, 'active', 'Scope should be active');
+    } finally {
+      teardown();
+    }
+  });
+
+  test('creates scope directory structure', async () => {
+    const manager = setup();
+    try {
+      await manager.initialize();
+      await manager.createScope('auth', { name: 'Auth' });
+
+      const scopePath = path.join(tmpDir, '_bmad-output', 'auth');
+      assertTrue(fs.existsSync(scopePath), 'Scope directory should exist');
+      assertTrue(fs.existsSync(path.join(scopePath, 'planning-artifacts')), 'planning-artifacts should exist');
+      assertTrue(fs.existsSync(path.join(scopePath, 'implementation-artifacts')), 'implementation-artifacts should exist');
+      assertTrue(fs.existsSync(path.join(scopePath, 'tests')), 'tests should exist');
+    } finally {
+      teardown();
+    }
+  });
+
+  test('rejects invalid scope ID on create', async () => {
+    const manager = setup();
+    try {
+      await manager.initialize();
+      let threw = false;
+      try {
+        await manager.createScope('Invalid-ID', { name: 'Test' });
+      } catch {
+        threw = true;
+      }
+      assertTrue(threw, 'Should throw for invalid ID');
+    } finally {
+      teardown();
+    }
+  });
+
+  test('rejects duplicate scope ID', async () => {
+    const manager = setup();
+    try {
+      await manager.initialize();
+      await manager.createScope('auth', { name: 'Auth' });
+      let threw = false;
+      try {
+        await manager.createScope('auth', { name: 'Auth 2' });
+      } catch {
+        threw = true;
+      }
+      assertTrue(threw, 'Should throw for duplicate ID');
+    } finally {
+      teardown();
+    }
+  });
+
+  // Test scope retrieval
+  test('retrieves scope by ID', async () => {
+    const manager = setup();
+    try {
+      await manager.initialize();
+      await manager.createScope('auth', { name: 'Authentication', description: 'Auth service' });
+
+      const scope = await manager.getScope('auth');
+      assertEqual(scope.id, 'auth', 'ID should match');
+      assertEqual(scope.name, 'Authentication', 'Name should match');
+      assertEqual(scope.description, 'Auth service', 'Description should match');
+    } finally {
+      teardown();
+    }
+  });
+
+  test('returns null for non-existent scope', async () => {
+    const manager = setup();
+    try {
+      await manager.initialize();
+      const scope = await manager.getScope('nonexistent');
+      assertEqual(scope, null, 'Should return null');
+    } finally {
+      teardown();
+    }
+  });
+
+  // Test scope listing
+  test('lists all scopes', async () => {
+    const manager = setup();
+    try {
+      await manager.initialize();
+      await manager.createScope('auth', { name: 'Auth' });
+      await manager.createScope('payments', { name: 'Payments' });
+
+      const scopes = await manager.listScopes();
+      assertEqual(scopes.length, 2, 'Should have 2 scopes');
+    } finally {
+      teardown();
+    }
+  });
+
+  test('filters scopes by status', async () => {
+    const manager = setup();
+    try {
+      await manager.initialize();
+      await manager.createScope('auth', { name: 'Auth' });
+      await manager.createScope('legacy', { name: 'Legacy' });
+      await manager.archiveScope('legacy');
+
+      const activeScopes = await manager.listScopes({ status: 'active' });
+      assertEqual(activeScopes.length, 1, 'Should have 1 active scope');
+      assertEqual(activeScopes[0].id, 'auth', 'Active scope should be auth');
+    } finally {
+      teardown();
+    }
+  });
+
+  // Test scope update
+  test('updates scope properties', async () => {
+    const manager = setup();
+    try {
+      await manager.initialize();
+      await manager.createScope('auth', { name: 'Auth', description: 'Old desc' });
+
+      await manager.updateScope('auth', { description: 'New description' });
+
+      const scope = await manager.getScope('auth');
+      assertEqual(scope.description, 'New description', 'Description should be updated');
+    } finally {
+      teardown();
+    }
+  });
+
+  // Test scope archive/activate
+  test('archives scope', async () => {
+    const manager = setup();
+    try {
+      await manager.initialize();
+      await manager.createScope('auth', { name: 'Auth' });
+
+      await manager.archiveScope('auth');
+
+      const scope = await manager.getScope('auth');
+      assertEqual(scope.status, 'archived', 'Status should be archived');
+    } finally {
+      teardown();
+    }
+  });
+
+  test('activates archived scope', async () => {
+    const manager = setup();
+    try {
+      await manager.initialize();
+      await manager.createScope('auth', { name: 'Auth' });
+      await manager.archiveScope('auth');
+
+      await manager.activateScope('auth');
+
+      const scope = await manager.getScope('auth');
+      assertEqual(scope.status, 'active', 'Status should be active');
+    } finally {
+      teardown();
+    }
+  });
+
+  // Test path resolution
+  test('resolves scope paths', async () => {
+    const manager = setup();
+    try {
+      await manager.initialize();
+      await manager.createScope('auth', { name: 'Auth' });
+
+      const paths = await manager.getScopePaths('auth');
+      assertTrue(paths.root.includes('auth'), 'Root path should contain scope ID');
+      assertTrue(paths.planning.includes('planning-artifacts'), 'Should have planning path');
+      assertTrue(paths.implementation.includes('implementation-artifacts'), 'Should have implementation path');
+      assertTrue(paths.tests.includes('tests'), 'Should have tests path');
+    } finally {
+      teardown();
+    }
+  });
+
+  // Test dependency management
+  test('tracks scope dependencies', async () => {
+    const manager = setup();
+    try {
+      await manager.initialize();
+      await manager.createScope('auth', { name: 'Auth' });
+      await manager.createScope('payments', { name: 'Payments', dependencies: ['auth'] });
+
+      const scope = await manager.getScope('payments');
+      assertArrayEqual(scope.dependencies, ['auth'], 'Dependencies should be set');
+    } finally {
+      teardown();
+    }
+  });
+
+  test('finds dependent scopes', async () => {
+    const manager = setup();
+    try {
+      await manager.initialize();
+      await manager.createScope('auth', { name: 'Auth' });
+      await manager.createScope('payments', { name: 'Payments', dependencies: ['auth'] });
+      await manager.createScope('orders', { name: 'Orders', dependencies: ['auth'] });
+
+      const dependents = await manager.findDependentScopes('auth');
+      assertEqual(dependents.length, 2, 'Should have 2 dependents');
+      assertTrue(dependents.includes('payments'), 'payments should depend on auth');
+      assertTrue(dependents.includes('orders'), 'orders should depend on auth');
+    } finally {
+      teardown();
+    }
+  });
+}
+
+// ============================================================================
+// ArtifactResolver Tests
+// ============================================================================
+
+function testArtifactResolver() {
+  console.log(`\n${colors.blue}ArtifactResolver Tests${colors.reset}`);
+
+  const { ArtifactResolver } = require('../src/core/lib/scope/artifact-resolver');
+
+  test('allows read from any scope', () => {
+    const resolver = new ArtifactResolver({
+      currentScope: 'auth',
+      basePath: '_bmad-output',
+    });
+
+    assertTrue(resolver.canRead('_bmad-output/payments/planning-artifacts/prd.md'), 'Should allow cross-scope read');
+    assertTrue(resolver.canRead('_bmad-output/auth/planning-artifacts/prd.md'), 'Should allow own-scope read');
+    assertTrue(resolver.canRead('_bmad-output/_shared/project-context.md'), 'Should allow shared read');
+  });
+
+  test('allows write to own scope', () => {
+    const resolver = new ArtifactResolver({
+      currentScope: 'auth',
+      basePath: '_bmad-output',
+    });
+
+    assertTrue(resolver.canWrite('_bmad-output/auth/planning-artifacts/prd.md'), 'Should allow own-scope write');
+  });
+
+  test('blocks write to other scope in strict mode', () => {
+    const resolver = new ArtifactResolver({
+      currentScope: 'auth',
+      basePath: '_bmad-output',
+      isolationMode: 'strict',
+    });
+
+    assertFalse(resolver.canWrite('_bmad-output/payments/planning-artifacts/prd.md'), 'Should block cross-scope write');
+  });
+
+  test('blocks direct write to _shared', () => {
+    const resolver = new ArtifactResolver({
+      currentScope: 'auth',
+      basePath: '_bmad-output',
+    });
+
+    assertFalse(resolver.canWrite('_bmad-output/_shared/project-context.md'), 'Should block _shared write');
+  });
+
+  test('extracts scope from path', () => {
+    const resolver = new ArtifactResolver({
+      currentScope: 'auth',
+      basePath: '_bmad-output',
+    });
+
+    assertEqual(resolver.extractScopeFromPath('_bmad-output/payments/planning-artifacts/prd.md'), 'payments');
+    assertEqual(resolver.extractScopeFromPath('_bmad-output/auth/tests/unit.js'), 'auth');
+    assertEqual(resolver.extractScopeFromPath('_bmad-output/_shared/context.md'), '_shared');
+  });
+
+  test('throws on cross-scope write validation in strict mode', () => {
+    const resolver = new ArtifactResolver({
+      currentScope: 'auth',
+      basePath: '_bmad-output',
+      isolationMode: 'strict',
+    });
+
+    assertThrows(() => resolver.validateWrite('_bmad-output/payments/prd.md'), 'Cannot write to scope');
+  });
+
+  test('warns on cross-scope write in warn mode', () => {
+    const resolver = new ArtifactResolver({
+      currentScope: 'auth',
+      basePath: '_bmad-output',
+      isolationMode: 'warn',
+    });
+
+    // Should not throw in warn mode
+    const result = resolver.canWrite('_bmad-output/payments/prd.md');
+    // In warn mode, it may return true but log a warning
+    // The exact behavior depends on implementation
+  });
+}
+
+// ============================================================================
+// StateLock Tests
+// ============================================================================
+
+function testStateLock() {
+  console.log(`\n${colors.blue}StateLock Tests${colors.reset}`);
+
+  const { StateLock } = require('../src/core/lib/scope/state-lock');
+
+  let tmpDir;
+
+  function setup() {
+    tmpDir = createTempDir();
+    return new StateLock();
+  }
+
+  function teardown() {
+    if (tmpDir) {
+      cleanupTempDir(tmpDir);
+    }
+  }
+
+  test('acquires and releases lock', async () => {
+    const lock = setup();
+    try {
+      const lockPath = path.join(tmpDir, 'test.lock');
+
+      const result = await lock.withLock(lockPath, async () => {
+        return 'success';
+      });
+
+      assertEqual(result, 'success', 'Should return operation result');
+    } finally {
+      teardown();
+    }
+  });
+
+  test('prevents concurrent access', async () => {
+    const lock = setup();
+    try {
+      const lockPath = path.join(tmpDir, 'test.lock');
+      const order = [];
+
+      // Start first operation (holds lock)
+      const op1 = lock.withLock(lockPath, async () => {
+        order.push('op1-start');
+        await new Promise((r) => setTimeout(r, 100));
+        order.push('op1-end');
+        return 'op1';
+      });
+
+      // Start second operation immediately (should wait)
+      await new Promise((r) => setTimeout(r, 10));
+      const op2 = lock.withLock(lockPath, async () => {
+        order.push('op2');
+        return 'op2';
+      });
+
+      await Promise.all([op1, op2]);
+
+      // op2 should start after op1 ends
+      assertTrue(order.indexOf('op1-end') < order.indexOf('op2'), 'op2 should run after op1 completes');
+    } finally {
+      teardown();
+    }
+  });
+
+  test('detects stale locks', async () => {
+    const lock = setup();
+    try {
+      const lockPath = path.join(tmpDir, 'test.lock');
+
+      // Create a stale lock file manually
+      fs.writeFileSync(
+        lockPath,
+        JSON.stringify({
+          pid: 99_999_999, // Non-existent PID
+          timestamp: Date.now() - 60_000, // 60 seconds ago
+        }),
+      );
+
+      // Should be able to acquire lock despite stale file
+      const result = await lock.withLock(lockPath, async () => 'success');
+      assertEqual(result, 'success', 'Should acquire lock after stale detection');
+    } finally {
+      teardown();
+    }
+  });
+}
+
+// ============================================================================
+// ScopeContext Tests
+// ============================================================================
+
+function testScopeContext() {
+  console.log(`\n${colors.blue}ScopeContext Tests${colors.reset}`);
+
+  const { ScopeContext } = require('../src/core/lib/scope/scope-context');
+  const { ScopeManager } = require('../src/core/lib/scope/scope-manager');
+
+  let tmpDir;
+
+  function setup() {
+    tmpDir = createTempDir();
+    fs.mkdirSync(path.join(tmpDir, '_bmad', '_config'), { recursive: true });
+    fs.mkdirSync(path.join(tmpDir, '_bmad-output', '_shared'), { recursive: true });
+    return new ScopeContext({ projectRoot: tmpDir });
+  }
+
+  function teardown() {
+    if (tmpDir) {
+      cleanupTempDir(tmpDir);
+    }
+  }
+
+  test('sets session scope', async () => {
+    const context = setup();
+    try {
+      // Initialize scope system first
+      const manager = new ScopeManager({ projectRoot: tmpDir });
+      await manager.initialize();
+      await manager.createScope('auth', { name: 'Auth' });
+
+      await context.setScope('auth');
+
+      const scopeFile = path.join(tmpDir, '.bmad-scope');
+      assertTrue(fs.existsSync(scopeFile), '.bmad-scope file should be created');
+    } finally {
+      teardown();
+    }
+  });
+
+  test('gets current scope from session', async () => {
+    const context = setup();
+    try {
+      // Initialize scope system first
+      const manager = new ScopeManager({ projectRoot: tmpDir });
+      await manager.initialize();
+      await manager.createScope('auth', { name: 'Auth' });
+
+      await context.setScope('auth');
+      const current = await context.getCurrentScope();
+
+      assertEqual(current, 'auth', 'Should return session scope');
+    } finally {
+      teardown();
+    }
+  });
+
+  test('clears session scope', async () => {
+    const context = setup();
+    try {
+      const manager = new ScopeManager({ projectRoot: tmpDir });
+      await manager.initialize();
+      await manager.createScope('auth', { name: 'Auth' });
+
+      await context.setScope('auth');
+      await context.clearScope();
+
+      const current = await context.getCurrentScope();
+      assertEqual(current, null, 'Should return null after clearing');
+    } finally {
+      teardown();
+    }
+  });
+
+  test('loads merged project context', async () => {
+    const context = setup();
+    try {
+      const manager = new ScopeManager({ projectRoot: tmpDir });
+      await manager.initialize();
+      await manager.createScope('auth', { name: 'Auth' });
+
+      // Create global context
+      fs.writeFileSync(path.join(tmpDir, '_bmad-output', '_shared', 'project-context.md'), '# Global Project\n\nGlobal content here.');
+
+      // Create scope-specific context
+      fs.mkdirSync(path.join(tmpDir, '_bmad-output', 'auth'), { recursive: true });
+      fs.writeFileSync(path.join(tmpDir, '_bmad-output', 'auth', 'project-context.md'), '# Auth Scope\n\nScope-specific content.');
+
+      const merged = await context.loadProjectContext('auth');
+
+      assertTrue(merged.includes('Global content'), 'Should include global content');
+      assertTrue(merged.includes('Scope-specific content'), 'Should include scope content');
+    } finally {
+      teardown();
+    }
+  });
+}
+
+// ============================================================================
+// Main Runner
+// ============================================================================
+
+async function main() {
+  console.log(`${colors.cyan}╔═══════════════════════════════════════════════════════════╗${colors.reset}`);
+  console.log(`${colors.cyan}║  Scope System Test Suite                                   ║${colors.reset}`);
+  console.log(`${colors.cyan}╚═══════════════════════════════════════════════════════════╝${colors.reset}`);
+
+  try {
+    testScopeValidator();
+    await testScopeManager();
+    testArtifactResolver();
+    await testStateLock();
+    await testScopeContext();
+  } catch (error) {
+    console.log(`\n${colors.red}Fatal error: ${error.message}${colors.reset}`);
+    console.log(error.stack);
+    process.exit(1);
+  }
+
+  // Summary
+  console.log(`\n${colors.cyan}═══════════════════════════════════════════════════════════${colors.reset}`);
+  console.log(`${colors.cyan}Test Results:${colors.reset}`);
+  console.log(`  Total:  ${testCount}`);
+  console.log(`  Passed: ${colors.green}${passCount}${colors.reset}`);
+  console.log(`  Failed: ${failCount === 0 ? colors.green : colors.red}${failCount}${colors.reset}`);
+  console.log(`${colors.cyan}═══════════════════════════════════════════════════════════${colors.reset}\n`);
+
+  if (failures.length > 0) {
+    console.log(`${colors.red}Failed Tests:${colors.reset}\n`);
+    for (const failure of failures) {
+      console.log(`${colors.red}✗${colors.reset} ${failure.name}`);
+      console.log(`  ${failure.error}\n`);
+    }
+    process.exit(1);
+  }
+
+  console.log(`${colors.green}All tests passed!${colors.reset}\n`);
+  process.exit(0);
+}
+
+main().catch((error) => {
+  console.error(`${colors.red}Fatal error:${colors.reset}`, error);
+  process.exit(1);
+});