bmad-method 4.30.2 → 4.30.3

package/expansion-packs/bmad-2d-unity-game-dev/workflows/game-prototype.yaml

@@ -0,0 +1,175 @@
+workflow:
+  id: unity-game-prototype
+  name: Game Prototype Development (Unity)
+  description: Fast-track workflow for rapid game prototyping and concept validation. Optimized for game jams, proof-of-concept development, and quick iteration on game mechanics using Unity and C#.
+  type: prototype
+  project_types:
+    - game-jam
+    - proof-of-concept
+    - mechanic-test
+    - technical-demo
+    - learning-project
+    - rapid-iteration
+  prototype_sequence:
+    - step: concept_definition
+      agent: game-designer
+      duration: 15-30 minutes
+      creates: concept-summary.md
+      notes: Quickly define core game concept, primary mechanic, and target experience. Focus on what makes this game unique and fun.
+    - step: rapid_design
+      agent: game-designer
+      duration: 30-60 minutes
+      creates: prototype-spec.md
+      requires: concept-summary.md
+      optional_steps:
+        - quick_brainstorming
+        - reference_research
+      notes: Create minimal but complete design specification. Focus on core mechanics, basic controls, and success/failure conditions.
+    - step: technical_planning
+      agent: game-developer
+      duration: 15-30 minutes
+      creates: prototype-architecture.md
+      requires: prototype-spec.md
+      notes: Define minimal technical implementation plan. Identify core Unity systems needed and performance constraints.
+    - step: implementation_stories
+      agent: game-sm
+      duration: 30-45 minutes
+      creates: prototype-stories/
+      requires: prototype-spec.md, prototype-architecture.md
+      notes: Create 3-5 focused implementation stories for core prototype features. Each story should be completable in 2-4 hours.
+    - step: iterative_development
+      agent: game-developer
+      duration: varies
+      implements: prototype-stories/
+      notes: Implement stories in priority order. Test frequently in the Unity Editor and adjust design based on what feels fun. Document discoveries.
+  workflow_end:
+    action: prototype_evaluation
+    notes: 'Prototype complete. Evaluate core mechanics, gather feedback, and decide next steps: iterate, expand, or archive.'
+  game_jam_sequence:
+    - step: jam_concept
+      agent: game-designer
+      duration: 10-15 minutes
+      creates: jam-concept.md
+      notes: Define game concept based on jam theme. One sentence core mechanic, basic controls, win condition.
+    - step: jam_implementation
+      agent: game-developer
+      duration: varies (jam timeline)
+      creates: working-prototype
+      requires: jam-concept.md
+      notes: Directly implement core mechanic in Unity. No formal stories - iterate rapidly on what's fun. Document major decisions.
+  jam_workflow_end:
+    action: jam_submission
+    notes: Submit to game jam. Capture lessons learned and consider post-jam development if concept shows promise.
+  flow_diagram: |
+    ```mermaid
+    graph TD
+        A[Start: Prototype Project] --> B{Development Context?}
+        B -->|Standard Prototype| C[game-designer: concept-summary.md]
+        B -->|Game Jam| D[game-designer: jam-concept.md]
+
+        C --> E[game-designer: prototype-spec.md]
+        E --> F[game-developer: prototype-architecture.md]
+        F --> G[game-sm: create prototype stories]
+        G --> H[game-developer: iterative implementation]
+        H --> I[Prototype Evaluation]
+
+        D --> J[game-developer: direct implementation]
+        J --> K[Game Jam Submission]
+
+        E -.-> E1[Optional: quick brainstorming]
+        E -.-> E2[Optional: reference research]
+
+        style I fill:#90EE90
+        style K fill:#90EE90
+        style C fill:#FFE4B5
+        style E fill:#FFE4B5
+        style F fill:#FFE4B5
+        style G fill:#FFE4B5
+        style H fill:#FFE4B5
+        style D fill:#FFB6C1
+        style J fill:#FFB6C1
+    ```
+  decision_guidance:
+    use_prototype_sequence_when:
+      - Learning new game development concepts
+      - Testing specific game mechanics
+      - Building portfolio pieces
+      - Have 1-7 days for development
+      - Need structured but fast development
+      - Want to validate game concepts before full development
+    use_game_jam_sequence_when:
+      - Participating in time-constrained game jams
+      - Have 24-72 hours total development time
+      - Want to experiment with wild or unusual concepts
+      - Learning through rapid iteration
+      - Building networking/portfolio presence
+  prototype_best_practices:
+    scope_management:
+      - Start with absolute minimum viable gameplay
+      - One core mechanic implemented well beats many mechanics poorly
+      - Focus on "game feel" over features
+      - Cut features ruthlessly to meet timeline
+    rapid_iteration:
+      - Test the game every 1-2 hours of development in the Unity Editor
+      - Ask "Is this fun?" frequently during development
+      - Be willing to pivot mechanics if they don't feel good
+      - Document what works and what doesn't
+    technical_efficiency:
+      - Use simple graphics (geometric shapes, basic sprites)
+      - Leverage Unity's built-in components heavily
+      - Avoid complex custom systems in prototypes
+      - Prioritize functional over polished
+  prototype_evaluation_criteria:
+    core_mechanic_validation:
+      - Is the primary mechanic engaging for 30+ seconds?
+      - Do players understand the mechanic without explanation?
+      - Does the mechanic have depth for extended play?
+      - Are there natural difficulty progression opportunities?
+    technical_feasibility:
+      - Does the prototype run at acceptable frame rates?
+      - Are there obvious technical blockers for expansion?
+      - Is the codebase clean enough for further development?
+      - Are performance targets realistic for full game?
+    player_experience:
+      - Do testers engage with the game voluntarily?
+      - What emotions does the game create in players?
+      - Are players asking for "just one more try"?
+      - What do players want to see added or changed?
+  post_prototype_options:
+    iterate_and_improve:
+      action: continue_prototyping
+      when: Core mechanic shows promise but needs refinement
+      next_steps: Create new prototype iteration focusing on identified improvements
+    expand_to_full_game:
+      action: transition_to_full_development
+      when: Prototype validates strong game concept
+      next_steps: Use game-dev-greenfield workflow to create full game design and architecture
+    pivot_concept:
+      action: new_prototype_direction
+      when: Current mechanic doesn't work but insights suggest new direction
+      next_steps: Apply learnings to new prototype concept
+    archive_and_learn:
+      action: document_learnings
+      when: Prototype doesn't work but provides valuable insights
+      next_steps: Document lessons learned and move to next prototype concept
+  time_boxing_guidance:
+    concept_phase: Maximum 30 minutes - if you can't explain the game simply, simplify it
+    design_phase: Maximum 1 hour - focus on core mechanics only
+    planning_phase: Maximum 30 minutes - identify critical path to playable prototype
+    implementation_phase: Time-boxed iterations - test every 2-4 hours of work
+  success_metrics:
+    development_velocity:
+      - Playable prototype in first day of development
+      - Core mechanic demonstrable within 4-6 hours of coding
+      - Major iteration cycles completed in 2-4 hour blocks
+    learning_objectives:
+      - Clear understanding of what makes the mechanic fun (or not)
+      - Technical feasibility assessment for full development
+      - Player reaction and engagement validation
+      - Design insights for future development
+  handoff_prompts:
+    concept_to_design: Game concept defined. Create minimal design specification focusing on core mechanics and player experience.
+    design_to_technical: Design specification ready. Create technical implementation plan for rapid prototyping.
+    technical_to_stories: Technical plan complete. Create focused implementation stories for prototype development.
+    stories_to_implementation: Stories ready. Begin iterative implementation with frequent playtesting and design validation.
+    prototype_to_evaluation: Prototype playable. Evaluate core mechanics, gather feedback, and determine next development steps.

package/expansion-packs/bmad-infrastructure-devops/config.yaml

@@ -1,6 +1,6 @@
 name: bmad-infrastructure-devops
-version: 1.9.0
-short-title: Infrastructure and DevOps capabilities
+version: 1.10.0
+short-title: Infrastructure DevOps Pack
 description: >-
   This expansion pack extends BMad Method with comprehensive infrastructure and
   DevOps capabilities. It's designed for teams that need to define, implement,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "bmad-method",
-  "version": "4.30.2",
+  "version": "4.30.3",
   "description": "Breakthrough Method of Agile AI-driven Development",
   "main": "tools/cli.js",
   "bin": {
@@ -18,10 +18,6 @@
     "version:patch": "node tools/version-bump.js patch",
     "version:minor": "node tools/version-bump.js minor",
     "version:major": "node tools/version-bump.js major",
-    "version:core": "node tools/bump-core-version.js",
-    "version:core:major": "node tools/bump-core-version.js major",
-    "version:core:minor": "node tools/bump-core-version.js minor",
-    "version:core:patch": "node tools/bump-core-version.js patch",
     "version:expansion": "node tools/bump-expansion-version.js",
     "version:expansion:set": "node tools/update-expansion-version.js",
     "version:all": "node tools/bump-all-versions.js",
@@ -38,13 +34,13 @@
   },
   "dependencies": {
     "@kayvan/markdown-tree-parser": "^1.5.0",
-    "chalk": "^5.4.1",
+    "chalk": "^4.1.2",
     "commander": "^14.0.0",
     "fs-extra": "^11.3.0",
     "glob": "^11.0.3",
-    "inquirer": "^12.6.3",
+    "inquirer": "^8.2.6",
     "js-yaml": "^4.1.0",
-    "ora": "^8.2.0"
+    "ora": "^5.4.1"
   },
   "keywords": [
     "agile",

package/tools/bump-all-versions.js

@@ -31,21 +31,20 @@ function bumpVersion(currentVersion, type) {
 async function bumpAllVersions() {
   const updatedItems = [];
   
-  // First, bump the core version
-  const coreConfigPath = path.join(__dirname, '..', 'bmad-core', 'core-config.yaml');
+  // First, bump the core version (package.json)
+  const packagePath = path.join(__dirname, '..', 'package.json');
   try {
-    const coreConfigContent = fs.readFileSync(coreConfigPath, 'utf8');
-    const coreConfig = yaml.load(coreConfigContent);
-    const oldCoreVersion = coreConfig.version || '1.0.0';
+    const packageContent = fs.readFileSync(packagePath, 'utf8');
+    const packageJson = JSON.parse(packageContent);
+    const oldCoreVersion = packageJson.version || '1.0.0';
     const newCoreVersion = bumpVersion(oldCoreVersion, bumpType);
     
-    coreConfig.version = newCoreVersion;
+    packageJson.version = newCoreVersion;
     
-    const updatedCoreYaml = yaml.dump(coreConfig, { indent: 2 });
-    fs.writeFileSync(coreConfigPath, updatedCoreYaml);
+    fs.writeFileSync(packagePath, JSON.stringify(packageJson, null, 2) + '\n');
     
     updatedItems.push({ type: 'core', name: 'BMad Core', oldVersion: oldCoreVersion, newVersion: newCoreVersion });
-    console.log(`✓ BMad Core: ${oldCoreVersion} → ${newCoreVersion}`);
+    console.log(`✓ BMad Core (package.json): ${oldCoreVersion} → ${newCoreVersion}`);
   } catch (error) {
     console.error(`✗ Failed to update BMad Core: ${error.message}`);
   }

package/tools/bump-expansion-version.js

@@ -1,78 +1,83 @@
 #!/usr/bin/env node
 
+// Load required modules
 const fs = require('fs');
 const path = require('path');
 const yaml = require('js-yaml');
 
+// Parse CLI arguments
 const args = process.argv.slice(2);
+const packId = args[0];
+const bumpType = args[1] || 'minor';
 
-if (args.length < 1 || args.length > 2) {
+// Validate arguments
+if (!packId || args.length > 2) {
   console.log('Usage: node bump-expansion-version.js <expansion-pack-id> [major|minor|patch]');
   console.log('Default: minor');
   console.log('Example: node bump-expansion-version.js bmad-creator-tools patch');
   process.exit(1);
 }
 
-const packId = args[0];
-const bumpType = args[1] || 'minor'; // default to minor
-
 if (!['major', 'minor', 'patch'].includes(bumpType)) {
   console.error('Error: Bump type must be major, minor, or patch');
   process.exit(1);
 }
 
+// Version bump logic
 function bumpVersion(currentVersion, type) {
   const [major, minor, patch] = currentVersion.split('.').map(Number);
-  
+
   switch (type) {
-    case 'major':
-      return `${major + 1}.0.0`;
-    case 'minor':
-      return `${major}.${minor + 1}.0`;
-    case 'patch':
-      return `${major}.${minor}.${patch + 1}`;
-    default:
-      return currentVersion;
+    case 'major': return `${major + 1}.0.0`;
+    case 'minor': return `${major}.${minor + 1}.0`;
+    case 'patch': return `${major}.${minor}.${patch + 1}`;
+    default: return currentVersion;
   }
 }
 
+// Main function to bump version
 async function updateVersion() {
+  const configPath = path.join(__dirname, '..', 'expansion-packs', packId, 'config.yaml');
+
+  // Check if config exists
+  if (!fs.existsSync(configPath)) {
+    console.error(`Error: Expansion pack '${packId}' not found`);
+    console.log('\nAvailable expansion packs:');
+
+    const packsDir = path.join(__dirname, '..', 'expansion-packs');
+    const entries = fs.readdirSync(packsDir, { withFileTypes: true });
+
+    entries.forEach(entry => {
+      if (entry.isDirectory() && !entry.name.startsWith('.')) {
+        console.log(`  - ${entry.name}`);
+      }
+    });
+
+    process.exit(1);
+  }
+
   try {
-    const configPath = path.join(__dirname, '..', 'expansion-packs', packId, 'config.yaml');
-    
-    if (!fs.existsSync(configPath)) {
-      console.error(`Error: Expansion pack '${packId}' not found`);
-      console.log('\nAvailable expansion packs:');
-      const expansionPacksDir = path.join(__dirname, '..', 'expansion-packs');
-      const entries = fs.readdirSync(expansionPacksDir, { withFileTypes: true });
-      entries.forEach(entry => {
-        if (entry.isDirectory() && !entry.name.startsWith('.')) {
-          console.log(`  - ${entry.name}`);
-        }
-      });
-      process.exit(1);
-    }
-    
     const configContent = fs.readFileSync(configPath, 'utf8');
     const config = yaml.load(configContent);
+
     const oldVersion = config.version || '1.0.0';
     const newVersion = bumpVersion(oldVersion, bumpType);
-    
+
     config.version = newVersion;
-    
+
     const updatedYaml = yaml.dump(config, { indent: 2 });
     fs.writeFileSync(configPath, updatedYaml);
-    
+
     console.log(`✓ ${packId}: ${oldVersion} → ${newVersion}`);
     console.log(`\n✓ Successfully bumped ${packId} with ${bumpType} version bump`);
     console.log('\nNext steps:');
-    console.log('1. Test the changes');
-    console.log('2. Commit: git add -A && git commit -m "chore: bump ' + packId + ' version (' + bumpType + ')"');
-    
+    console.log(`1. Test the changes`);
+    console.log(`2. Commit: git add -A && git commit -m "chore: bump ${packId} version (${bumpType})"`);
+
   } catch (error) {
     console.error('Error updating version:', error.message);
     process.exit(1);
   }
 }
 
-updateVersion();
+updateVersion();

package/tools/installer/bin/bmad.js

@@ -4,17 +4,8 @@ const { program } = require('commander');
 const path = require('path');
 const fs = require('fs').promises;
 const yaml = require('js-yaml');
-
-// Dynamic imports for ES modules
-let chalk, inquirer;
-
-// Initialize ES modules
-async function initializeModules() {
-  if (!chalk) {
-    chalk = (await import('chalk')).default;
-    inquirer = (await import('inquirer')).default;
-  }
-}
+const chalk = require('chalk');
+const inquirer = require('inquirer');
 
 // Handle both execution contexts (from root via npx or from installer directory)
 let version;
@@ -54,12 +45,12 @@ program
   .option('-e, --expansion-packs <packs...>', 'Install specific expansion packs (can specify multiple)')
   .action(async (options) => {
     try {
-      await initializeModules();
       if (!options.full && !options.expansionOnly) {
         // Interactive mode
         const answers = await promptInstallation();
         if (!answers._alreadyInstalled) {
           await installer.install(answers);
+          process.exit(0);
         }
       } else {
         // Direct mode
@@ -73,9 +64,9 @@ program
           expansionPacks: options.expansionPacks || []
         };
         await installer.install(config);
+        process.exit(0);
       }
     } catch (error) {
-      if (!chalk) await initializeModules();
       console.error(chalk.red('Installation failed:'), error.message);
       process.exit(1);
     }
@@ -90,7 +81,6 @@ program
     try {
       await installer.update();
     } catch (error) {
-      if (!chalk) await initializeModules();
       console.error(chalk.red('Update failed:'), error.message);
       process.exit(1);
     }
@@ -103,7 +93,6 @@ program
     try {
       await installer.listExpansionPacks();
     } catch (error) {
-      if (!chalk) await initializeModules();
       console.error(chalk.red('Error:'), error.message);
       process.exit(1);
     }
@@ -116,14 +105,12 @@ program
     try {
       await installer.showStatus();
     } catch (error) {
-      if (!chalk) await initializeModules();
       console.error(chalk.red('Error:'), error.message);
       process.exit(1);
     }
   });
 
 async function promptInstallation() {
-  await initializeModules();
   
   // Display ASCII logo
   console.log(chalk.bold.cyan(`
@@ -178,13 +165,13 @@ async function promptInstallation() {
   let bmadOptionText;
   if (state.type === 'v4_existing') {
     const currentVersion = state.manifest?.version || 'unknown';
-    const newVersion = coreConfig.version || 'unknown'; // Use version from core-config.yaml
+    const newVersion = version; // Always use package.json version
     const versionInfo = currentVersion === newVersion 
       ? `(v${currentVersion} - reinstall)`
       : `(v${currentVersion} → v${newVersion})`;
     bmadOptionText = `Update ${coreShortTitle} ${versionInfo} .bmad-core`;
   } else {
-    bmadOptionText = `Install ${coreShortTitle} (v${coreConfig.version || version}) .bmad-core`;
+    bmadOptionText = `${coreShortTitle} (v${version}) .bmad-core`;
   }
   
   choices.push({
@@ -204,9 +191,9 @@ async function promptInstallation() {
       const versionInfo = currentVersion === newVersion 
         ? `(v${currentVersion} - reinstall)`
         : `(v${currentVersion} → v${newVersion})`;
-      packOptionText = `Update ${pack.description} ${versionInfo} .${pack.id}`;
+      packOptionText = `Update ${pack.shortTitle} ${versionInfo} .${pack.id}`;
     } else {
-      packOptionText = `Install ${pack.description} (v${pack.version}) .${pack.id}`;
+      packOptionText = `${pack.shortTitle} (v${pack.version}) .${pack.id}`;
     }
     
     choices.push({

package/tools/installer/lib/file-manager.js

@@ -1,18 +1,11 @@
 const fs = require("fs-extra");
 const path = require("path");
 const crypto = require("crypto");
-const glob = require("glob");
 const yaml = require("js-yaml");
-
-// Dynamic import for ES module
-let chalk;
-
-// Initialize ES modules
-async function initializeModules() {
-  if (!chalk) {
-    chalk = (await import("chalk")).default;
-  }
-}
+const chalk = require("chalk");
+const { createReadStream, createWriteStream, promises: fsPromises } = require('fs');
+const { pipeline } = require('stream/promises');
+const resourceLocator = require('./resource-locator');
 
 class FileManager {
   constructor() {
@@ -23,10 +16,19 @@ class FileManager {
   async copyFile(source, destination) {
     try {
       await fs.ensureDir(path.dirname(destination));
-      await fs.copy(source, destination);
+      
+      // Use streaming for large files (> 10MB)
+      const stats = await fs.stat(source);
+      if (stats.size > 10 * 1024 * 1024) {
+        await pipeline(
+          createReadStream(source),
+          createWriteStream(destination)
+        );
+      } else {
+        await fs.copy(source, destination);
+      }
       return true;
     } catch (error) {
-      await initializeModules();
       console.error(chalk.red(`Failed to copy ${source}:`), error.message);
       return false;
     }
@@ -35,10 +37,28 @@ class FileManager {
   async copyDirectory(source, destination) {
     try {
       await fs.ensureDir(destination);
-      await fs.copy(source, destination);
+      
+      // Use streaming copy for large directories
+      const files = await resourceLocator.findFiles('**/*', {
+        cwd: source,
+        nodir: true
+      });
+      
+      // Process files in batches to avoid memory issues
+      const batchSize = 50;
+      for (let i = 0; i < files.length; i += batchSize) {
+        const batch = files.slice(i, i + batchSize);
+        await Promise.all(
+          batch.map(file => 
+            this.copyFile(
+              path.join(source, file),
+              path.join(destination, file)
+            )
+          )
+        );
+      }
       return true;
     } catch (error) {
-      await initializeModules();
       console.error(
         chalk.red(`Failed to copy directory ${source}:`),
         error.message
@@ -48,7 +68,7 @@ class FileManager {
   }
 
   async copyGlobPattern(pattern, sourceDir, destDir, rootValue = null) {
-    const files = glob.sync(pattern, { cwd: sourceDir });
+    const files = await resourceLocator.findFiles(pattern, { cwd: sourceDir });
     const copied = [];
 
     for (const file of files) {
@@ -75,12 +95,15 @@ class FileManager {
 
   async calculateFileHash(filePath) {
     try {
-      const content = await fs.readFile(filePath);
-      return crypto
-        .createHash("sha256")
-        .update(content)
-        .digest("hex")
-        .slice(0, 16);
+      // Use streaming for hash calculation to reduce memory usage
+      const stream = createReadStream(filePath);
+      const hash = crypto.createHash("sha256");
+      
+      for await (const chunk of stream) {
+        hash.update(chunk);
+      }
+      
+      return hash.digest("hex").slice(0, 16);
     } catch (error) {
       return null;
     }
@@ -93,15 +116,14 @@ class FileManager {
       this.manifestFile
     );
 
-    // Read version from core-config.yaml
-    const coreConfigPath = path.join(__dirname, "../../../bmad-core/core-config.yaml");
+    // Read version from package.json
     let coreVersion = "unknown";
     try {
-      const coreConfigContent = await fs.readFile(coreConfigPath, "utf8");
-      const coreConfig = yaml.load(coreConfigContent);
-      coreVersion = coreConfig.version || "unknown";
+      const packagePath = path.join(__dirname, '..', '..', '..', 'package.json');
+      const packageJson = require(packagePath);
+      coreVersion = packageJson.version;
     } catch (error) {
-      console.warn("Could not read version from core-config.yaml, using 'unknown'");
+      console.warn("Could not read version from package.json, using 'unknown'");
     }
 
     const manifest = {
@@ -304,7 +326,6 @@ class FileManager {
       
       return true;
     } catch (error) {
-      await initializeModules();
       console.error(chalk.red(`Failed to modify core-config.yaml:`), error.message);
       return false;
     }
@@ -312,22 +333,35 @@ class FileManager {
 
   async copyFileWithRootReplacement(source, destination, rootValue) {
     try {
-      // Read the source file content
-      const fs = require('fs').promises;
-      const content = await fs.readFile(source, 'utf8');
-      
-      // Replace {root} with the specified root value
-      const updatedContent = content.replace(/\{root\}/g, rootValue);
+      // Check file size to determine if we should stream
+      const stats = await fs.stat(source);
       
-      // Ensure directory exists
-      await this.ensureDirectory(path.dirname(destination));
-      
-      // Write the updated content
-      await fs.writeFile(destination, updatedContent, 'utf8');
+      if (stats.size > 5 * 1024 * 1024) { // 5MB threshold
+        // Use streaming for large files
+        const { Transform } = require('stream');
+        const replaceStream = new Transform({
+          transform(chunk, encoding, callback) {
+            const modified = chunk.toString().replace(/\{root\}/g, rootValue);
+            callback(null, modified);
+          }
+        });
+        
+        await this.ensureDirectory(path.dirname(destination));
+        await pipeline(
+          createReadStream(source, { encoding: 'utf8' }),
+          replaceStream,
+          createWriteStream(destination, { encoding: 'utf8' })
+        );
+      } else {
+        // Regular approach for smaller files
+        const content = await fsPromises.readFile(source, 'utf8');
+        const updatedContent = content.replace(/\{root\}/g, rootValue);
+        await this.ensureDirectory(path.dirname(destination));
+        await fsPromises.writeFile(destination, updatedContent, 'utf8');
+      }
       
       return true;
     } catch (error) {
-      await initializeModules();
       console.error(chalk.red(`Failed to copy ${source} with root replacement:`), error.message);
       return false;
     }
@@ -335,11 +369,10 @@ class FileManager {
 
   async copyDirectoryWithRootReplacement(source, destination, rootValue, fileExtensions = ['.md', '.yaml', '.yml']) {
     try {
-      await initializeModules(); // Ensure chalk is initialized
       await this.ensureDirectory(destination);
       
       // Get all files in source directory
-      const files = glob.sync('**/*', { 
+      const files = await resourceLocator.findFiles('**/*', { 
         cwd: source, 
         nodir: true 
       });
@@ -369,7 +402,6 @@ class FileManager {
       
       return true;
     } catch (error) {
-      await initializeModules();
       console.error(chalk.red(`Failed to copy directory ${source} with root replacement:`), error.message);
       return false;
     }