bmad-fh 6.0.0-alpha.23

package/tools/cli/installers/lib/core/detector.js

@@ -0,0 +1,223 @@
+const path = require('node:path');
+const fs = require('fs-extra');
+const yaml = require('yaml');
+const { Manifest } = require('./manifest');
+
+class Detector {
+  /**
+   * Detect existing BMAD installation
+   * @param {string} bmadDir - Path to bmad directory
+   * @returns {Object} Installation status and details
+   */
+  async detect(bmadDir) {
+    const result = {
+      installed: false,
+      path: bmadDir,
+      version: null,
+      hasCore: false,
+      modules: [],
+      ides: [],
+      customModules: [],
+      manifest: null,
+    };
+
+    // Check if bmad directory exists
+    if (!(await fs.pathExists(bmadDir))) {
+      return result;
+    }
+
+    // Check for manifest using the Manifest class
+    const manifest = new Manifest();
+    const manifestData = await manifest.read(bmadDir);
+    if (manifestData) {
+      result.manifest = manifestData;
+      result.version = manifestData.version;
+      result.installed = true;
+      // Copy custom modules if they exist
+      if (manifestData.customModules) {
+        result.customModules = manifestData.customModules;
+      }
+    }
+
+    // Check for core
+    const corePath = path.join(bmadDir, 'core');
+    if (await fs.pathExists(corePath)) {
+      result.hasCore = true;
+
+      // Try to get core version from config
+      const coreConfigPath = path.join(corePath, 'config.yaml');
+      if (await fs.pathExists(coreConfigPath)) {
+        try {
+          const configContent = await fs.readFile(coreConfigPath, 'utf8');
+          const config = yaml.parse(configContent);
+          if (!result.version && config.version) {
+            result.version = config.version;
+          }
+        } catch {
+          // Ignore config read errors
+        }
+      }
+    }
+
+    // Check for modules
+    // If manifest exists, use it as the source of truth for installed modules
+    // Otherwise fall back to directory scanning (legacy installations)
+    if (manifestData && manifestData.modules && manifestData.modules.length > 0) {
+      // Use manifest module list - these are officially installed modules
+      for (const moduleId of manifestData.modules) {
+        const modulePath = path.join(bmadDir, moduleId);
+        const moduleConfigPath = path.join(modulePath, 'config.yaml');
+
+        const moduleInfo = {
+          id: moduleId,
+          path: modulePath,
+          version: 'unknown',
+        };
+
+        if (await fs.pathExists(moduleConfigPath)) {
+          try {
+            const configContent = await fs.readFile(moduleConfigPath, 'utf8');
+            const config = yaml.parse(configContent);
+            moduleInfo.version = config.version || 'unknown';
+            moduleInfo.name = config.name || moduleId;
+            moduleInfo.description = config.description;
+          } catch {
+            // Ignore config read errors
+          }
+        }
+
+        result.modules.push(moduleInfo);
+      }
+    } else {
+      // Fallback: scan directory for modules (legacy installations without manifest)
+      const entries = await fs.readdir(bmadDir, { withFileTypes: true });
+      for (const entry of entries) {
+        if (entry.isDirectory() && entry.name !== 'core' && entry.name !== '_config') {
+          const modulePath = path.join(bmadDir, entry.name);
+          const moduleConfigPath = path.join(modulePath, 'config.yaml');
+
+          // Only treat it as a module if it has a config.yaml
+          if (await fs.pathExists(moduleConfigPath)) {
+            const moduleInfo = {
+              id: entry.name,
+              path: modulePath,
+              version: 'unknown',
+            };
+
+            try {
+              const configContent = await fs.readFile(moduleConfigPath, 'utf8');
+              const config = yaml.parse(configContent);
+              moduleInfo.version = config.version || 'unknown';
+              moduleInfo.name = config.name || entry.name;
+              moduleInfo.description = config.description;
+            } catch {
+              // Ignore config read errors
+            }
+
+            result.modules.push(moduleInfo);
+          }
+        }
+      }
+    }
+
+    // Check for IDE configurations from manifest
+    if (result.manifest && result.manifest.ides) {
+      // Filter out any undefined/null values
+      result.ides = result.manifest.ides.filter((ide) => ide && typeof ide === 'string');
+    }
+
+    // Mark as installed if we found core or modules
+    if (result.hasCore || result.modules.length > 0) {
+      result.installed = true;
+    }
+
+    return result;
+  }
+
+  /**
+   * Detect legacy installation (_bmad-method, .bmm, .cis)
+   * @param {string} projectDir - Project directory to check
+   * @returns {Object} Legacy installation details
+   */
+  async detectLegacy(projectDir) {
+    const result = {
+      hasLegacy: false,
+      legacyCore: false,
+      legacyModules: [],
+      paths: [],
+    };
+
+    // Check for legacy core (_bmad-method)
+    const legacyCorePath = path.join(projectDir, '_bmad-method');
+    if (await fs.pathExists(legacyCorePath)) {
+      result.hasLegacy = true;
+      result.legacyCore = true;
+      result.paths.push(legacyCorePath);
+    }
+
+    // Check for legacy modules (directories starting with .)
+    const entries = await fs.readdir(projectDir, { withFileTypes: true });
+    for (const entry of entries) {
+      if (
+        entry.isDirectory() &&
+        entry.name.startsWith('.') &&
+        entry.name !== '_bmad-method' &&
+        !entry.name.startsWith('.git') &&
+        !entry.name.startsWith('.vscode') &&
+        !entry.name.startsWith('.idea')
+      ) {
+        const modulePath = path.join(projectDir, entry.name);
+        const moduleManifestPath = path.join(modulePath, 'install-manifest.yaml');
+
+        // Check if it's likely a BMAD module
+        if ((await fs.pathExists(moduleManifestPath)) || (await fs.pathExists(path.join(modulePath, 'config.yaml')))) {
+          result.hasLegacy = true;
+          result.legacyModules.push({
+            name: entry.name.slice(1), // Remove leading dot
+            path: modulePath,
+          });
+          result.paths.push(modulePath);
+        }
+      }
+    }
+
+    return result;
+  }
+
+  /**
+   * Check if migration from legacy is needed
+   * @param {string} projectDir - Project directory
+   * @returns {Object} Migration requirements
+   */
+  async checkMigrationNeeded(projectDir) {
+    const bmadDir = path.join(projectDir, 'bmad');
+    const current = await this.detect(bmadDir);
+    const legacy = await this.detectLegacy(projectDir);
+
+    return {
+      needed: legacy.hasLegacy && !current.installed,
+      canMigrate: legacy.hasLegacy,
+      legacy: legacy,
+      current: current,
+    };
+  }
+
+  /**
+   * Detect legacy BMAD v4 .bmad-method folder
+   * @param {string} projectDir - Project directory to check
+   * @returns {{ hasLegacyV4: boolean, offenders: string[] }}
+   */
+  async detectLegacyV4(projectDir) {
+    const offenders = [];
+
+    // Check for .bmad-method folder
+    const bmadMethodPath = path.join(projectDir, '.bmad-method');
+    if (await fs.pathExists(bmadMethodPath)) {
+      offenders.push(bmadMethodPath);
+    }
+
+    return { hasLegacyV4: offenders.length > 0, offenders };
+  }
+}
+
+module.exports = { Detector };

package/tools/cli/installers/lib/core/ide-config-manager.js

@@ -0,0 +1,156 @@
+const path = require('node:path');
+const fs = require('fs-extra');
+const yaml = require('yaml');
+
+/**
+ * Manages IDE configuration persistence
+ * Saves and loads IDE-specific configurations to/from bmad/_config/ides/
+ */
+class IdeConfigManager {
+  constructor() {}
+
+  /**
+   * Get path to IDE config directory
+   * @param {string} bmadDir - BMAD installation directory
+   * @returns {string} Path to IDE config directory
+   */
+  getIdeConfigDir(bmadDir) {
+    return path.join(bmadDir, '_config', 'ides');
+  }
+
+  /**
+   * Get path to specific IDE config file
+   * @param {string} bmadDir - BMAD installation directory
+   * @param {string} ideName - IDE name (e.g., 'claude-code')
+   * @returns {string} Path to IDE config file
+   */
+  getIdeConfigPath(bmadDir, ideName) {
+    return path.join(this.getIdeConfigDir(bmadDir), `${ideName}.yaml`);
+  }
+
+  /**
+   * Save IDE configuration
+   * @param {string} bmadDir - BMAD installation directory
+   * @param {string} ideName - IDE name
+   * @param {Object} configuration - IDE-specific configuration object
+   */
+  async saveIdeConfig(bmadDir, ideName, configuration) {
+    const configDir = this.getIdeConfigDir(bmadDir);
+    await fs.ensureDir(configDir);
+
+    const configPath = this.getIdeConfigPath(bmadDir, ideName);
+    const now = new Date().toISOString();
+
+    // Check if config already exists to preserve configured_date
+    let configuredDate = now;
+    if (await fs.pathExists(configPath)) {
+      try {
+        const existing = await this.loadIdeConfig(bmadDir, ideName);
+        if (existing && existing.configured_date) {
+          configuredDate = existing.configured_date;
+        }
+      } catch {
+        // Ignore errors reading existing config
+      }
+    }
+
+    const configData = {
+      ide: ideName,
+      configured_date: configuredDate,
+      last_updated: now,
+      configuration: configuration || {},
+    };
+
+    // Clean the config to remove any non-serializable values (like functions)
+    const cleanConfig = structuredClone(configData);
+
+    const yamlContent = yaml.stringify(cleanConfig, {
+      indent: 2,
+      lineWidth: 0,
+      sortKeys: false,
+    });
+
+    // Ensure POSIX-compliant final newline
+    const content = yamlContent.endsWith('\n') ? yamlContent : yamlContent + '\n';
+    await fs.writeFile(configPath, content, 'utf8');
+  }
+
+  /**
+   * Load IDE configuration
+   * @param {string} bmadDir - BMAD installation directory
+   * @param {string} ideName - IDE name
+   * @returns {Object|null} IDE configuration or null if not found
+   */
+  async loadIdeConfig(bmadDir, ideName) {
+    const configPath = this.getIdeConfigPath(bmadDir, ideName);
+
+    if (!(await fs.pathExists(configPath))) {
+      return null;
+    }
+
+    try {
+      const content = await fs.readFile(configPath, 'utf8');
+      const config = yaml.parse(content);
+      return config;
+    } catch (error) {
+      console.warn(`Warning: Failed to load IDE config for ${ideName}:`, error.message);
+      return null;
+    }
+  }
+
+  /**
+   * Load all IDE configurations
+   * @param {string} bmadDir - BMAD installation directory
+   * @returns {Object} Map of IDE name to configuration
+   */
+  async loadAllIdeConfigs(bmadDir) {
+    const configDir = this.getIdeConfigDir(bmadDir);
+    const configs = {};
+
+    if (!(await fs.pathExists(configDir))) {
+      return configs;
+    }
+
+    try {
+      const files = await fs.readdir(configDir);
+      for (const file of files) {
+        if (file.endsWith('.yaml')) {
+          const ideName = file.replace('.yaml', '');
+          const config = await this.loadIdeConfig(bmadDir, ideName);
+          if (config) {
+            configs[ideName] = config.configuration;
+          }
+        }
+      }
+    } catch (error) {
+      console.warn('Warning: Failed to load IDE configs:', error.message);
+    }
+
+    return configs;
+  }
+
+  /**
+   * Check if IDE has saved configuration
+   * @param {string} bmadDir - BMAD installation directory
+   * @param {string} ideName - IDE name
+   * @returns {boolean} True if configuration exists
+   */
+  async hasIdeConfig(bmadDir, ideName) {
+    const configPath = this.getIdeConfigPath(bmadDir, ideName);
+    return await fs.pathExists(configPath);
+  }
+
+  /**
+   * Delete IDE configuration
+   * @param {string} bmadDir - BMAD installation directory
+   * @param {string} ideName - IDE name
+   */
+  async deleteIdeConfig(bmadDir, ideName) {
+    const configPath = this.getIdeConfigPath(bmadDir, ideName);
+    if (await fs.pathExists(configPath)) {
+      await fs.remove(configPath);
+    }
+  }
+}
+
+module.exports = { IdeConfigManager };