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

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

@@ -2,16 +2,17 @@ const path = require('node:path');
 const fs = require('fs-extra');
 const yaml = require('yaml');
 const { ScopeValidator } = require('./scope-validator');
+const { ScopeInitializer } = require('./scope-initializer');
 
 /**
  * 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,8 +24,9 @@ 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.initializer = new ScopeInitializer({ projectRoot: this.projectRoot });
     this._config = null; // Cached configuration
   }
 
@@ -38,6 +40,7 @@ class ScopeManager {
     this.configPath = path.join(this.bmadPath, '_config');
     this.scopesFilePath = path.join(this.configPath, 'scopes.yaml');
     this._config = null; // Clear cache
+    this.initializer.setProjectRoot(projectRoot);
   }
 
   /**
@@ -52,13 +55,16 @@ class ScopeManager {
 
       // Check if scopes.yaml exists
       const exists = await fs.pathExists(this.scopesFilePath);
-      
+
       if (!exists) {
         // Create default configuration
         const defaultConfig = this.validator.createDefaultConfig();
         await this.saveConfig(defaultConfig);
       }
 
+      // Initialize scope system directories (_shared, _events)
+      await this.initializer.initializeScopeSystem();
+
       // Load and validate configuration
       const config = await this.loadConfig();
       return config !== null;
@@ -122,7 +128,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 +152,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 +229,8 @@ class ScopeManager {
         created: new Date().toISOString(),
         _meta: {
           last_activity: new Date().toISOString(),
-          artifact_count: 0
-        }
+          artifact_count: 0,
+        },
       };
 
       // Validate scope with existing scopes
@@ -239,6 +245,9 @@ class ScopeManager {
       // Save configuration
       await this.saveConfig(config);
 
+      // Create scope directory structure
+      await this.initializer.initializeScope(scopeId, options);
+
       return scope;
     } catch (error) {
       throw new Error(`Failed to create scope '${scopeId}': ${error.message}`);
@@ -272,8 +281,8 @@ class ScopeManager {
         _meta: {
           ...currentScope._meta,
           ...updates._meta,
-          last_activity: new Date().toISOString()
-        }
+          last_activity: new Date().toISOString(),
+        },
       };
 
       // Validate updated scope
@@ -311,10 +320,10 @@ class ScopeManager {
       }
 
       // Check if other scopes depend on this one
-      const dependentScopes = this.findDependentScopes(scopeId, config.scopes);
+      const dependentScopes = this.findDependentScopesSync(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 +334,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 +356,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 +369,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 +397,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 +405,7 @@ class ScopeManager {
       const tree = {
         scope: scopeId,
         dependencies: [],
-        dependents: this.findDependentScopes(scopeId, config.scopes)
+        dependents: this.findDependentScopesSync(scopeId, config.scopes),
       };
 
       // Build dependency tree recursively
@@ -407,7 +416,7 @@ class ScopeManager {
             tree.dependencies.push({
               scope: depId,
               name: depScope.name,
-              status: depScope.status
+              status: depScope.status,
             });
           }
         }
@@ -422,12 +431,36 @@ class ScopeManager {
   /**
    * Find scopes that depend on a given scope
    * @param {string} scopeId - The scope ID
-   * @param {object} allScopes - All scopes object
+   * @param {object} allScopes - All scopes object (optional, will load if not provided)
+   * @returns {Promise<string[]>|string[]} Array of dependent scope IDs
+   */
+  async findDependentScopes(scopeId, allScopes = null) {
+    // If allScopes not provided, load from config
+    if (!allScopes) {
+      const config = await this.loadConfig();
+      allScopes = config.scopes || {};
+    }
+
+    const dependents = [];
+
+    for (const [sid, scope] of Object.entries(allScopes)) {
+      if (scope.dependencies && scope.dependencies.includes(scopeId)) {
+        dependents.push(sid);
+      }
+    }
+
+    return dependents;
+  }
+
+  /**
+   * Find scopes that depend on a given scope (synchronous version)
+   * @param {string} scopeId - The scope ID
+   * @param {object} allScopes - All scopes object (required)
    * @returns {string[]} Array of dependent scope IDs
    */
-  findDependentScopes(scopeId, allScopes) {
+  findDependentScopesSync(scopeId, allScopes) {
     const dependents = [];
-    
+
     for (const [sid, scope] of Object.entries(allScopes)) {
       if (scope.dependencies && scope.dependencies.includes(scopeId)) {
         dependents.push(sid);
@@ -462,7 +495,7 @@ class ScopeManager {
    */
   async touchScope(scopeId) {
     return this.updateScope(scopeId, {
-      _meta: { last_activity: new Date().toISOString() }
+      _meta: { last_activity: new Date().toISOString() },
     });
   }
 
@@ -480,7 +513,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 +535,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) {