bmad-fh 6.0.0-alpha.23 → 6.0.0-alpha.23.3b00cb36

package/src/core/lib/scope/scope-sync.js

@@ -7,12 +7,12 @@ const { StateLock } = require('./state-lock');
 /**
  * Handles synchronization between scopes and shared layer
  * Implements sync-up (promote to shared) and sync-down (pull from shared)
- * 
+ *
  * @class ScopeSync
  * @requires fs-extra
  * @requires yaml
  * @requires StateLock
- * 
+ *
  * @example
  * const sync = new ScopeSync({ projectRoot: '/path/to/project' });
  * await sync.syncUp('auth', ['architecture.md']);
@@ -24,13 +24,13 @@ class ScopeSync {
     this.outputPath = path.join(this.projectRoot, this.outputBase);
     this.sharedPath = path.join(this.outputPath, '_shared');
     this.stateLock = new StateLock();
-    
+
     // Default patterns for promotable artifacts
     this.promotablePatterns = options.promotablePatterns || [
       'architecture/*.md',
       'contracts/*.md',
       'principles/*.md',
-      'project-context.md'
+      'project-context.md',
     ];
   }
 
@@ -74,7 +74,7 @@ class ScopeSync {
    */
   async loadSyncMeta(scopeId) {
     const metaPath = this.getSyncMetaPath(scopeId);
-    
+
     try {
       if (await fs.pathExists(metaPath)) {
         const content = await fs.readFile(metaPath, 'utf8');
@@ -89,7 +89,7 @@ class ScopeSync {
       lastSyncUp: null,
       lastSyncDown: null,
       promotedFiles: {},
-      pulledFiles: {}
+      pulledFiles: {},
     };
   }
 
@@ -117,14 +117,14 @@ class ScopeSync {
       promoted: [],
       conflicts: [],
       errors: [],
-      skipped: []
+      skipped: [],
     };
 
     try {
       const scopePath = path.join(this.outputPath, scopeId);
-      
+
       // Verify scope exists
-      if (!await fs.pathExists(scopePath)) {
+      if (!(await fs.pathExists(scopePath))) {
         throw new Error(`Scope '${scopeId}' does not exist`);
       }
 
@@ -133,10 +133,10 @@ class ScopeSync {
 
       // Determine files to promote
       let filesToPromote = [];
-      
+
       if (files && files.length > 0) {
         // Use specified files
-        filesToPromote = files.map(f => path.isAbsolute(f) ? f : path.join(scopePath, f));
+        filesToPromote = files.map((f) => (path.isAbsolute(f) ? f : path.join(scopePath, f)));
       } else {
         // Find promotable files using patterns
         filesToPromote = await this.findPromotableFiles(scopePath);
@@ -146,7 +146,7 @@ class ScopeSync {
       for (const sourceFile of filesToPromote) {
         try {
           // Verify file exists
-          if (!await fs.pathExists(sourceFile)) {
+          if (!(await fs.pathExists(sourceFile))) {
             result.skipped.push({ file: sourceFile, reason: 'File not found' });
             continue;
           }
@@ -156,7 +156,7 @@ class ScopeSync {
           const targetPath = path.join(this.sharedPath, scopeId, relativePath);
 
           // Check for conflicts
-          if (await fs.pathExists(targetPath) && !options.force) {
+          if ((await fs.pathExists(targetPath)) && !options.force) {
             const sourceHash = await this.computeHash(sourceFile);
             const targetHash = await this.computeHash(targetPath);
 
@@ -165,7 +165,7 @@ class ScopeSync {
                 file: relativePath,
                 source: sourceFile,
                 target: targetPath,
-                resolution: 'manual'
+                resolution: 'manual',
               });
               continue;
             }
@@ -184,7 +184,7 @@ class ScopeSync {
             promoted_at: new Date().toISOString(),
             original_path: relativePath,
             original_hash: await this.computeHash(sourceFile),
-            version: (meta.promotedFiles[relativePath]?.version || 0) + 1
+            version: (meta.promotedFiles[relativePath]?.version || 0) + 1,
           };
           await fs.writeFile(metaFilePath, yaml.stringify(fileMeta), 'utf8');
 
@@ -192,18 +192,17 @@ class ScopeSync {
           meta.promotedFiles[relativePath] = {
             promotedAt: fileMeta.promoted_at,
             hash: fileMeta.original_hash,
-            version: fileMeta.version
+            version: fileMeta.version,
           };
 
           result.promoted.push({
             file: relativePath,
-            target: targetPath
+            target: targetPath,
           });
-
         } catch (error) {
           result.errors.push({
             file: sourceFile,
-            error: error.message
+            error: error.message,
           });
         }
       }
@@ -213,7 +212,6 @@ class ScopeSync {
       await this.saveSyncMeta(scopeId, meta);
 
       result.success = result.errors.length === 0;
-      
     } catch (error) {
       result.success = false;
       result.errors.push({ error: error.message });
@@ -234,14 +232,14 @@ class ScopeSync {
       pulled: [],
       conflicts: [],
       errors: [],
-      upToDate: []
+      upToDate: [],
     };
 
     try {
       const scopePath = path.join(this.outputPath, scopeId);
-      
+
       // Verify scope exists
-      if (!await fs.pathExists(scopePath)) {
+      if (!(await fs.pathExists(scopePath))) {
         throw new Error(`Scope '${scopeId}' does not exist`);
       }
 
@@ -250,10 +248,10 @@ class ScopeSync {
 
       // Find all shared files from any scope
       const sharedScopeDirs = await fs.readdir(this.sharedPath, { withFileTypes: true });
-      
+
       for (const dir of sharedScopeDirs) {
         if (!dir.isDirectory() || dir.name.startsWith('.')) continue;
-        
+
         const sharedScopePath = path.join(this.sharedPath, dir.name);
         const files = await this.getAllFiles(sharedScopePath);
 
@@ -264,7 +262,7 @@ class ScopeSync {
           try {
             const relativePath = path.relative(sharedScopePath, sharedFile);
             const targetPath = path.join(scopePath, 'shared', dir.name, relativePath);
-            
+
             // Load shared file metadata
             const metaFilePath = `${sharedFile}.meta`;
             let fileMeta = null;
@@ -281,7 +279,7 @@ class ScopeSync {
             }
 
             // Check for local conflicts
-            if (await fs.pathExists(targetPath) && !options.force) {
+            if ((await fs.pathExists(targetPath)) && !options.force) {
               const localHash = await this.computeHash(targetPath);
               const sharedHash = await this.computeHash(sharedFile);
 
@@ -294,7 +292,7 @@ class ScopeSync {
                     scope: dir.name,
                     local: targetPath,
                     shared: sharedFile,
-                    resolution: options.resolution || 'prompt'
+                    resolution: options.resolution || 'prompt',
                   });
                   continue;
                 }
@@ -311,19 +309,18 @@ class ScopeSync {
             meta.pulledFiles[`${dir.name}/${relativePath}`] = {
               pulledAt: new Date().toISOString(),
               version: fileMeta?.version || 1,
-              hash: await this.computeHash(targetPath)
+              hash: await this.computeHash(targetPath),
             };
 
             result.pulled.push({
               file: relativePath,
               scope: dir.name,
-              target: targetPath
+              target: targetPath,
             });
-
           } catch (error) {
             result.errors.push({
               file: sharedFile,
-              error: error.message
+              error: error.message,
             });
           }
         }
@@ -334,7 +331,6 @@ class ScopeSync {
       await this.saveSyncMeta(scopeId, meta);
 
       result.success = result.errors.length === 0;
-      
     } catch (error) {
       result.success = false;
       result.errors.push({ error: error.message });
@@ -350,18 +346,18 @@ class ScopeSync {
    */
   async findPromotableFiles(scopePath) {
     const files = [];
-    
+
     for (const pattern of this.promotablePatterns) {
       // Simple glob-like matching
       const parts = pattern.split('/');
       const dir = parts.slice(0, -1).join('/');
       const filePattern = parts.at(-1);
-      
+
       const searchDir = path.join(scopePath, dir);
-      
+
       if (await fs.pathExists(searchDir)) {
         const entries = await fs.readdir(searchDir, { withFileTypes: true });
-        
+
         for (const entry of entries) {
           if (entry.isFile() && this.matchPattern(entry.name, filePattern)) {
             files.push(path.join(searchDir, entry.name));
@@ -380,9 +376,7 @@ class ScopeSync {
    * @returns {boolean} True if matches
    */
   matchPattern(filename, pattern) {
-    const regexPattern = pattern
-      .replaceAll('.', String.raw`\.`)
-      .replaceAll('*', '.*');
+    const regexPattern = pattern.replaceAll('.', String.raw`\.`).replaceAll('*', '.*');
     const regex = new RegExp(`^${regexPattern}$`);
     return regex.test(filename);
   }
@@ -394,13 +388,13 @@ class ScopeSync {
    */
   async getAllFiles(dir) {
     const files = [];
-    
+
     async function walk(currentDir) {
       const entries = await fs.readdir(currentDir, { withFileTypes: true });
-      
+
       for (const entry of entries) {
         const fullPath = path.join(currentDir, entry.name);
-        
+
         if (entry.isDirectory()) {
           await walk(fullPath);
         } else {
@@ -408,7 +402,7 @@ class ScopeSync {
         }
       }
     }
-    
+
     await walk(dir);
     return files;
   }
@@ -420,14 +414,14 @@ class ScopeSync {
    */
   async getSyncStatus(scopeId) {
     const meta = await this.loadSyncMeta(scopeId);
-    
+
     return {
       lastSyncUp: meta.lastSyncUp,
       lastSyncDown: meta.lastSyncDown,
       promotedCount: Object.keys(meta.promotedFiles).length,
       pulledCount: Object.keys(meta.pulledFiles).length,
       promotedFiles: Object.keys(meta.promotedFiles),
-      pulledFiles: Object.keys(meta.pulledFiles)
+      pulledFiles: Object.keys(meta.pulledFiles),
     };
   }
 
@@ -452,7 +446,7 @@ class ScopeSync {
         case 'keep-shared': {
           // Overwrite with shared
           await fs.copy(conflict.shared || conflict.source, conflict.local || conflict.target, {
-            overwrite: true
+            overwrite: true,
           });
           result.action = 'kept-shared';
           result.success = true;
@@ -464,7 +458,7 @@ class ScopeSync {
           const backupPath = `${conflict.local || conflict.target}.backup.${Date.now()}`;
           await fs.copy(conflict.local || conflict.target, backupPath);
           await fs.copy(conflict.shared || conflict.source, conflict.local || conflict.target, {
-            overwrite: true
+            overwrite: true,
           });
           result.action = 'backed-up-and-updated';
           result.backupPath = backupPath;

package/src/core/lib/scope/scope-validator.js

@@ -7,13 +7,13 @@ const yaml = require('yaml');
 class ScopeValidator {
   constructor() {
     // Scope ID validation pattern: lowercase alphanumeric + hyphens, 2-50 chars
-    
+
     // Reserved scope IDs that cannot be used
     this.reservedIds = ['_shared', '_events', '_config', 'global', 'default'];
-    
+
     // Valid isolation modes
     this.validIsolationModes = ['strict', 'warn', 'permissive'];
-    
+
     // Valid scope statuses
     this.validStatuses = ['active', 'archived'];
   }
@@ -38,7 +38,8 @@ class ScopeValidator {
     if (!this.scopeIdPattern.test(scopeId)) {
       return {
         valid: false,
-        error: 'Scope ID must start with lowercase letter, contain only lowercase letters, numbers, and hyphens, and end with letter or number'
+        error:
+          'Scope ID must start with lowercase letter, contain only lowercase letters, numbers, and hyphens, and end with letter or number',
       };
     }
 
@@ -46,7 +47,7 @@ class ScopeValidator {
     if (this.reservedIds.includes(scopeId)) {
       return {
         valid: false,
-        error: `Scope ID '${scopeId}' is reserved and cannot be used`
+        error: `Scope ID '${scopeId}' is reserved and cannot be used`,
       };
     }
 
@@ -132,8 +133,8 @@ class ScopeValidator {
           }
         }
         if (scope._meta.artifact_count !== undefined && (!Number.isInteger(scope._meta.artifact_count) || scope._meta.artifact_count < 0)) {
-            errors.push('_meta.artifact_count must be a non-negative integer');
-          }
+          errors.push('_meta.artifact_count must be a non-negative integer');
+        }
       } else {
         errors.push('Scope _meta must be an object');
       }
@@ -141,7 +142,7 @@ class ScopeValidator {
 
     return {
       valid: errors.length === 0,
-      errors
+      errors,
     };
   }
 
@@ -172,13 +173,7 @@ class ScopeValidator {
       // Recursively check this dependency's dependencies
       const depScope = allScopes[dep];
       if (depScope && depScope.dependencies) {
-        const result = this.detectCircularDependencies(
-          dep,
-          depScope.dependencies,
-          allScopes,
-          new Set(visited),
-          [...chain]
-        );
+        const result = this.detectCircularDependencies(dep, depScope.dependencies, allScopes, new Set(visited), [...chain]);
         if (result.hasCircular) {
           return result;
         }
@@ -249,7 +244,7 @@ class ScopeValidator {
 
     return {
       valid: errors.length === 0,
-      errors
+      errors,
     };
   }
 
@@ -262,17 +257,17 @@ class ScopeValidator {
     try {
       const config = yaml.parse(yamlContent);
       const validation = this.validateConfig(config);
-      
+
       return {
         valid: validation.valid,
         errors: validation.errors,
-        config: validation.valid ? config : null
+        config: validation.valid ? config : null,
       };
     } catch (error) {
       return {
         valid: false,
         errors: [`Failed to parse YAML: ${error.message}`],
-        config: null
+        config: null,
       };
     }
   }
@@ -288,9 +283,9 @@ class ScopeValidator {
         allow_adhoc_scopes: true,
         isolation_mode: 'strict',
         default_output_base: '_bmad-output',
-        default_shared_path: '_bmad-output/_shared'
+        default_shared_path: '_bmad-output/_shared',
       },
-      scopes: {}
+      scopes: {},
     };
   }
   scopeIdPattern = /^[a-z][a-z0-9-]*[a-z0-9]$/;

package/src/core/lib/scope/state-lock.js

@@ -5,11 +5,11 @@ const yaml = require('yaml');
 /**
  * File locking utilities for safe concurrent access to state files
  * Uses file-based locking for cross-process synchronization
- * 
+ *
  * @class StateLock
  * @requires fs-extra
  * @requires yaml
- * 
+ *
  * @example
  * const lock = new StateLock();
  * const result = await lock.withLock('/path/to/state.yaml', async () => {
@@ -57,25 +57,22 @@ class StateLock {
    */
   async acquireLock(filePath) {
     const lockPath = this.getLockPath(filePath);
-    
+
     for (let attempt = 0; attempt < this.retries; attempt++) {
       try {
         // Check if lock exists
         const lockExists = await fs.pathExists(lockPath);
-        
+
         if (lockExists) {
           // Check if lock is stale
           const isStale = await this.isLockStale(lockPath);
-          
+
           if (isStale) {
             // Remove stale lock
             await fs.remove(lockPath);
           } else {
             // Lock is active, wait and retry
-            const waitTime = Math.min(
-              this.minTimeout * Math.pow(2, attempt),
-              this.maxTimeout
-            );
+            const waitTime = Math.min(this.minTimeout * Math.pow(2, attempt), this.maxTimeout);
             await this.sleep(waitTime);
             continue;
           }
@@ -85,22 +82,19 @@ class StateLock {
         const lockContent = {
           pid: process.pid,
           hostname: require('node:os').hostname(),
-          created: new Date().toISOString()
+          created: new Date().toISOString(),
         };
 
         // Use exclusive flag for atomic creation
         await fs.writeFile(lockPath, JSON.stringify(lockContent), {
-          flag: 'wx' // Exclusive create
+          flag: 'wx', // Exclusive create
         });
 
         return { success: true, lockPath };
       } catch (error) {
         if (error.code === 'EEXIST') {
           // Lock was created by another process, retry
-          const waitTime = Math.min(
-            this.minTimeout * Math.pow(2, attempt),
-            this.maxTimeout
-          );
+          const waitTime = Math.min(this.minTimeout * Math.pow(2, attempt), this.maxTimeout);
           await this.sleep(waitTime);
           continue;
         }
@@ -118,7 +112,7 @@ class StateLock {
    */
   async releaseLock(filePath) {
     const lockPath = this.getLockPath(filePath);
-    
+
     try {
       await fs.remove(lockPath);
       return true;
@@ -138,7 +132,7 @@ class StateLock {
    */
   async withLock(filePath, operation) {
     const lockResult = await this.acquireLock(filePath);
-    
+
     if (!lockResult.success) {
       throw new Error(`Failed to acquire lock on ${filePath}: ${lockResult.reason}`);
     }
@@ -159,12 +153,12 @@ class StateLock {
     try {
       const content = await fs.readFile(filePath, 'utf8');
       const data = yaml.parse(content);
-      
+
       // Ensure version field exists
       if (!data._version) {
         data._version = 0;
       }
-      
+
       return data;
     } catch (error) {
       if (error.code === 'ENOENT') {
@@ -183,17 +177,17 @@ class StateLock {
   async writeYaml(filePath, data) {
     // Ensure directory exists
     await fs.ensureDir(path.dirname(filePath));
-    
+
     // Update version and timestamp
     const versionedData = {
       ...data,
       _version: (data._version || 0) + 1,
-      _lastModified: new Date().toISOString()
+      _lastModified: new Date().toISOString(),
     };
 
     const yamlContent = yaml.stringify(versionedData, { indent: 2 });
     await fs.writeFile(filePath, yamlContent, 'utf8');
-    
+
     return versionedData;
   }
 
@@ -208,17 +202,17 @@ class StateLock {
       // Read current data
       const data = await this.readYaml(filePath);
       const currentVersion = data._version || 0;
-      
+
       // Apply modifications
       const modified = await modifier(data);
-      
+
       // Update version
       modified._version = currentVersion + 1;
       modified._lastModified = new Date().toISOString();
-      
+
       // Write back
       await this.writeYaml(filePath, modified);
-      
+
       return modified;
     });
   }
@@ -233,30 +227,30 @@ class StateLock {
   async optimisticUpdate(filePath, expectedVersion, newData) {
     return this.withLock(filePath, async () => {
       const current = await this.readYaml(filePath);
-      
+
       // Check version
       if (current._version !== expectedVersion) {
         return {
           success: false,
           data: current,
           conflict: true,
-          message: `Version conflict: expected ${expectedVersion}, found ${current._version}`
+          message: `Version conflict: expected ${expectedVersion}, found ${current._version}`,
         };
       }
-      
+
       // Update with new version
       const updated = {
         ...newData,
         _version: expectedVersion + 1,
-        _lastModified: new Date().toISOString()
+        _lastModified: new Date().toISOString(),
       };
-      
+
       await this.writeYaml(filePath, updated);
-      
+
       return {
         success: true,
         data: updated,
-        conflict: false
+        conflict: false,
       };
     });
   }
@@ -267,7 +261,7 @@ class StateLock {
    * @returns {Promise<void>}
    */
   sleep(ms) {
-    return new Promise(resolve => setTimeout(resolve, ms));
+    return new Promise((resolve) => setTimeout(resolve, ms));
   }
 
   /**
@@ -277,14 +271,14 @@ class StateLock {
    */
   async isLocked(filePath) {
     const lockPath = this.getLockPath(filePath);
-    
+
     try {
       const exists = await fs.pathExists(lockPath);
-      
+
       if (!exists) {
         return false;
       }
-      
+
       // Check if lock is stale
       const isStale = await this.isLockStale(lockPath);
       return !isStale;
@@ -300,22 +294,22 @@ class StateLock {
    */
   async getLockInfo(filePath) {
     const lockPath = this.getLockPath(filePath);
-    
+
     try {
       const exists = await fs.pathExists(lockPath);
-      
+
       if (!exists) {
         return null;
       }
-      
+
       const content = await fs.readFile(lockPath, 'utf8');
       const info = JSON.parse(content);
       const stat = await fs.stat(lockPath);
-      
+
       return {
         ...info,
         age: Date.now() - stat.mtimeMs,
-        isStale: Date.now() - stat.mtimeMs > this.staleTimeout
+        isStale: Date.now() - stat.mtimeMs > this.staleTimeout,
       };
     } catch {
       return null;
@@ -329,7 +323,7 @@ class StateLock {
    */
   async forceRelease(filePath) {
     const lockPath = this.getLockPath(filePath);
-    
+
     try {
       await fs.remove(lockPath);
       return true;

package/src/core/module.yaml

@@ -29,12 +29,12 @@ output_folder:
 scope_settings:
   header: "Scope System Settings"
   subheader: "Configure multi-scope artifact isolation"
-  
+
   allow_adhoc_scopes:
     prompt: "Allow creating scopes on-demand during workflows?"
     default: true
     result: "{value}"
-  
+
   isolation_mode:
     prompt: "Scope isolation mode"
     default: "strict"