bmad-fh 6.0.0-alpha.23 → 6.0.0-alpha.23.02a963fa

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

@@ -5,11 +5,11 @@ const yaml = require('yaml');
 /**
  * Initializes directory structure for scopes
  * Creates scope directories, shared layer, and event system
- * 
+ *
  * @class ScopeInitializer
  * @requires fs-extra
  * @requires yaml
- * 
+ *
  * @example
  * const initializer = new ScopeInitializer({ projectRoot: '/path/to/project' });
  * await initializer.initializeScope('auth');
@@ -70,14 +70,14 @@ class ScopeInitializer {
 
       // Create README in shared directory
       const sharedReadmePath = path.join(this.sharedPath, 'README.md');
-      if (!await fs.pathExists(sharedReadmePath)) {
+      if (!(await fs.pathExists(sharedReadmePath))) {
         const readmeContent = this.generateSharedReadme();
         await fs.writeFile(sharedReadmePath, readmeContent, 'utf8');
       }
 
       // Create global project-context.md template
       const contextPath = path.join(this.sharedPath, 'project-context.md');
-      if (!await fs.pathExists(contextPath)) {
+      if (!(await fs.pathExists(contextPath))) {
         const contextContent = this.generateGlobalContextTemplate();
         await fs.writeFile(contextPath, contextContent, 'utf8');
       }
@@ -100,20 +100,20 @@ class ScopeInitializer {
 
       // Create event-log.yaml
       const eventLogPath = path.join(this.eventsPath, 'event-log.yaml');
-      if (!await fs.pathExists(eventLogPath)) {
+      if (!(await fs.pathExists(eventLogPath))) {
         const eventLog = {
           version: 1,
-          events: []
+          events: [],
         };
         await fs.writeFile(eventLogPath, yaml.stringify(eventLog), 'utf8');
       }
 
       // Create subscriptions.yaml
       const subscriptionsPath = path.join(this.eventsPath, 'subscriptions.yaml');
-      if (!await fs.pathExists(subscriptionsPath)) {
+      if (!(await fs.pathExists(subscriptionsPath))) {
         const subscriptions = {
           version: 1,
-          subscriptions: {}
+          subscriptions: {},
         };
         await fs.writeFile(subscriptionsPath, yaml.stringify(subscriptions), 'utf8');
       }
@@ -135,10 +135,8 @@ class ScopeInitializer {
       const scopePath = path.join(this.outputPath, scopeId);
 
       // Check if scope directory already exists
-      if (await fs.pathExists(scopePath)) {
-        if (!options.force) {
-          throw new Error(`Scope directory '${scopeId}' already exists. Use force option to recreate.`);
-        }
+      if ((await fs.pathExists(scopePath)) && !options.force) {
+        throw new Error(`Scope directory '${scopeId}' already exists. Use force option to recreate.`);
       }
 
       // Create scope directory structure
@@ -147,7 +145,7 @@ class ScopeInitializer {
         planning: path.join(scopePath, 'planning-artifacts'),
         implementation: path.join(scopePath, 'implementation-artifacts'),
         tests: path.join(scopePath, 'tests'),
-        meta: path.join(scopePath, '.scope-meta.yaml')
+        meta: path.join(scopePath, '.scope-meta.yaml'),
       };
 
       // Create directories
@@ -163,14 +161,14 @@ class ScopeInitializer {
         structure: {
           planning_artifacts: 'planning-artifacts/',
           implementation_artifacts: 'implementation-artifacts/',
-          tests: 'tests/'
-        }
+          tests: 'tests/',
+        },
       };
       await fs.writeFile(paths.meta, yaml.stringify(metadata), 'utf8');
 
       // Create README in scope directory
       const readmePath = path.join(scopePath, 'README.md');
-      if (!await fs.pathExists(readmePath)) {
+      if (!(await fs.pathExists(readmePath))) {
         const readmeContent = this.generateScopeReadme(scopeId, options);
         await fs.writeFile(readmePath, readmeContent, 'utf8');
       }
@@ -199,7 +197,7 @@ class ScopeInitializer {
       const scopePath = path.join(this.outputPath, scopeId);
 
       // Check if scope exists
-      if (!await fs.pathExists(scopePath)) {
+      if (!(await fs.pathExists(scopePath))) {
         throw new Error(`Scope directory '${scopeId}' does not exist`);
       }
 
@@ -251,7 +249,7 @@ class ScopeInitializer {
       implementation: path.join(scopePath, 'implementation-artifacts'),
       tests: path.join(scopePath, 'tests'),
       meta: path.join(scopePath, '.scope-meta.yaml'),
-      context: path.join(scopePath, 'project-context.md')
+      context: path.join(scopePath, 'project-context.md'),
     };
   }
 
@@ -281,9 +279,9 @@ The shared layer enables:
 
 ## Usage
 
-1. **Reading**: All scopes can read from \\`_shared/\\`
-2. **Writing**: Use \\`bmad scope sync-up <scope>\\` to promote artifacts
-3. **Syncing**: Use \\`bmad scope sync-down <scope>\\` to pull updates
+1. **Reading**: All scopes can read from \`_shared/\`
+2. **Writing**: Use \`bmad scope sync-up <scope>\` to promote artifacts
+3. **Syncing**: Use \`bmad scope sync-down <scope>\` to pull updates
 
 ## Best Practices
 
@@ -368,16 +366,14 @@ ${description}
 
 ## Scope Information
 
-- **ID:** \\`${scopeId}\\`
+- **ID:** ${scopeId}
 - **Name:** ${scopeName}
 - **Status:** ${options.status || 'active'}
 - **Created:** ${new Date().toISOString().split('T')[0]}
 
 ## Dependencies
 
-${options.dependencies && options.dependencies.length > 0
-    ? options.dependencies.map(dep => `- \\`${dep}\\``).join('\n')
-    : 'No dependencies'}
+${options.dependencies && options.dependencies.length > 0 ? options.dependencies.map((dep) => `- ${dep}`).join('\n') : 'No dependencies'}
 
 ## Usage
 
@@ -403,8 +399,8 @@ bmad scope sync-down ${scopeId}
 
 ## Related Documentation
 
-- Global context: \\`../_shared/project-context.md\\`
-- Contracts: \\`../_shared/contracts/\\`
+- Global context: ../_shared/project-context.md
+- Contracts: ../_shared/contracts/
 `;
   }
 
@@ -419,7 +415,7 @@ bmad scope sync-down ${scopeId}
 
     return `# Scope Context: ${scopeName}
 
-> This context extends the global project context in \\`../_shared/project-context.md\\`
+> This context extends the global project context in ../_shared/project-context.md
 
 ## Scope Purpose
 
@@ -436,9 +432,11 @@ bmad scope sync-down ${scopeId}
 ## Integration Points
 
 ### Dependencies
-${options.dependencies && options.dependencies.length > 0
-    ? options.dependencies.map(dep => `- **${dep}**: [Describe dependency relationship]`).join('\n')
-    : 'No dependencies'}
+${
+  options.dependencies && options.dependencies.length > 0
+    ? options.dependencies.map((dep) => `- **${dep}**: [Describe dependency relationship]`).join('\n')
+    : 'No dependencies'
+}
 
 ### Provides
 [What this scope provides to other scopes]

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

@@ -6,12 +6,12 @@ const { ScopeValidator } = require('./scope-validator');
 /**
  * Manages scope lifecycle and CRUD operations
  * Handles scope configuration in scopes.yaml file
- * 
+ *
  * @class ScopeManager
  * @requires fs-extra
  * @requires yaml
  * @requires ScopeValidator
- * 
+ *
  * @example
  * const manager = new ScopeManager({ projectRoot: '/path/to/project' });
  * await manager.initialize();
@@ -23,7 +23,7 @@ class ScopeManager {
     this.bmadPath = options.bmadPath || path.join(this.projectRoot, '_bmad');
     this.configPath = options.configPath || path.join(this.bmadPath, '_config');
     this.scopesFilePath = options.scopesFilePath || path.join(this.configPath, 'scopes.yaml');
-    
+
     this.validator = new ScopeValidator();
     this._config = null; // Cached configuration
   }
@@ -52,7 +52,7 @@ class ScopeManager {
 
       // Check if scopes.yaml exists
       const exists = await fs.pathExists(this.scopesFilePath);
-      
+
       if (!exists) {
         // Create default configuration
         const defaultConfig = this.validator.createDefaultConfig();
@@ -122,7 +122,7 @@ class ScopeManager {
       // Write to file
       const yamlContent = yaml.stringify(config, {
         indent: 2,
-        lineWidth: 100
+        lineWidth: 100,
       });
       await fs.writeFile(this.scopesFilePath, yamlContent, 'utf8');
 
@@ -146,7 +146,7 @@ class ScopeManager {
 
       // Apply filters
       if (filters.status) {
-        scopes = scopes.filter(scope => scope.status === filters.status);
+        scopes = scopes.filter((scope) => scope.status === filters.status);
       }
 
       // Sort by created date (newest first)
@@ -223,8 +223,8 @@ class ScopeManager {
         created: new Date().toISOString(),
         _meta: {
           last_activity: new Date().toISOString(),
-          artifact_count: 0
-        }
+          artifact_count: 0,
+        },
       };
 
       // Validate scope with existing scopes
@@ -272,8 +272,8 @@ class ScopeManager {
         _meta: {
           ...currentScope._meta,
           ...updates._meta,
-          last_activity: new Date().toISOString()
-        }
+          last_activity: new Date().toISOString(),
+        },
       };
 
       // Validate updated scope
@@ -314,7 +314,7 @@ class ScopeManager {
       const dependentScopes = this.findDependentScopes(scopeId, config.scopes);
       if (dependentScopes.length > 0 && !options.force) {
         throw new Error(
-          `Cannot remove scope '${scopeId}'. The following scopes depend on it: ${dependentScopes.join(', ')}. Use force option to remove anyway.`
+          `Cannot remove scope '${scopeId}'. The following scopes depend on it: ${dependentScopes.join(', ')}. Use force option to remove anyway.`,
         );
       }
 
@@ -325,7 +325,7 @@ class ScopeManager {
       if (options.force && dependentScopes.length > 0) {
         for (const depScopeId of dependentScopes) {
           const depScope = config.scopes[depScopeId];
-          depScope.dependencies = depScope.dependencies.filter(dep => dep !== scopeId);
+          depScope.dependencies = depScope.dependencies.filter((dep) => dep !== scopeId);
         }
       }
 
@@ -347,7 +347,7 @@ class ScopeManager {
     try {
       const config = await this.loadConfig();
       const scope = config.scopes[scopeId];
-      
+
       if (!scope) {
         throw new Error(`Scope '${scopeId}' does not exist`);
       }
@@ -360,7 +360,7 @@ class ScopeManager {
         planning: path.join(scopePath, 'planning-artifacts'),
         implementation: path.join(scopePath, 'implementation-artifacts'),
         tests: path.join(scopePath, 'tests'),
-        meta: path.join(scopePath, '.scope-meta.yaml')
+        meta: path.join(scopePath, '.scope-meta.yaml'),
       };
     } catch (error) {
       throw new Error(`Failed to get scope paths for '${scopeId}': ${error.message}`);
@@ -388,7 +388,7 @@ class ScopeManager {
     try {
       const config = await this.loadConfig();
       const scope = config.scopes[scopeId];
-      
+
       if (!scope) {
         throw new Error(`Scope '${scopeId}' does not exist`);
       }
@@ -396,7 +396,7 @@ class ScopeManager {
       const tree = {
         scope: scopeId,
         dependencies: [],
-        dependents: this.findDependentScopes(scopeId, config.scopes)
+        dependents: this.findDependentScopes(scopeId, config.scopes),
       };
 
       // Build dependency tree recursively
@@ -407,7 +407,7 @@ class ScopeManager {
             tree.dependencies.push({
               scope: depId,
               name: depScope.name,
-              status: depScope.status
+              status: depScope.status,
             });
           }
         }
@@ -427,7 +427,7 @@ class ScopeManager {
    */
   findDependentScopes(scopeId, allScopes) {
     const dependents = [];
-    
+
     for (const [sid, scope] of Object.entries(allScopes)) {
       if (scope.dependencies && scope.dependencies.includes(scopeId)) {
         dependents.push(sid);
@@ -462,7 +462,7 @@ class ScopeManager {
    */
   async touchScope(scopeId) {
     return this.updateScope(scopeId, {
-      _meta: { last_activity: new Date().toISOString() }
+      _meta: { last_activity: new Date().toISOString() },
     });
   }
 
@@ -480,7 +480,7 @@ class ScopeManager {
 
     const currentCount = scope._meta?.artifact_count || 0;
     return this.updateScope(scopeId, {
-      _meta: { artifact_count: currentCount + increment }
+      _meta: { artifact_count: currentCount + increment },
     });
   }
 
@@ -502,7 +502,7 @@ class ScopeManager {
     const config = await this.loadConfig();
     config.settings = {
       ...config.settings,
-      ...settings
+      ...settings,
     };
     await this.saveConfig(config);
     return config.settings;

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

@@ -5,11 +5,11 @@ const yaml = require('yaml');
 /**
  * Migrates existing artifacts to scoped structure
  * Handles migration of legacy non-scoped installations
- * 
+ *
  * @class ScopeMigrator
  * @requires fs-extra
  * @requires yaml
- * 
+ *
  * @example
  * const migrator = new ScopeMigrator({ projectRoot: '/path/to/project' });
  * await migrator.migrate();
@@ -41,18 +41,14 @@ class ScopeMigrator {
   async needsMigration() {
     try {
       // Check if output directory exists
-      if (!await fs.pathExists(this.outputPath)) {
+      if (!(await fs.pathExists(this.outputPath))) {
         return false;
       }
 
       // Check for legacy structure indicators
-      const hasLegacyPlanning = await fs.pathExists(
-        path.join(this.outputPath, 'planning-artifacts')
-      );
-      const hasLegacyImplementation = await fs.pathExists(
-        path.join(this.outputPath, 'implementation-artifacts')
-      );
-      
+      const hasLegacyPlanning = await fs.pathExists(path.join(this.outputPath, 'planning-artifacts'));
+      const hasLegacyImplementation = await fs.pathExists(path.join(this.outputPath, 'implementation-artifacts'));
+
       // Check if already migrated (scopes.yaml exists and has scopes)
       const scopesYamlPath = path.join(this.bmadPath, '_config', 'scopes.yaml');
       if (await fs.pathExists(scopesYamlPath)) {
@@ -80,23 +76,19 @@ class ScopeMigrator {
       directories: [],
       files: [],
       totalSize: 0,
-      suggestedScope: this.defaultScopeId
+      suggestedScope: this.defaultScopeId,
     };
 
     try {
       // Check for legacy directories
-      const legacyDirs = [
-        'planning-artifacts',
-        'implementation-artifacts',
-        'tests'
-      ];
+      const legacyDirs = ['planning-artifacts', 'implementation-artifacts', 'tests'];
 
       for (const dir of legacyDirs) {
         const dirPath = path.join(this.outputPath, dir);
         if (await fs.pathExists(dirPath)) {
           analysis.hasLegacyArtifacts = true;
           analysis.directories.push(dir);
-          
+
           // Count files and size
           const stats = await this.getDirStats(dirPath);
           analysis.files.push(...stats.files);
@@ -115,7 +107,6 @@ class ScopeMigrator {
           analysis.totalSize += stat.size;
         }
       }
-
     } catch (error) {
       throw new Error(`Failed to analyze existing artifacts: ${error.message}`);
     }
@@ -130,16 +121,16 @@ class ScopeMigrator {
    */
   async getDirStats(dirPath) {
     const stats = { files: [], size: 0 };
-    
+
     try {
       const entries = await fs.readdir(dirPath, { withFileTypes: true });
-      
+
       for (const entry of entries) {
         const fullPath = path.join(dirPath, entry.name);
-        
+
         if (entry.isDirectory()) {
           const subStats = await this.getDirStats(fullPath);
-          stats.files.push(...subStats.files.map(f => path.join(entry.name, f)));
+          stats.files.push(...subStats.files.map((f) => path.join(entry.name, f)));
           stats.size += subStats.size;
         } else {
           stats.files.push(entry.name);
@@ -150,7 +141,7 @@ class ScopeMigrator {
     } catch {
       // Ignore permission errors
     }
-    
+
     return stats;
   }
 
@@ -161,10 +152,10 @@ class ScopeMigrator {
   async createBackup() {
     const backupName = `_backup_migration_${Date.now()}`;
     const backupPath = path.join(this.outputPath, backupName);
-    
+
     try {
       await fs.ensureDir(backupPath);
-      
+
       // Copy legacy directories
       const legacyDirs = ['planning-artifacts', 'implementation-artifacts', 'tests'];
       for (const dir of legacyDirs) {
@@ -173,7 +164,7 @@ class ScopeMigrator {
           await fs.copy(sourcePath, path.join(backupPath, dir));
         }
       }
-      
+
       // Copy root-level files
       const rootFiles = ['project-context.md', 'sprint-status.yaml', 'bmm-workflow-status.yaml'];
       for (const file of rootFiles) {
@@ -182,7 +173,7 @@ class ScopeMigrator {
           await fs.copy(sourcePath, path.join(backupPath, file));
         }
       }
-      
+
       return backupPath;
     } catch (error) {
       throw new Error(`Failed to create backup: ${error.message}`);
@@ -197,13 +188,13 @@ class ScopeMigrator {
   async migrate(options = {}) {
     const scopeId = options.scopeId || this.defaultScopeId;
     const createBackup = options.backup !== false;
-    
+
     const result = {
       success: false,
       scopeId,
       backupPath: null,
       migratedFiles: [],
-      errors: []
+      errors: [],
     };
 
     try {
@@ -225,7 +216,7 @@ class ScopeMigrator {
       const scopeDirs = {
         planning: path.join(scopePath, 'planning-artifacts'),
         implementation: path.join(scopePath, 'implementation-artifacts'),
-        tests: path.join(scopePath, 'tests')
+        tests: path.join(scopePath, 'tests'),
       };
 
       for (const dir of Object.values(scopeDirs)) {
@@ -236,7 +227,7 @@ class ScopeMigrator {
       const migrations = [
         { from: 'planning-artifacts', to: scopeDirs.planning },
         { from: 'implementation-artifacts', to: scopeDirs.implementation },
-        { from: 'tests', to: scopeDirs.tests }
+        { from: 'tests', to: scopeDirs.tests },
       ];
 
       for (const migration of migrations) {
@@ -247,17 +238,17 @@ class ScopeMigrator {
           for (const entry of entries) {
             const sourceFile = path.join(sourcePath, entry.name);
             const targetFile = path.join(migration.to, entry.name);
-            
+
             // Skip if target already exists
             if (await fs.pathExists(targetFile)) {
               result.errors.push(`Skipped ${entry.name}: already exists in target`);
               continue;
             }
-            
+
             await fs.copy(sourceFile, targetFile);
             result.migratedFiles.push(path.join(migration.from, entry.name));
           }
-          
+
           // Remove original directory
           await fs.remove(sourcePath);
         }
@@ -267,7 +258,7 @@ class ScopeMigrator {
       const rootFileMigrations = [
         { from: 'project-context.md', to: path.join(scopePath, 'project-context.md') },
         { from: 'sprint-status.yaml', to: path.join(scopeDirs.implementation, 'sprint-status.yaml') },
-        { from: 'bmm-workflow-status.yaml', to: path.join(scopeDirs.planning, 'bmm-workflow-status.yaml') }
+        { from: 'bmm-workflow-status.yaml', to: path.join(scopeDirs.planning, 'bmm-workflow-status.yaml') },
       ];
 
       for (const migration of rootFileMigrations) {
@@ -290,20 +281,19 @@ class ScopeMigrator {
         migrated: true,
         migrated_at: new Date().toISOString(),
         original_backup: result.backupPath,
-        version: 1
+        version: 1,
       };
       await fs.writeFile(metaPath, yaml.stringify(metadata), 'utf8');
 
       // Create scope README
       const readmePath = path.join(scopePath, 'README.md');
-      if (!await fs.pathExists(readmePath)) {
+      if (!(await fs.pathExists(readmePath))) {
         const readme = this.generateMigrationReadme(scopeId, result.migratedFiles.length);
         await fs.writeFile(readmePath, readme, 'utf8');
       }
 
       result.success = true;
       result.message = `Migrated ${result.migratedFiles.length} items to scope '${scopeId}'`;
-
     } catch (error) {
       result.success = false;
       result.errors.push(error.message);
@@ -359,22 +349,22 @@ bmad scope info ${scopeId}
    */
   async rollback(backupPath) {
     try {
-      if (!await fs.pathExists(backupPath)) {
+      if (!(await fs.pathExists(backupPath))) {
         throw new Error(`Backup not found at: ${backupPath}`);
       }
 
       // Restore backed up directories
       const entries = await fs.readdir(backupPath, { withFileTypes: true });
-      
+
       for (const entry of entries) {
         const sourcePath = path.join(backupPath, entry.name);
         const targetPath = path.join(this.outputPath, entry.name);
-        
+
         // Remove current version if exists
         if (await fs.pathExists(targetPath)) {
           await fs.remove(targetPath);
         }
-        
+
         // Restore from backup
         await fs.copy(sourcePath, targetPath);
       }
@@ -395,34 +385,36 @@ bmad scope info ${scopeId}
    */
   async updateReferences(scopeId) {
     const result = { updated: [], errors: [] };
-    
+
     const scopePath = path.join(this.outputPath, scopeId);
-    
+
     // Files that might contain path references
     const filesToUpdate = [
       path.join(scopePath, 'implementation-artifacts', 'sprint-status.yaml'),
-      path.join(scopePath, 'planning-artifacts', 'bmm-workflow-status.yaml')
+      path.join(scopePath, 'planning-artifacts', 'bmm-workflow-status.yaml'),
     ];
 
     for (const filePath of filesToUpdate) {
       if (await fs.pathExists(filePath)) {
         try {
           let content = await fs.readFile(filePath, 'utf8');
-          
+
           // Update common path patterns
           const patterns = [
             { from: /planning-artifacts\//g, to: `${scopeId}/planning-artifacts/` },
             { from: /implementation-artifacts\//g, to: `${scopeId}/implementation-artifacts/` },
-            { from: /tests\//g, to: `${scopeId}/tests/` }
+            { from: /tests\//g, to: `${scopeId}/tests/` },
           ];
 
           let modified = false;
           for (const pattern of patterns) {
-            if (pattern.from.test(content) && // Only update if not already scoped
-              !content.includes(`${scopeId}/`)) {
-                content = content.replace(pattern.from, pattern.to);
-                modified = true;
-              }
+            if (
+              pattern.from.test(content) && // Only update if not already scoped
+              !content.includes(`${scopeId}/`)
+            ) {
+              content = content.replace(pattern.from, pattern.to);
+              modified = true;
+            }
           }
 
           if (modified) {