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

package/tools/cli/commands/scope.js

@@ -32,30 +32,30 @@ function displayScopeList(scopes) {
   }
 
   console.log(chalk.bold('\n  Scopes:\n'));
-  
+
   // Calculate column widths
-  const idWidth = Math.max(10, ...scopes.map(s => s.id.length)) + 2;
-  const nameWidth = Math.max(15, ...scopes.map(s => (s.name || '').length)) + 2;
-  
+  const idWidth = Math.max(10, ...scopes.map((s) => s.id.length)) + 2;
+  const nameWidth = Math.max(15, ...scopes.map((s) => (s.name || '').length)) + 2;
+
   // Header
   console.log(
     chalk.dim('  ') +
-    chalk.bold('ID'.padEnd(idWidth)) +
-    chalk.bold('Name'.padEnd(nameWidth)) +
-    chalk.bold('Status'.padEnd(10)) +
-    chalk.bold('Created')
+      chalk.bold('ID'.padEnd(idWidth)) +
+      chalk.bold('Name'.padEnd(nameWidth)) +
+      chalk.bold('Status'.padEnd(10)) +
+      chalk.bold('Created'),
   );
   console.log(chalk.dim('  ' + '─'.repeat(idWidth + nameWidth + 10 + 20)));
-  
+
   // Rows
   for (const scope of scopes) {
     const statusColor = scope.status === 'active' ? chalk.green : chalk.dim;
     console.log(
       '  ' +
-      chalk.cyan(scope.id.padEnd(idWidth)) +
-      (scope.name || scope.id).padEnd(nameWidth) +
-      statusColor(scope.status.padEnd(10)) +
-      chalk.dim(formatDate(scope.created).split(' ')[0])
+        chalk.cyan(scope.id.padEnd(idWidth)) +
+        (scope.name || scope.id).padEnd(nameWidth) +
+        statusColor(scope.status.padEnd(10)) +
+        chalk.dim(formatDate(scope.created).split(' ')[0]),
     );
   }
   console.log();
@@ -69,7 +69,7 @@ function displayScopeList(scopes) {
  */
 function displayScopeInfo(scope, paths, tree) {
   console.log(chalk.bold(`\n  Scope: ${scope.name || scope.id}\n`));
-  
+
   console.log(chalk.dim('  ─────────────────────────────────────'));
   console.log(`  ${chalk.bold('ID:')}           ${chalk.cyan(scope.id)}`);
   console.log(`  ${chalk.bold('Name:')}         ${scope.name || 'N/A'}`);
@@ -78,13 +78,13 @@ function displayScopeInfo(scope, paths, tree) {
   console.log(`  ${chalk.bold('Created:')}      ${formatDate(scope.created)}`);
   console.log(`  ${chalk.bold('Last Active:')}  ${formatDate(scope._meta?.last_activity)}`);
   console.log(`  ${chalk.bold('Artifacts:')}    ${scope._meta?.artifact_count || 0}`);
-  
+
   console.log(chalk.dim('\n  ─────────────────────────────────────'));
   console.log(chalk.bold('  Paths:'));
   console.log(`    Planning:       ${chalk.dim(paths.planning)}`);
   console.log(`    Implementation: ${chalk.dim(paths.implementation)}`);
   console.log(`    Tests:          ${chalk.dim(paths.tests)}`);
-  
+
   console.log(chalk.dim('\n  ─────────────────────────────────────'));
   console.log(chalk.bold('  Dependencies:'));
   if (tree.dependencies.length > 0) {
@@ -95,7 +95,7 @@ function displayScopeInfo(scope, paths, tree) {
   } else {
     console.log(chalk.dim('    None'));
   }
-  
+
   console.log(chalk.bold('\n  Dependents (scopes that depend on this):'));
   if (tree.dependents.length > 0) {
     for (const dep of tree.dependents) {
@@ -104,7 +104,7 @@ function displayScopeInfo(scope, paths, tree) {
   } else {
     console.log(chalk.dim('    None'));
   }
-  
+
   console.log();
 }
 
@@ -113,7 +113,7 @@ function displayScopeInfo(scope, paths, tree) {
  */
 async function handleList(projectRoot, options) {
   const manager = new ScopeManager({ projectRoot });
-  
+
   try {
     await manager.initialize();
     const scopes = await manager.listScopes(options.status ? { status: options.status } : {});
@@ -134,7 +134,7 @@ async function handleCreate(projectRoot, scopeId, options) {
   const manager = new ScopeManager({ projectRoot });
   const initializer = new ScopeInitializer({ projectRoot });
   const validator = new ScopeValidator();
-  
+
   // If no scopeId provided, prompt for it
   if (!scopeId) {
     const inputId = await text({
@@ -143,80 +143,80 @@ async function handleCreate(projectRoot, scopeId, options) {
       validate: (value) => {
         const result = validator.validateScopeId(value);
         return result.valid ? undefined : result.error;
-      }
+      },
     });
-    
+
     if (isCancel(inputId)) {
       console.log(chalk.yellow('Cancelled.'));
       return;
     }
     scopeId = inputId;
   }
-  
+
   // Validate scope ID
   const idValidation = validator.validateScopeId(scopeId);
   if (!idValidation.valid) {
     console.error(chalk.red(`Error: ${idValidation.error}`));
     process.exit(1);
   }
-  
+
   // Get scope name if not provided
   let name = options.name;
   if (!name) {
     const inputName = await text({
       message: 'Enter scope name (human-readable):',
       placeholder: `e.g., Authentication Service`,
-      initialValue: scopeId.charAt(0).toUpperCase() + scopeId.slice(1).replaceAll('-', ' ')
+      initialValue: scopeId.charAt(0).toUpperCase() + scopeId.slice(1).replaceAll('-', ' '),
     });
-    
+
     if (isCancel(inputName)) {
       console.log(chalk.yellow('Cancelled.'));
       return;
     }
     name = inputName;
   }
-  
+
   // Get description if not provided
   let description = options.description;
   if (!description) {
     const inputDesc = await text({
       message: 'Enter scope description (optional):',
-      placeholder: 'Brief description of this scope'
+      placeholder: 'Brief description of this scope',
     });
-    
+
     if (isCancel(inputDesc)) {
       console.log(chalk.yellow('Cancelled.'));
       return;
     }
     description = inputDesc || '';
   }
-  
+
   console.log(chalk.blue('\nCreating scope...'));
-  
+
   // Initialize scope system if needed
   await manager.initialize();
-  
+
   // Check if system is initialized
   const systemInit = await initializer.isSystemInitialized();
   if (!systemInit) {
     console.log(chalk.blue('Initializing scope system...'));
     await initializer.initializeScopeSystem();
   }
-  
+
   // Create scope in configuration
   const scope = await manager.createScope(scopeId, {
     name,
     description,
-    dependencies: options.dependencies ? options.dependencies.split(',').map(d => d.trim()) : []
+    dependencies: options.dependencies ? options.dependencies.split(',').map((d) => d.trim()) : [],
   });
-  
+
   // Create scope directory structure
   const paths = await initializer.initializeScope(scopeId, {
     name,
     description,
-    createContext: options.context
+    createContext: options.context,
   });
-  
+
   console.log(chalk.green(`\n✓ Scope '${scopeId}' created successfully!\n`));
   console.log(chalk.dim('  Directories created:'));
   console.log(`    ${paths.planning}`);
@@ -235,20 +235,20 @@ async function handleInfo(projectRoot, scopeId) {
     console.error(chalk.red('Error: Scope ID is required. Usage: bmad scope info <scope-id>'));
     process.exit(1);
   }
-  
+
   const manager = new ScopeManager({ projectRoot });
-  
+
   await manager.initialize();
   const scope = await manager.getScope(scopeId);
-  
+
   if (!scope) {
     console.error(chalk.red(`Error: Scope '${scopeId}' not found.`));
     process.exit(1);
   }
-  
+
   const paths = await manager.getScopePaths(scopeId);
   const tree = await manager.getDependencyTree(scopeId);
-  
+
   displayScopeInfo(scope, paths, tree);
 }
 
@@ -260,39 +260,39 @@ async function handleRemove(projectRoot, scopeId, options) {
     console.error(chalk.red('Error: Scope ID is required. Usage: bmad scope remove <scope-id>'));
     process.exit(1);
   }
-  
+
   const manager = new ScopeManager({ projectRoot });
   const initializer = new ScopeInitializer({ projectRoot });
-  
+
   await manager.initialize();
-  
+
   const scope = await manager.getScope(scopeId);
   if (!scope) {
     console.error(chalk.red(`Error: Scope '${scopeId}' not found.`));
     process.exit(1);
   }
-  
+
   // Confirm removal unless --force
   if (!options.force) {
     const confirmed = await confirm({
       message: `Are you sure you want to remove scope '${scopeId}'? This will delete all scope artifacts!`,
-      initialValue: false
+      initialValue: false,
     });
-    
+
     if (isCancel(confirmed) || !confirmed) {
       console.log(chalk.yellow('Cancelled.'));
       return;
     }
   }
-  
+
   console.log(chalk.blue('\nRemoving scope...'));
-  
+
   // Remove scope directory (with backup)
   await initializer.removeScope(scopeId, { backup: !options.noBackup });
-  
+
   // Remove from configuration
   await manager.removeScope(scopeId, { force: true });
-  
+
   console.log(chalk.green(`\n✓ Scope '${scopeId}' removed successfully!`));
   if (!options.noBackup) {
     console.log(chalk.dim('  A backup was created in _bmad-output/'));
@@ -306,12 +306,12 @@ async function handleRemove(projectRoot, scopeId, options) {
 async function handleInit(projectRoot) {
   const manager = new ScopeManager({ projectRoot });
   const initializer = new ScopeInitializer({ projectRoot });
-  
+
   console.log(chalk.blue('\nInitializing scope system...'));
-  
+
   await manager.initialize();
   await initializer.initializeScopeSystem();
-  
+
   console.log(chalk.green('\n✓ Scope system initialized successfully!\n'));
   console.log(chalk.dim('  Created:'));
   console.log(`    ${chalk.cyan('_bmad/_config/scopes.yaml')} - Scope configuration`);
@@ -330,12 +330,12 @@ async function handleArchive(projectRoot, scopeId) {
     console.error(chalk.red('Error: Scope ID is required. Usage: bmad scope archive <scope-id>'));
     process.exit(1);
   }
-  
+
   const manager = new ScopeManager({ projectRoot });
-  
+
   await manager.initialize();
   await manager.archiveScope(scopeId);
-  
+
   console.log(chalk.green(`\n✓ Scope '${scopeId}' archived.\n`));
 }
 
@@ -347,12 +347,12 @@ async function handleActivate(projectRoot, scopeId) {
     console.error(chalk.red('Error: Scope ID is required. Usage: bmad scope activate <scope-id>'));
     process.exit(1);
   }
-  
+
   const manager = new ScopeManager({ projectRoot });
-  
+
   await manager.initialize();
   await manager.activateScope(scopeId);
-  
+
   console.log(chalk.green(`\n✓ Scope '${scopeId}' activated.\n`));
 }
 
@@ -397,61 +397,61 @@ module.exports = {
     ['-f, --force', 'Force operation without confirmation'],
     ['--no-backup', 'Skip backup on remove'],
     ['--context', 'Create scope-specific project-context.md'],
-    ['-s, --status <status>', 'Filter by status (active/archived)']
+    ['-s, --status <status>', 'Filter by status (active/archived)'],
   ],
   action: async (subcommand, id, options) => {
     try {
       // Determine project root
       const projectRoot = process.cwd();
-      
+
       // Handle subcommands
       switch (subcommand) {
         case 'init': {
           await handleInit(projectRoot);
           break;
         }
-          
+
         case 'list':
         case 'ls': {
           await handleList(projectRoot, options);
           break;
         }
-          
+
         case 'create':
         case 'new': {
           await handleCreate(projectRoot, id, options);
           break;
         }
-          
+
         case 'info':
         case 'show': {
           await handleInfo(projectRoot, id);
           break;
         }
-          
+
         case 'remove':
         case 'rm':
         case 'delete': {
           await handleRemove(projectRoot, id, options);
           break;
         }
-          
+
         case 'archive': {
           await handleArchive(projectRoot, id);
           break;
         }
-          
+
         case 'activate': {
           await handleActivate(projectRoot, id);
           break;
         }
-          
+
         case 'help':
         case undefined: {
           showHelp();
           break;
         }
-          
+
         default: {
           // If subcommand looks like an ID, show info for it
           if (subcommand && !subcommand.startsWith('-')) {
@@ -461,7 +461,7 @@ module.exports = {
           }
         }
       }
-      
+
       process.exit(0);
     } catch (error) {
       console.error(chalk.red(`\nError: ${error.message}`));
@@ -470,5 +470,5 @@ module.exports = {
       }
       process.exit(1);
     }
-  }
+  },
 };

package/tools/cli/scripts/migrate-workflows.js

@@ -1,13 +1,12 @@
-
 /**
  * Workflow Migration Script
- * 
+ *
  * Updates workflow.yaml files to support the multi-scope system.
  * Primarily updates test_dir and other path variables to use scope-aware paths.
- * 
+ *
  * Usage:
  *   node migrate-workflows.js [--dry-run] [--verbose]
- * 
+ *
  * Options:
  *   --dry-run   Show what would be changed without making changes
  *   --verbose   Show detailed output
@@ -28,48 +27,42 @@ const PATH_MIGRATIONS = [
   {
     pattern: /\{output_folder\}\/tests/g,
     replacement: '{scope_tests}',
-    description: 'test directory to scope_tests'
+    description: 'test directory to scope_tests',
   },
   {
     pattern: /\{config_source:implementation_artifacts\}\/tests/g,
     replacement: '{config_source:scope_tests}',
-    description: 'implementation_artifacts tests to scope_tests'
+    description: 'implementation_artifacts tests to scope_tests',
   },
   // Planning artifacts
   {
     pattern: /\{output_folder\}\/planning-artifacts/g,
     replacement: '{config_source:planning_artifacts}',
-    description: 'output_folder planning to config_source'
+    description: 'output_folder planning to config_source',
   },
-  // Implementation artifacts  
+  // Implementation artifacts
   {
     pattern: /\{output_folder\}\/implementation-artifacts/g,
     replacement: '{config_source:implementation_artifacts}',
-    description: 'output_folder implementation to config_source'
-  }
+    description: 'output_folder implementation to config_source',
+  },
 ];
 
 // Variables that indicate scope requirement
-const SCOPE_INDICATORS = [
-  '{scope}',
-  '{scope_path}',
-  '{scope_tests}',
-  '{scope_planning}',
-  '{scope_implementation}'
-];
+const SCOPE_INDICATORS = ['{scope}', '{scope_path}', '{scope_tests}', '{scope_planning}', '{scope_implementation}'];
 
 /**
  * Find all workflow.yaml files
  */
 async function findWorkflowFiles(basePath) {
   const files = [];
-  
+
   async function walk(dir) {
     const entries = await fs.readdir(dir, { withFileTypes: true });
-    
+
     for (const entry of entries) {
       const fullPath = path.join(dir, entry.name);
-      
+
       if (entry.isDirectory()) {
         // Skip node_modules and hidden directories
         if (!entry.name.startsWith('.') && entry.name !== 'node_modules') {
@@ -80,7 +73,7 @@ async function findWorkflowFiles(basePath) {
       }
     }
   }
-  
+
   await walk(basePath);
   return files;
 }
@@ -89,7 +82,7 @@ async function findWorkflowFiles(basePath) {
  * Check if a workflow already uses scope variables
  */
 function usesScope(content) {
-  return SCOPE_INDICATORS.some(indicator => content.includes(indicator));
+  return SCOPE_INDICATORS.some((indicator) => content.includes(indicator));
 }
 
 /**
@@ -101,20 +94,20 @@ function analyzeWorkflow(content, filePath) {
     needsMigration: false,
     alreadyScoped: false,
     suggestions: [],
-    currentVariables: []
+    currentVariables: [],
   };
-  
+
   // Check if already uses scope
   if (usesScope(content)) {
     analysis.alreadyScoped = true;
     return analysis;
   }
-  
+
   // Find variables that might need migration
   const variablePattern = /\{[^}]+\}/g;
   const matches = content.match(variablePattern) || [];
   analysis.currentVariables = [...new Set(matches)];
-  
+
   // Check each migration pattern
   for (const migration of PATH_MIGRATIONS) {
     if (migration.pattern.test(content)) {
@@ -122,21 +115,21 @@ function analyzeWorkflow(content, filePath) {
       analysis.suggestions.push({
         description: migration.description,
         pattern: migration.pattern.toString(),
-        replacement: migration.replacement
+        replacement: migration.replacement,
       });
     }
   }
-  
+
   // Check for test_dir variable
   if (content.includes('test_dir:') || content.includes('test_dir:')) {
     analysis.needsMigration = true;
     analysis.suggestions.push({
       description: 'Has test_dir variable - may need scope_tests',
       pattern: 'test_dir',
-      replacement: 'scope_tests via config_source'
+      replacement: 'scope_tests via config_source',
     });
   }
-  
+
   return analysis;
 }
 
@@ -146,14 +139,14 @@ function analyzeWorkflow(content, filePath) {
 function migrateWorkflow(content) {
   let migrated = content;
   let changes = [];
-  
+
   for (const migration of PATH_MIGRATIONS) {
     if (migration.pattern.test(migrated)) {
       migrated = migrated.replace(migration.pattern, migration.replacement);
       changes.push(migration.description);
     }
   }
-  
+
   return { content: migrated, changes };
 }
 
@@ -163,12 +156,12 @@ function migrateWorkflow(content) {
 function addScopeMarker(content) {
   try {
     const parsed = yaml.parse(content);
-    
+
     // Add scope_required if not present
     if (!parsed.scope_required) {
       parsed.scope_required = false; // Default to false for backward compatibility
     }
-    
+
     return yaml.stringify(parsed, { lineWidth: 120 });
   } catch {
     // If YAML parsing fails, return original
@@ -183,37 +176,37 @@ async function main() {
   const args = new Set(process.argv.slice(2));
   const dryRun = args.has('--dry-run');
   const verbose = args.has('--verbose');
-  
+
   console.log(chalk.bold('\nWorkflow Migration Script'));
   console.log(chalk.dim('Updating workflow.yaml files for multi-scope support\n'));
-  
+
   if (dryRun) {
     console.log(chalk.yellow('DRY RUN MODE - No changes will be made\n'));
   }
-  
+
   // Find all workflow files
   console.log(chalk.blue('Scanning for workflow.yaml files...'));
   const files = await findWorkflowFiles(SRC_PATH);
   console.log(chalk.green(`Found ${files.length} workflow.yaml files\n`));
-  
+
   // Analysis results
   const results = {
     analyzed: 0,
     alreadyScoped: 0,
     migrated: 0,
     noChanges: 0,
-    errors: []
+    errors: [],
   };
-  
+
   // Process each file
   for (const filePath of files) {
     const relativePath = path.relative(SRC_PATH, filePath);
     results.analyzed++;
-    
+
     try {
       const content = await fs.readFile(filePath, 'utf8');
       const analysis = analyzeWorkflow(content, filePath);
-      
+
       if (analysis.alreadyScoped) {
         results.alreadyScoped++;
         if (verbose) {
@@ -221,7 +214,7 @@ async function main() {
         }
         continue;
       }
-      
+
       if (!analysis.needsMigration) {
         results.noChanges++;
         if (verbose) {
@@ -229,16 +222,16 @@ async function main() {
         }
         continue;
       }
-      
+
       // Apply migration
       const { content: migrated, changes } = migrateWorkflow(content);
-      
+
       if (changes.length > 0) {
         console.log(chalk.cyan(`  ● ${relativePath}`));
         for (const change of changes) {
           console.log(chalk.dim(`      → ${change}`));
         }
-        
+
         if (!dryRun) {
           await fs.writeFile(filePath, migrated, 'utf8');
         }
@@ -246,13 +239,12 @@ async function main() {
       } else {
         results.noChanges++;
       }
-      
     } catch (error) {
       results.errors.push({ file: relativePath, error: error.message });
       console.log(chalk.red(`  ✗ ${relativePath} - Error: ${error.message}`));
     }
   }
-  
+
   // Print summary
   console.log(chalk.bold('\n─────────────────────────────────────'));
   console.log(chalk.bold('Summary'));
@@ -265,17 +257,17 @@ async function main() {
     console.log(chalk.red(`  Errors:             ${results.errors.length}`));
   }
   console.log();
-  
+
   if (dryRun && results.migrated > 0) {
     console.log(chalk.yellow('Run without --dry-run to apply changes\n'));
   }
-  
+
   // Exit with error code if there were errors
   process.exit(results.errors.length > 0 ? 1 : 0);
 }
 
 // Run
-main().catch(error => {
+main().catch((error) => {
   console.error(chalk.red('Fatal error:'), error.message);
   process.exit(1);
 });