bmad-fh 6.0.0-alpha.23 → 6.0.0-alpha.24

package/test/test-scope-system.js

@@ -1,12 +1,12 @@
 /**
  * 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
  */
@@ -104,7 +104,7 @@ function cleanupTempDir(tmpDir) {
 
 function testScopeValidator() {
   console.log(`\n${colors.blue}ScopeValidator Tests${colors.reset}`);
-  
+
   const { ScopeValidator } = require('../src/core/lib/scope/scope-validator');
   const validator = new ScopeValidator();
 
@@ -209,11 +209,11 @@ function testScopeValidator() {
 
 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();
@@ -222,7 +222,7 @@ function testScopeManager() {
     fs.mkdirSync(path.join(tmpDir, '_bmad-output'), { recursive: true });
     return new ScopeManager({ projectRoot: tmpDir });
   }
-  
+
   function teardown() {
     if (tmpDir) {
       cleanupTempDir(tmpDir);
@@ -260,7 +260,7 @@ function testScopeManager() {
     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');
@@ -310,7 +310,7 @@ function testScopeManager() {
     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');
@@ -338,7 +338,7 @@ function testScopeManager() {
       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 {
@@ -353,7 +353,7 @@ function testScopeManager() {
       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');
@@ -368,9 +368,9 @@ function testScopeManager() {
     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 {
@@ -384,9 +384,9 @@ function testScopeManager() {
     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 {
@@ -400,9 +400,9 @@ function testScopeManager() {
       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 {
@@ -416,7 +416,7 @@ function testScopeManager() {
     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');
@@ -434,7 +434,7 @@ function testScopeManager() {
       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 {
@@ -449,7 +449,7 @@ function testScopeManager() {
       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');
@@ -466,7 +466,7 @@ function testScopeManager() {
 
 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', () => {
@@ -474,7 +474,7 @@ function testArtifactResolver() {
       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');
@@ -485,7 +485,7 @@ function testArtifactResolver() {
       currentScope: 'auth',
       basePath: '_bmad-output',
     });
-    
+
     assertTrue(resolver.canWrite('_bmad-output/auth/planning-artifacts/prd.md'), 'Should allow own-scope write');
   });
 
@@ -495,7 +495,7 @@ function testArtifactResolver() {
       basePath: '_bmad-output',
       isolationMode: 'strict',
     });
-    
+
     assertFalse(resolver.canWrite('_bmad-output/payments/planning-artifacts/prd.md'), 'Should block cross-scope write');
   });
 
@@ -504,7 +504,7 @@ function testArtifactResolver() {
       currentScope: 'auth',
       basePath: '_bmad-output',
     });
-    
+
     assertFalse(resolver.canWrite('_bmad-output/_shared/project-context.md'), 'Should block _shared write');
   });
 
@@ -513,7 +513,7 @@ function testArtifactResolver() {
       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');
@@ -525,11 +525,8 @@ function testArtifactResolver() {
       basePath: '_bmad-output',
       isolationMode: 'strict',
     });
-    
-    assertThrows(
-      () => resolver.validateWrite('_bmad-output/payments/prd.md'),
-      'Cannot write to scope'
-    );
+
+    assertThrows(() => resolver.validateWrite('_bmad-output/payments/prd.md'), 'Cannot write to scope');
   });
 
   test('warns on cross-scope write in warn mode', () => {
@@ -538,7 +535,7 @@ function testArtifactResolver() {
       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
@@ -552,16 +549,16 @@ function testArtifactResolver() {
 
 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);
@@ -572,11 +569,11 @@ function testStateLock() {
     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();
@@ -588,24 +585,24 @@ function testStateLock() {
     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));
+        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));
+      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 {
@@ -617,13 +614,16 @@ function testStateLock() {
     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
-      }));
-      
+      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');
@@ -639,19 +639,19 @@ function testStateLock() {
 
 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);
@@ -665,9 +665,9 @@ function testScopeContext() {
       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 {
@@ -682,10 +682,10 @@ function testScopeContext() {
       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();
@@ -698,10 +698,10 @@ function testScopeContext() {
       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 {
@@ -715,22 +715,16 @@ function testScopeContext() {
       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.'
-      );
-      
+      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.'
-      );
-      
+      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 {