bmad-enhanced 1.1.2 → 1.3.0

package/scripts/update/lib/validator.js

@@ -0,0 +1,430 @@
+#!/usr/bin/env node
+
+const fs = require('fs-extra');
+const path = require('path');
+const yaml = require('js-yaml');
+const configMerger = require('./config-merger');
+
+/**
+ * Validator for BMAD-Enhanced
+ * Verifies installation integrity post-migration
+ */
+
+/**
+ * Validate entire installation
+ * @param {object} preM
+
+igrationData - Data from before migration for comparison
+ * @returns {Promise<object>} Validation result
+ */
+async function validateInstallation(preMigrationData = {}) {
+  const checks = [];
+
+  // 1. Config structure validation
+  checks.push(await validateConfigStructure());
+
+  // 2. Agent files validation
+  checks.push(await validateAgentFiles());
+
+  // 3. Workflow files validation
+  checks.push(await validateWorkflows());
+
+  // 4. Manifest consistency validation
+  checks.push(await validateManifest());
+
+  // 5. User data integrity validation
+  if (preMigrationData.userDataCount) {
+    checks.push(await validateUserDataIntegrity(preMigrationData.userDataCount));
+  }
+
+  // 6. Deprecated workflows validation (if applicable)
+  checks.push(await validateDeprecatedWorkflows());
+
+  const allPassed = checks.every(c => c.passed);
+
+  return {
+    valid: allPassed,
+    checks
+  };
+}
+
+/**
+ * Validate config.yaml structure
+ * @returns {Promise<object>} Validation check result
+ */
+async function validateConfigStructure() {
+  const check = {
+    name: 'Config structure',
+    passed: false,
+    error: null
+  };
+
+  try {
+    const configPath = path.join(process.cwd(), '_bmad/bme/_vortex/config.yaml');
+
+    if (!fs.existsSync(configPath)) {
+      check.error = 'config.yaml not found';
+      return check;
+    }
+
+    const configContent = fs.readFileSync(configPath, 'utf8');
+    const config = yaml.load(configContent);
+
+    // Validate using config-merger
+    const validation = configMerger.validateConfig(config);
+
+    if (!validation.valid) {
+      check.error = validation.errors.join(', ');
+      return check;
+    }
+
+    check.passed = true;
+  } catch (error) {
+    check.error = error.message;
+  }
+
+  return check;
+}
+
+/**
+ * Validate agent files exist
+ * @returns {Promise<object>} Validation check result
+ */
+async function validateAgentFiles() {
+  const check = {
+    name: 'Agent files',
+    passed: false,
+    error: null
+  };
+
+  try {
+    const agentsDir = path.join(process.cwd(), '_bmad/bme/_vortex/agents');
+    const requiredAgents = [
+      'contextualization-expert.md',
+      'lean-experiments-specialist.md'
+    ];
+
+    if (!fs.existsSync(agentsDir)) {
+      check.error = 'agents/ directory not found';
+      return check;
+    }
+
+    const missingAgents = [];
+    for (const agent of requiredAgents) {
+      const agentPath = path.join(agentsDir, agent);
+      if (!fs.existsSync(agentPath)) {
+        missingAgents.push(agent);
+      }
+    }
+
+    if (missingAgents.length > 0) {
+      check.error = `Missing agent files: ${missingAgents.join(', ')}`;
+      return check;
+    }
+
+    check.passed = true;
+  } catch (error) {
+    check.error = error.message;
+  }
+
+  return check;
+}
+
+/**
+ * Validate workflow files exist
+ * @returns {Promise<object>} Validation check result
+ */
+async function validateWorkflows() {
+  const check = {
+    name: 'Workflow files',
+    passed: false,
+    error: null
+  };
+
+  try {
+    const workflowsDir = path.join(process.cwd(), '_bmad/bme/_vortex/workflows');
+    const requiredWorkflows = [
+      'lean-persona',
+      'product-vision',
+      'contextualize-scope',
+      'mvp',
+      'lean-experiment',
+      'proof-of-concept',
+      'proof-of-value'
+    ];
+
+    if (!fs.existsSync(workflowsDir)) {
+      check.error = 'workflows/ directory not found';
+      return check;
+    }
+
+    const missingWorkflows = [];
+    for (const workflow of requiredWorkflows) {
+      const workflowFile = path.join(workflowsDir, workflow, 'workflow.md');
+      if (!fs.existsSync(workflowFile)) {
+        missingWorkflows.push(workflow);
+      }
+    }
+
+    if (missingWorkflows.length > 0) {
+      check.error = `Missing workflows: ${missingWorkflows.join(', ')}`;
+      return check;
+    }
+
+    check.passed = true;
+  } catch (error) {
+    check.error = error.message;
+  }
+
+  return check;
+}
+
+/**
+ * Validate agent manifest consistency
+ * @returns {Promise<object>} Validation check result
+ */
+async function validateManifest() {
+  const check = {
+    name: 'Agent manifest',
+    passed: false,
+    error: null
+  };
+
+  try {
+    const manifestPath = path.join(process.cwd(), '_bmad/_config/agent-manifest.csv');
+
+    if (!fs.existsSync(manifestPath)) {
+      // Manifest is optional, so this is not a failure
+      check.passed = true;
+      check.warning = 'agent-manifest.csv not found (optional)';
+      return check;
+    }
+
+    const manifestContent = fs.readFileSync(manifestPath, 'utf8');
+
+    // Check for BMAD-Enhanced agents
+    const hasEmma = manifestContent.includes('contextualization-expert');
+    const hasWade = manifestContent.includes('lean-experiments-specialist');
+
+    if (!hasEmma || !hasWade) {
+      check.error = 'Agent manifest missing BMAD-Enhanced agents';
+      return check;
+    }
+
+    check.passed = true;
+  } catch (error) {
+    check.error = error.message;
+  }
+
+  return check;
+}
+
+/**
+ * Validate user data integrity
+ * @param {number} expectedCount - Expected file count
+ * @returns {Promise<object>} Validation check result
+ */
+async function validateUserDataIntegrity(expectedCount) {
+  const check = {
+    name: 'User data preserved',
+    passed: false,
+    error: null
+  };
+
+  try {
+    const outputDir = path.join(process.cwd(), '_bmad-output');
+
+    if (!fs.existsSync(outputDir)) {
+      check.error = '_bmad-output/ directory not found';
+      return check;
+    }
+
+    const currentCount = await countUserDataFiles(outputDir);
+
+    // Allow for slight variation (user guides may have been updated)
+    if (currentCount >= expectedCount - 2) {
+      check.passed = true;
+      check.info = `Files: ${currentCount} (expected: ${expectedCount})`;
+    } else {
+      check.error = `User data count mismatch: ${currentCount} (expected: ${expectedCount})`;
+    }
+  } catch (error) {
+    check.error = error.message;
+  }
+
+  return check;
+}
+
+/**
+ * Validate deprecated workflows structure
+ * @returns {Promise<object>} Validation check result
+ */
+async function validateDeprecatedWorkflows() {
+  const check = {
+    name: 'Deprecated workflows',
+    passed: true, // Not required, so pass by default
+    error: null
+  };
+
+  try {
+    const deprecatedDir = path.join(process.cwd(), '_bmad/bme/_vortex/workflows/_deprecated');
+
+    if (!fs.existsSync(deprecatedDir)) {
+      check.info = 'No deprecated workflows (fresh installation)';
+      return check;
+    }
+
+    // If deprecated dir exists, check for expected workflows
+    const empathyMapDir = path.join(deprecatedDir, 'empathy-map');
+    const wireframeDir = path.join(deprecatedDir, 'wireframe');
+
+    if (!fs.existsSync(empathyMapDir) && !fs.existsSync(wireframeDir)) {
+      check.warning = '_deprecated/ directory exists but is empty';
+    } else {
+      check.info = 'Deprecated workflows preserved in _deprecated/';
+    }
+
+    check.passed = true;
+  } catch (error) {
+    check.error = error.message;
+    check.passed = false;
+  }
+
+  return check;
+}
+
+/**
+ * Count user data files in _bmad-output
+ * @param {string} outputDir - Output directory path
+ * @returns {Promise<number>} File count
+ */
+async function countUserDataFiles(outputDir) {
+  let count = 0;
+
+  async function countRecursive(dir) {
+    const entries = await fs.readdir(dir, { withFileTypes: true });
+
+    for (const entry of entries) {
+      const fullPath = path.join(dir, entry.name);
+
+      // Skip .backups and .logs directories
+      if (entry.name === '.backups' || entry.name === '.logs') {
+        continue;
+      }
+
+      if (entry.isDirectory()) {
+        await countRecursive(fullPath);
+      } else if (entry.isFile()) {
+        count++;
+      }
+    }
+  }
+
+  await countRecursive(outputDir);
+  return count;
+}
+
+/**
+ * Run smoke tests after migration
+ * @returns {Promise<object>} Smoke test result
+ */
+async function runSmokeTests() {
+  const tests = [];
+
+  // Test 1: Can read Emma agent file
+  tests.push(await testReadAgentFile('contextualization-expert.md', 'Emma'));
+
+  // Test 2: Can read Wade agent file
+  tests.push(await testReadAgentFile('lean-experiments-specialist.md', 'Wade'));
+
+  // Test 3: Can read a workflow template
+  tests.push(await testReadWorkflowTemplate('lean-persona'));
+
+  // Test 4: Config.yaml is parseable
+  tests.push(await testConfigParseable());
+
+  const allPassed = tests.every(t => t.passed);
+
+  return {
+    passed: allPassed,
+    tests
+  };
+}
+
+/**
+ * Test reading an agent file
+ */
+async function testReadAgentFile(filename, agentName) {
+  const test = { name: `Read ${agentName} agent file`, passed: false };
+
+  try {
+    const agentPath = path.join(process.cwd(), '_bmad/bme/_vortex/agents', filename);
+    const content = await fs.readFile(agentPath, 'utf8');
+
+    if (content.length > 0) {
+      test.passed = true;
+    }
+  } catch (error) {
+    test.error = error.message;
+  }
+
+  return test;
+}
+
+/**
+ * Test reading a workflow template
+ */
+async function testReadWorkflowTemplate(workflowName) {
+  const test = { name: `Read ${workflowName} template`, passed: false };
+
+  try {
+    const templatePath = path.join(
+      process.cwd(),
+      '_bmad/bme/_vortex/workflows',
+      workflowName,
+      `${workflowName}.template.md`
+    );
+
+    const content = await fs.readFile(templatePath, 'utf8');
+
+    if (content.length > 0) {
+      test.passed = true;
+    }
+  } catch (error) {
+    test.error = error.message;
+  }
+
+  return test;
+}
+
+/**
+ * Test config.yaml parseability
+ */
+async function testConfigParseable() {
+  const test = { name: 'Parse config.yaml', passed: false };
+
+  try {
+    const configPath = path.join(process.cwd(), '_bmad/bme/_vortex/config.yaml');
+    const content = await fs.readFile(configPath, 'utf8');
+    const config = yaml.load(content);
+
+    if (config && config.version) {
+      test.passed = true;
+    }
+  } catch (error) {
+    test.error = error.message;
+  }
+
+  return test;
+}
+
+module.exports = {
+  validateInstallation,
+  validateConfigStructure,
+  validateAgentFiles,
+  validateWorkflows,
+  validateManifest,
+  validateUserDataIntegrity,
+  validateDeprecatedWorkflows,
+  runSmokeTests
+};

package/scripts/update/lib/version-detector.js

@@ -0,0 +1,246 @@
+#!/usr/bin/env node
+
+const fs = require('fs-extra');
+const path = require('path');
+const yaml = require('js-yaml');
+
+/**
+ * Version Detector for BMAD-Enhanced
+ * Reliably detects current installed version and determines migration path
+ */
+
+/**
+ * Get current installed version from config.yaml
+ * @returns {string|null} Version string or null if not found
+ */
+function getCurrentVersion() {
+  try {
+    const configPath = path.join(process.cwd(), '_bmad/bme/_vortex/config.yaml');
+
+    if (!fs.existsSync(configPath)) {
+      return null; // No config = fresh install
+    }
+
+    const configContent = fs.readFileSync(configPath, 'utf8');
+    const config = yaml.load(configContent);
+
+    if (config && config.version) {
+      return config.version;
+    }
+
+    // Fallback: Check for deprecated folder structure to guess version
+    console.warn('Warning: config.yaml exists but has no version field');
+    return guessVersionFromFileStructure();
+
+  } catch (error) {
+    console.warn('Warning: Could not read config.yaml:', error.message);
+    return guessVersionFromFileStructure();
+  }
+}
+
+/**
+ * Guess version from file structure (fallback method)
+ * @returns {string|null} Guessed version or null
+ */
+function guessVersionFromFileStructure() {
+  const vortexDir = path.join(process.cwd(), '_bmad/bme/_vortex');
+
+  if (!fs.existsSync(vortexDir)) {
+    return null; // No installation
+  }
+
+  // Check for deprecated folder (exists in v1.1.0+)
+  const deprecatedDir = path.join(vortexDir, 'workflows/_deprecated');
+  if (fs.existsSync(deprecatedDir)) {
+    return '1.1.0'; // Has deprecated folder = v1.1.0+
+  }
+
+  // Check for old empathy-map workflow (v1.0.0)
+  const empathyMapDir = path.join(vortexDir, 'workflows/empathy-map');
+  if (fs.existsSync(empathyMapDir)) {
+    return '1.0.0'; // Has empathy-map in workflows = v1.0.0
+  }
+
+  // Has vortex dir but can't determine version
+  return '1.0.0'; // Default to oldest version
+}
+
+/**
+ * Get target version from package.json
+ * @returns {string} Target version
+ */
+function getTargetVersion() {
+  try {
+    const packagePath = path.join(__dirname, '../../../package.json');
+    const packageContent = fs.readFileSync(packagePath, 'utf8');
+    const packageJson = JSON.parse(packageContent);
+
+    return packageJson.version;
+  } catch (error) {
+    throw new Error(`Could not read package.json: ${error.message}`);
+  }
+}
+
+/**
+ * Determine migration path based on versions
+ * @param {string|null} currentVersion - Current installed version
+ * @param {string} targetVersion - Target version from package
+ * @returns {object} Migration path info
+ */
+function getMigrationPath(currentVersion, targetVersion) {
+  // Fresh install (no current version)
+  if (!currentVersion) {
+    return {
+      type: 'fresh-install',
+      needsMigration: false,
+      breaking: false
+    };
+  }
+
+  // Already up to date
+  if (currentVersion === targetVersion) {
+    return {
+      type: 'up-to-date',
+      needsMigration: false,
+      breaking: false
+    };
+  }
+
+  // Downgrade attempt (not supported)
+  if (compareVersions(currentVersion, targetVersion) > 0) {
+    return {
+      type: 'downgrade',
+      needsMigration: false,
+      breaking: false,
+      fromVersion: currentVersion,
+      toVersion: targetVersion
+    };
+  }
+
+  // Upgrade needed
+  const breaking = isBreakingChange(currentVersion, targetVersion);
+
+  return {
+    type: 'upgrade-needed',
+    needsMigration: true,
+    breaking,
+    fromVersion: currentVersion,
+    toVersion: targetVersion
+  };
+}
+
+/**
+ * Detect installation scenario
+ * @returns {string} Scenario: 'fresh' | 'partial' | 'complete' | 'corrupted'
+ */
+function detectInstallationScenario() {
+  const vortexDir = path.join(process.cwd(), '_bmad/bme/_vortex');
+  const configPath = path.join(vortexDir, 'config.yaml');
+  const agentsDir = path.join(vortexDir, 'agents');
+  const workflowsDir = path.join(vortexDir, 'workflows');
+
+  // No vortex directory = fresh install
+  if (!fs.existsSync(vortexDir)) {
+    return 'fresh';
+  }
+
+  // No config.yaml = partial installation
+  if (!fs.existsSync(configPath)) {
+    return 'partial';
+  }
+
+  // Check agent files
+  const requiredAgents = [
+    'contextualization-expert.md',
+    'lean-experiments-specialist.md'
+  ];
+
+  if (!fs.existsSync(agentsDir)) {
+    return 'corrupted';
+  }
+
+  const missingAgents = requiredAgents.filter(agent =>
+    !fs.existsSync(path.join(agentsDir, agent))
+  );
+
+  if (missingAgents.length > 0) {
+    return 'corrupted';
+  }
+
+  // Check workflows directory
+  if (!fs.existsSync(workflowsDir)) {
+    return 'corrupted';
+  }
+
+  return 'complete';
+}
+
+/**
+ * Compare two semantic versions
+ * @param {string} v1 - First version
+ * @param {string} v2 - Second version
+ * @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 part1 = parts1[i] || 0;
+    const part2 = parts2[i] || 0;
+
+    if (part1 < part2) return -1;
+    if (part1 > part2) return 1;
+  }
+
+  return 0;
+}
+
+/**
+ * Determine if upgrade involves breaking changes
+ * @param {string} fromVersion - Current version
+ * @param {string} toVersion - Target version
+ * @returns {boolean} True if breaking changes exist
+ */
+function isBreakingChange(fromVersion, toVersion) {
+  // v1.0.x → any later version = breaking (empathy-map removed)
+  if (fromVersion.startsWith('1.0.')) {
+    return true;
+  }
+
+  // v1.1.x → v1.2.0 = not breaking (just updates)
+  if (fromVersion.startsWith('1.1.') && toVersion.startsWith('1.2.')) {
+    return false;
+  }
+
+  // Major version change = breaking
+  const fromMajor = parseInt(fromVersion.split('.')[0]);
+  const toMajor = parseInt(toVersion.split('.')[0]);
+
+  if (fromMajor < toMajor) {
+    return true;
+  }
+
+  return false;
+}
+
+/**
+ * Get version range pattern for migrations (e.g., "1.0.x")
+ * @param {string} version - Full version string
+ * @returns {string} Version range pattern
+ */
+function getVersionRange(version) {
+  const parts = version.split('.');
+  return `${parts[0]}.${parts[1]}.x`;
+}
+
+module.exports = {
+  getCurrentVersion,
+  getTargetVersion,
+  getMigrationPath,
+  detectInstallationScenario,
+  compareVersions,
+  isBreakingChange,
+  getVersionRange,
+  guessVersionFromFileStructure
+};