bmad-enhanced 1.3.8 → 1.4.1

package/scripts/update/lib/config-merger.js

@@ -1,7 +1,6 @@
 #!/usr/bin/env node
 
 const fs = require('fs-extra');
-const path = require('path');
 const yaml = require('js-yaml');
 
 /**
@@ -24,7 +23,7 @@ async function mergeConfig(currentConfigPath, newVersion, updates = {}) {
     try {
       const currentContent = fs.readFileSync(currentConfigPath, 'utf8');
       current = yaml.load(currentContent);
-    } catch (error) {
+    } catch (_error) {
       console.warn('Warning: Could not parse current config.yaml, using defaults');
       current = {};
     }
@@ -80,7 +79,7 @@ function extractUserPreferences(config) {
     prefs.output_folder = config.output_folder;
   }
 
-  if (config.hasOwnProperty('party_mode_enabled')) {
+  if (Object.prototype.hasOwnProperty.call(config, 'party_mode_enabled')) {
     prefs.party_mode_enabled = config.party_mode_enabled;
   }
 
@@ -111,7 +110,7 @@ function validateConfig(config) {
   ];
 
   for (const field of requiredFields) {
-    if (!config.hasOwnProperty(field)) {
+    if (!Object.prototype.hasOwnProperty.call(config, field)) {
       errors.push(`Missing required field: ${field}`);
     }
   }
@@ -189,44 +188,10 @@ function addMigrationHistory(config, fromVersion, toVersion, migrationsApplied)
   return config;
 }
 
-/**
- * Get default config template for a version
- * @param {string} version - Version to generate template for
- * @returns {object} Default config template
- */
-function getDefaultConfig(version) {
-  return {
-    submodule_name: '_vortex',
-    description: 'Contextualize and Externalize streams - Strategic framing and validated learning',
-    module: 'bme',
-    version,
-    output_folder: '{project-root}/_bmad-output/vortex-artifacts',
-    user_name: '{user}',
-    communication_language: 'en',
-    agents: [
-      'contextualization-expert',
-      'lean-experiments-specialist'
-    ],
-    workflows: [
-      'lean-persona',
-      'product-vision',
-      'contextualize-scope',
-      'mvp',
-      'lean-experiment',
-      'proof-of-concept',
-      'proof-of-value'
-    ],
-    party_mode_enabled: true,
-    core_module: 'bme',
-    migration_history: []
-  };
-}
-
 module.exports = {
   mergeConfig,
   extractUserPreferences,
   validateConfig,
   writeConfig,
-  addMigrationHistory,
-  getDefaultConfig
+  addMigrationHistory
 };

package/scripts/update/lib/migration-runner.js

@@ -3,26 +3,34 @@
 const fs = require('fs-extra');
 const path = require('path');
 const chalk = require('chalk');
+const yaml = require('js-yaml');
+const { findProjectRoot, getPackageVersion } = require('./utils');
 const backupManager = require('./backup-manager');
-const versionDetector = require('./version-detector');
 const configMerger = require('./config-merger');
 const validator = require('./validator');
+const { refreshInstallation } = require('./refresh-installation');
 const registry = require('../migrations/registry');
 
 /**
  * Migration Runner for BMAD-Enhanced
- * Core orchestration: executes migrations, handles backups, manages rollback
+ * Core orchestration: executes migration deltas, refreshes installation, handles backups and rollback.
  */
 
 /**
- * Run migrations from current version to target version
- * @param {string} fromVersion - Current version
- * @param {string} toVersion - Target version
+ * Run migrations from current version to the current package version.
+ * @param {string} fromVersion - Current installed version
  * @param {object} options - Options { dryRun, verbose }
  * @returns {Promise<object>} Migration result
  */
-async function runMigrations(fromVersion, toVersion, options = {}) {
+async function runMigrations(fromVersion, options = {}) {
   const { dryRun = false, verbose = false } = options;
+  const toVersion = getPackageVersion();
+
+  // Resolve project root
+  const projectRoot = findProjectRoot();
+  if (!projectRoot) {
+    throw new Error('Not in a BMAD project. Could not find _bmad/ directory.');
+  }
 
   console.log('');
   if (dryRun) {
@@ -31,8 +39,8 @@ async function runMigrations(fromVersion, toVersion, options = {}) {
     console.log('');
   }
 
-  // 1. Get applicable migrations
-  const migrations = registry.getMigrationsFor(fromVersion, toVersion);
+  // 1. Get applicable migration deltas
+  const migrations = registry.getMigrationsFor(fromVersion);
 
   if (migrations.length === 0) {
     console.log(chalk.yellow('No migrations needed'));
@@ -52,7 +60,7 @@ async function runMigrations(fromVersion, toVersion, options = {}) {
   }
 
   // 2. Acquire migration lock
-  await acquireMigrationLock();
+  await acquireMigrationLock(projectRoot);
 
   let backupMetadata = null;
   const results = [];
@@ -60,20 +68,18 @@ async function runMigrations(fromVersion, toVersion, options = {}) {
   try {
     // 3. Create backup
     console.log(chalk.cyan('[1/5] Creating backup...'));
-    const userDataCount = await backupManager.countUserDataFiles();
-    backupMetadata = await backupManager.createBackup(fromVersion);
-    backupMetadata.userDataCount = userDataCount;
+    backupMetadata = await backupManager.createBackup(fromVersion, projectRoot);
     console.log(chalk.green(`✓ Backup created: ${path.basename(backupMetadata.backup_dir)}`));
     console.log('');
 
-    // 4. Execute migrations sequentially
-    console.log(chalk.cyan('[2/5] Running migrations...'));
+    // 4. Execute migration deltas sequentially
+    console.log(chalk.cyan('[2/5] Running migration deltas...'));
     for (let i = 0; i < migrations.length; i++) {
       const migration = migrations[i];
       console.log(chalk.cyan(`\nMigration ${i + 1}/${migrations.length}: ${migration.name}`));
 
       try {
-        const changes = await executeMigration(migration, { verbose });
+        const changes = await executeMigration(migration, projectRoot, { verbose });
         results.push({
           name: migration.name,
           success: true,
@@ -87,20 +93,30 @@ async function runMigrations(fromVersion, toVersion, options = {}) {
       }
     }
     console.log('');
-    console.log(chalk.green('✓ All migrations completed'));
+    console.log(chalk.green('✓ All migration deltas completed'));
     console.log('');
 
-    // 5. Update configuration and migration history
-    console.log(chalk.cyan('[3/5] Updating configuration...'));
-    await updateMigrationHistory(fromVersion, toVersion, results);
+    // 5. Refresh installation (copy latest files from package)
+    console.log(chalk.cyan('[3/5] Refreshing installation files...'));
+    const refreshChanges = await refreshInstallation(projectRoot);
+    results.push({
+      name: 'refresh-installation',
+      success: true,
+      changes: refreshChanges
+    });
+    console.log(chalk.green('✓ Installation refreshed'));
+    console.log('');
+
+    // 6. Update migration history in config.yaml
+    console.log(chalk.cyan('[4/5] Updating configuration...'));
+    await updateMigrationHistory(projectRoot, fromVersion, toVersion, results);
     console.log(chalk.green('✓ Migration history updated'));
     console.log('');
 
-    // 6. Validate installation
-    console.log(chalk.cyan('[4/5] Validating installation...'));
-    const validationResult = await validator.validateInstallation(backupMetadata);
+    // 7. Validate installation
+    console.log(chalk.cyan('[5/5] Validating installation...'));
+    const validationResult = await validator.validateInstallation(backupMetadata, projectRoot);
 
-    // Display validation results
     validationResult.checks.forEach(check => {
       if (check.passed) {
         console.log(chalk.green(`  ✓ ${check.name}`));
@@ -123,21 +139,17 @@ async function runMigrations(fromVersion, toVersion, options = {}) {
     console.log(chalk.green('✓ Installation validated'));
     console.log('');
 
-    // 7. Cleanup old backups
-    console.log(chalk.cyan('[5/5] Cleanup...'));
-    const deletedCount = await backupManager.cleanupOldBackups(5);
+    // 8. Cleanup old backups
+    const deletedCount = await backupManager.cleanupOldBackups(5, projectRoot);
     if (deletedCount > 0) {
       console.log(chalk.green(`✓ Cleaned up ${deletedCount} old backup(s)`));
-    } else {
-      console.log(chalk.green('✓ No old backups to clean up'));
     }
-    console.log('');
 
     // Release lock
-    await releaseMigrationLock();
+    await releaseMigrationLock(projectRoot);
 
     // Create migration log
-    await createMigrationLog(fromVersion, toVersion, results, backupMetadata);
+    await createMigrationLog(projectRoot, fromVersion, toVersion, results, backupMetadata);
 
     return {
       success: true,
@@ -158,7 +170,7 @@ async function runMigrations(fromVersion, toVersion, options = {}) {
     if (backupMetadata) {
       console.log(chalk.yellow('Restoring from backup...'));
       try {
-        await backupManager.restoreBackup(backupMetadata);
+        await backupManager.restoreBackup(backupMetadata, projectRoot);
         console.log(chalk.green('✓ Installation restored from backup'));
         console.log('');
       } catch (restoreError) {
@@ -171,10 +183,10 @@ async function runMigrations(fromVersion, toVersion, options = {}) {
     }
 
     // Release lock
-    await releaseMigrationLock();
+    await releaseMigrationLock(projectRoot);
 
     // Create error log
-    await createErrorLog(fromVersion, toVersion, error, backupMetadata);
+    await createErrorLog(projectRoot, fromVersion, toVersion, error, backupMetadata);
 
     throw error;
   }
@@ -182,8 +194,6 @@ async function runMigrations(fromVersion, toVersion, options = {}) {
 
 /**
  * Preview migrations without applying
- * @param {Array} migrations - Migrations to preview
- * @returns {Promise<object>} Preview result
  */
 async function previewMigrations(migrations) {
   const previews = [];
@@ -199,40 +209,35 @@ async function previewMigrations(migrations) {
       preview.actions.forEach(action => {
         console.log(chalk.gray(`  - ${action}`));
       });
-
-      previews.push({
-        name: migration.name,
-        preview
-      });
+      previews.push({ name: migration.name, preview });
     }
   }
 
+  console.log('');
+  console.log(chalk.white('After deltas, installation will be refreshed:'));
+  console.log(chalk.gray('  - Refresh agent files'));
+  console.log(chalk.gray('  - Refresh 7 workflow directories'));
+  console.log(chalk.gray('  - Update config.yaml (preserving user preferences)'));
+  console.log(chalk.gray('  - Update user guides (with .bak backup)'));
   console.log('');
   console.log(chalk.green('To apply these changes, run:'));
   console.log(chalk.cyan('  npx bmad-update'));
   console.log('');
 
-  return {
-    success: true,
-    dryRun: true,
-    previews
-  };
+  return { success: true, dryRun: true, previews };
 }
 
 /**
- * Execute a single migration
- * @param {object} migration - Migration to execute
- * @param {object} options - Options { verbose }
- * @returns {Promise<Array<string>>} Changes made
+ * Execute a single migration delta
  */
-async function executeMigration(migration, options = {}) {
+async function executeMigration(migration, projectRoot, options = {}) {
   const { verbose = false } = options;
 
   if (!migration.module || !migration.module.apply) {
     throw new Error(`Migration ${migration.name} has no apply function`);
   }
 
-  const changes = await migration.module.apply();
+  const changes = await migration.module.apply(projectRoot);
 
   if (verbose) {
     changes.forEach(change => {
@@ -245,45 +250,35 @@ async function executeMigration(migration, options = {}) {
 
 /**
  * Update migration history in config.yaml
- * @param {string} fromVersion - Version migrated from
- * @param {string} toVersion - Version migrated to
- * @param {Array} results - Migration results
  */
-async function updateMigrationHistory(fromVersion, toVersion, results) {
-  const configPath = path.join(process.cwd(), '_bmad/bme/_vortex/config.yaml');
+async function updateMigrationHistory(projectRoot, fromVersion, toVersion, results) {
+  const configPath = path.join(projectRoot, '_bmad/bme/_vortex/config.yaml');
 
   if (!fs.existsSync(configPath)) {
-    throw new Error('config.yaml not found');
+    throw new Error('config.yaml not found after refresh');
   }
 
   const configContent = fs.readFileSync(configPath, 'utf8');
-  const yaml = require('js-yaml');
   const config = yaml.load(configContent);
 
-  // Add migration history entry
-  const migrationsApplied = results.map(r => r.name);
+  const migrationsApplied = results
+    .filter(r => r.name !== 'refresh-installation')
+    .map(r => r.name);
+
   const updatedConfig = configMerger.addMigrationHistory(
-    config,
-    fromVersion,
-    toVersion,
-    migrationsApplied
+    config, fromVersion, toVersion, migrationsApplied
   );
 
-  // Write config
   await configMerger.writeConfig(configPath, updatedConfig);
 }
 
-/**
- * Acquire migration lock to prevent concurrent migrations
- */
-async function acquireMigrationLock() {
-  const lockFile = path.join(process.cwd(), '_bmad-output/.migration-lock');
+async function acquireMigrationLock(projectRoot) {
+  const lockFile = path.join(projectRoot, '_bmad-output/.migration-lock');
 
   if (fs.existsSync(lockFile)) {
     const lock = await fs.readJson(lockFile);
     const age = Date.now() - lock.timestamp;
 
-    // Stale lock (older than 5 minutes)
     if (age > 5 * 60 * 1000) {
       console.log(chalk.yellow('Removing stale migration lock'));
       await fs.remove(lockFile);
@@ -292,39 +287,22 @@ async function acquireMigrationLock() {
     }
   }
 
-  // Create lock
-  await fs.ensureDir(path.join(process.cwd(), '_bmad-output'));
-  await fs.writeJson(lockFile, {
-    timestamp: Date.now(),
-    pid: process.pid
-  });
+  await fs.ensureDir(path.join(projectRoot, '_bmad-output'));
+  await fs.writeJson(lockFile, { timestamp: Date.now(), pid: process.pid });
 }
 
-/**
- * Release migration lock
- */
-async function releaseMigrationLock() {
-  const lockFile = path.join(process.cwd(), '_bmad-output/.migration-lock');
-
+async function releaseMigrationLock(projectRoot) {
+  const lockFile = path.join(projectRoot, '_bmad-output/.migration-lock');
   if (fs.existsSync(lockFile)) {
     await fs.remove(lockFile);
   }
 }
 
-/**
- * Create migration log
- * @param {string} fromVersion - Version migrated from
- * @param {string} toVersion - Version migrated to
- * @param {Array} results - Migration results
- * @param {object} backupMetadata - Backup metadata
- */
-async function createMigrationLog(fromVersion, toVersion, results, backupMetadata) {
-  const logsDir = path.join(process.cwd(), '_bmad-output/.logs');
+async function createMigrationLog(projectRoot, fromVersion, toVersion, results, backupMetadata) {
+  const logsDir = path.join(projectRoot, '_bmad-output/.logs');
   await fs.ensureDir(logsDir);
 
-  const timestamp = Date.now();
-  const logFile = path.join(logsDir, `migration-${timestamp}.log`);
-
+  const logFile = path.join(logsDir, `migration-${Date.now()}.log`);
   const logContent = [
     `BMAD-Enhanced Migration Log`,
     `Date: ${new Date().toISOString()}`,
@@ -345,20 +323,11 @@ async function createMigrationLog(fromVersion, toVersion, results, backupMetadat
   await fs.writeFile(logFile, logContent, 'utf8');
 }
 
-/**
- * Create error log
- * @param {string} fromVersion - Version migrated from
- * @param {string} toVersion - Version migrated to
- * @param {Error} error - Error that occurred
- * @param {object} backupMetadata - Backup metadata (if exists)
- */
-async function createErrorLog(fromVersion, toVersion, error, backupMetadata) {
-  const logsDir = path.join(process.cwd(), '_bmad-output/.logs');
+async function createErrorLog(projectRoot, fromVersion, toVersion, error, backupMetadata) {
+  const logsDir = path.join(projectRoot, '_bmad-output/.logs');
   await fs.ensureDir(logsDir);
 
-  const timestamp = Date.now();
-  const logFile = path.join(logsDir, `migration-error-${timestamp}.log`);
-
+  const logFile = path.join(logsDir, `migration-error-${Date.now()}.log`);
   const logContent = [
     `BMAD-Enhanced Migration Error Log`,
     `Date: ${new Date().toISOString()}`,
@@ -373,18 +342,13 @@ async function createErrorLog(fromVersion, toVersion, error, backupMetadata) {
     backupMetadata ? `Backup: ${backupMetadata.backup_dir}` : 'No backup created',
     backupMetadata ? 'Status: ROLLED BACK' : 'Status: FAILED (no backup)',
     '',
-    'Please report this issue at: https://github.com/amalik/BMAD-Enhanced/issues',
-    'Include this log file when reporting.'
+    'Please report this issue at: https://github.com/amalik/BMAD-Enhanced/issues'
   ].join('\n');
 
   await fs.writeFile(logFile, logContent, 'utf8');
-
   console.log(chalk.gray(`Migration log: ${logFile}`));
 }
 
-/**
- * Custom error for migration failures
- */
 class MigrationError extends Error {
   constructor(migrationName, originalError) {
     super(`Migration ${migrationName} failed: ${originalError.message}`);

package/scripts/update/lib/refresh-installation.js

@@ -0,0 +1,132 @@
+#!/usr/bin/env node
+
+const fs = require('fs-extra');
+const path = require('path');
+const { getPackageVersion } = require('./utils');
+const configMerger = require('./config-merger');
+
+/**
+ * Refresh Installation for BMAD-Enhanced
+ *
+ * Copies latest agent files, workflows, config, and user guides from the
+ * package to the project. Called ONCE after all migration deltas have run,
+ * or directly by the install script.
+ */
+
+const AGENT_FILES = [
+  'contextualization-expert.md',
+  'lean-experiments-specialist.md'
+];
+
+const WORKFLOWS = [
+  'lean-persona',
+  'product-vision',
+  'contextualize-scope',
+  'mvp',
+  'lean-experiment',
+  'proof-of-concept',
+  'proof-of-value'
+];
+
+const USER_GUIDES = [
+  'EMMA-USER-GUIDE.md',
+  'WADE-USER-GUIDE.md'
+];
+
+/**
+ * Refresh all installation files from the package to the project.
+ *
+ * @param {string} projectRoot - Absolute path to project root
+ * @param {object} options
+ * @param {boolean} options.backupGuides - Create .bak of user guides before overwriting (default: true)
+ * @param {boolean} options.verbose - Log each action (default: true)
+ * @returns {Promise<Array<string>>} List of changes made
+ */
+async function refreshInstallation(projectRoot, options = {}) {
+  const { backupGuides = true, verbose = true } = options;
+  const changes = [];
+  const packageRoot = path.join(__dirname, '..', '..', '..');
+  const packageVortex = path.join(packageRoot, '_bmad', 'bme', '_vortex');
+  const targetVortex = path.join(projectRoot, '_bmad', 'bme', '_vortex');
+  const version = getPackageVersion();
+
+  // 1. Copy agent files
+  const agentsSource = path.join(packageVortex, 'agents');
+  const agentsTarget = path.join(targetVortex, 'agents');
+  await fs.ensureDir(agentsTarget);
+
+  for (const file of AGENT_FILES) {
+    const src = path.join(agentsSource, file);
+    if (fs.existsSync(src)) {
+      await fs.copy(src, path.join(agentsTarget, file), { overwrite: true });
+      changes.push(`Refreshed agent: ${file}`);
+      if (verbose) console.log(`    Refreshed agent: ${file}`);
+    }
+  }
+
+  // Remove deprecated agent files if still present
+  const deprecatedAgents = ['empathy-mapper.md', 'wireframe-designer.md'];
+  for (const file of deprecatedAgents) {
+    const agentPath = path.join(agentsTarget, file);
+    if (fs.existsSync(agentPath)) {
+      await fs.remove(agentPath);
+      changes.push(`Removed deprecated agent: ${file}`);
+      if (verbose) console.log(`    Removed deprecated agent: ${file}`);
+    }
+  }
+
+  // 2. Copy workflow directories
+  const workflowsSource = path.join(packageVortex, 'workflows');
+  const workflowsTarget = path.join(targetVortex, 'workflows');
+  await fs.ensureDir(workflowsTarget);
+
+  for (const wf of WORKFLOWS) {
+    const src = path.join(workflowsSource, wf);
+    if (fs.existsSync(src)) {
+      await fs.copy(src, path.join(workflowsTarget, wf), { overwrite: true });
+      changes.push(`Refreshed workflow: ${wf}`);
+      if (verbose) console.log(`    Refreshed workflow: ${wf}`);
+    }
+  }
+
+  // 3. Update config.yaml (merge, preserving user prefs)
+  const configPath = path.join(targetVortex, 'config.yaml');
+  await fs.ensureDir(path.dirname(configPath));
+
+  const updates = {
+    agents: ['contextualization-expert', 'lean-experiments-specialist'],
+    workflows: WORKFLOWS
+  };
+
+  const merged = await configMerger.mergeConfig(configPath, version, updates);
+  await configMerger.writeConfig(configPath, merged);
+  changes.push(`Updated config.yaml to v${version}`);
+  if (verbose) console.log(`    Updated config.yaml to v${version}`);
+
+  // 4. Copy user guides (with optional backup)
+  const guidesSource = path.join(packageRoot, '_bmad-output', 'vortex-artifacts');
+  const guidesTarget = path.join(projectRoot, '_bmad-output', 'vortex-artifacts');
+  await fs.ensureDir(guidesTarget);
+
+  for (const guide of USER_GUIDES) {
+    const src = path.join(guidesSource, guide);
+    const dest = path.join(guidesTarget, guide);
+
+    if (fs.existsSync(src)) {
+      // Backup existing guide before overwriting
+      if (backupGuides && fs.existsSync(dest)) {
+        await fs.copy(dest, dest + '.bak', { overwrite: true });
+        changes.push(`Backed up ${guide} → ${guide}.bak`);
+        if (verbose) console.log(`    Backed up ${guide} → ${guide}.bak`);
+      }
+
+      await fs.copy(src, dest, { overwrite: true });
+      changes.push(`Refreshed guide: ${guide}`);
+      if (verbose) console.log(`    Refreshed guide: ${guide}`);
+    }
+  }
+
+  return changes;
+}
+
+module.exports = { refreshInstallation };

package/scripts/update/lib/utils.js

@@ -0,0 +1,96 @@
+#!/usr/bin/env node
+
+const fs = require('fs-extra');
+const path = require('path');
+
+/**
+ * Shared utilities for the BMAD-Enhanced update system.
+ * Single source of truth for version, comparison, project detection.
+ */
+
+/**
+ * Get the package version at runtime from package.json.
+ * This is the SINGLE SOURCE OF TRUTH for version - never hardcode versions elsewhere.
+ * @returns {string} e.g. "1.3.8"
+ */
+function getPackageVersion() {
+  const pkg = require('../../../package.json');
+  return pkg.version;
+}
+
+/**
+ * Compare two semantic version strings.
+ * @param {string} v1
+ * @param {string} v2
+ * @returns {number} -1 if v1 < v2, 0 if equal, 1 if v1 > v2
+ */
+function compareVersions(v1, v2) {
+  const parts1 = v1.split('.').map(Number);
+  const parts2 = v2.split('.').map(Number);
+
+  for (let i = 0; i < Math.max(parts1.length, parts2.length); i++) {
+    const p1 = parts1[i] || 0;
+    const p2 = parts2[i] || 0;
+    if (p1 < p2) return -1;
+    if (p1 > p2) return 1;
+  }
+
+  return 0;
+}
+
+/**
+ * Count user data files in _bmad-output/ (excluding .backups, .logs).
+ * @param {string} projectRoot - Absolute path to project root
+ * @returns {Promise<number>}
+ */
+async function countUserDataFiles(projectRoot) {
+  const outputDir = path.join(projectRoot, '_bmad-output');
+
+  if (!fs.existsSync(outputDir)) {
+    return 0;
+  }
+
+  let count = 0;
+
+  async function walk(dir) {
+    const entries = await fs.readdir(dir, { withFileTypes: true });
+    for (const entry of entries) {
+      if (entry.name === '.backups' || entry.name === '.logs') continue;
+      const full = path.join(dir, entry.name);
+      if (entry.isDirectory()) {
+        await walk(full);
+      } else if (entry.isFile()) {
+        count++;
+      }
+    }
+  }
+
+  await walk(outputDir);
+  return count;
+}
+
+/**
+ * Find the project root by walking up from cwd looking for _bmad/ directory.
+ * @returns {string|null} Absolute path to project root, or null if not found
+ */
+function findProjectRoot() {
+  let dir = process.cwd();
+  const root = path.parse(dir).root;
+
+  while (true) {
+    if (fs.existsSync(path.join(dir, '_bmad'))) {
+      return dir;
+    }
+    if (dir === root) break;
+    dir = path.dirname(dir);
+  }
+
+  return null;
+}
+
+module.exports = {
+  getPackageVersion,
+  compareVersions,
+  countUserDataFiles,
+  findProjectRoot
+};