bmad-method-quarkus 1.0.0

package/tools/installer/core/manifest.js

@@ -0,0 +1,433 @@
+const path = require('node:path');
+const https = require('node:https');
+const { execFile } = require('node:child_process');
+const { promisify } = require('node:util');
+const fs = require('../fs-native');
+const crypto = require('node:crypto');
+const { resolveModuleVersion } = require('../modules/version-resolver');
+const prompts = require('../prompts');
+
+const execFileAsync = promisify(execFile);
+const NPM_LOOKUP_TIMEOUT_MS = 10_000;
+const NPM_PACKAGE_NAME_PATTERN = /^(?:@[a-z0-9][a-z0-9._~-]*\/)?[a-z0-9][a-z0-9._~-]*$/;
+
+function isValidNpmPackageName(packageName) {
+  return typeof packageName === 'string' && NPM_PACKAGE_NAME_PATTERN.test(packageName);
+}
+
+class Manifest {
+  /**
+   * Create a new manifest
+   * @param {string} bmadDir - Path to bmad directory
+   * @param {Object} data - Manifest data
+   * @param {Array} installedFiles - List of installed files (no longer used, files tracked in files-manifest.csv)
+   */
+  async create(bmadDir, data, installedFiles = []) {
+    const manifestPath = path.join(bmadDir, '_config', 'manifest.yaml');
+    const yaml = require('yaml');
+
+    // Ensure _config directory exists
+    await fs.ensureDir(path.dirname(manifestPath));
+
+    // Get the BMad version from package.json
+    const bmadVersion = data.version || require(path.join(process.cwd(), 'package.json')).version;
+
+    // Convert module list to new detailed format
+    const moduleDetails = [];
+    if (data.modules && Array.isArray(data.modules)) {
+      for (const moduleName of data.modules) {
+        // Core and BMM modules use the BMad version
+        const moduleVersion = moduleName === 'core' || moduleName === 'bmm' ? bmadVersion : null;
+        const now = data.installDate || new Date().toISOString();
+
+        moduleDetails.push({
+          name: moduleName,
+          version: moduleVersion,
+          installDate: now,
+          lastUpdated: now,
+          source: moduleName === 'core' || moduleName === 'bmm' ? 'built-in' : 'unknown',
+        });
+      }
+    }
+
+    // Structure the manifest data
+    const manifestData = {
+      installation: {
+        version: bmadVersion,
+        installDate: data.installDate || new Date().toISOString(),
+        lastUpdated: data.lastUpdated || new Date().toISOString(),
+      },
+      modules: moduleDetails,
+      ides: data.ides || [],
+    };
+
+    // Write YAML manifest
+    // Clean the manifest data to remove any non-serializable values
+    const cleanManifestData = structuredClone(manifestData);
+
+    const yamlContent = yaml.stringify(cleanManifestData, {
+      indent: 2,
+      lineWidth: 0,
+      sortKeys: false,
+    });
+
+    // Ensure POSIX-compliant final newline
+    const content = yamlContent.endsWith('\n') ? yamlContent : yamlContent + '\n';
+    await fs.writeFile(manifestPath, content, 'utf8');
+    return { success: true, path: manifestPath, filesTracked: 0 };
+  }
+
+  /**
+   * Read existing manifest
+   * @param {string} bmadDir - Path to bmad directory
+   * @returns {Object|null} Manifest data or null if not found
+   */
+  async read(bmadDir) {
+    const yamlPath = path.join(bmadDir, '_config', 'manifest.yaml');
+    const yaml = require('yaml');
+
+    if (await fs.pathExists(yamlPath)) {
+      try {
+        const content = await fs.readFile(yamlPath, 'utf8');
+        const manifestData = yaml.parse(content);
+
+        // Handle new detailed module format
+        const modules = manifestData.modules || [];
+
+        // For backward compatibility: if modules is an array of strings (old format),
+        // the calling code may need the array of names
+        const moduleNames = modules.map((m) => (typeof m === 'string' ? m : m.name));
+
+        // Check if we have the new detailed format
+        const hasDetailedModules = modules.length > 0 && typeof modules[0] === 'object';
+
+        // Flatten the structure for compatibility with existing code
+        return {
+          version: manifestData.installation?.version,
+          installDate: manifestData.installation?.installDate,
+          lastUpdated: manifestData.installation?.lastUpdated,
+          modules: moduleNames, // Simple array of module names for backward compatibility
+          modulesDetailed: hasDetailedModules ? modules : null, // New detailed format
+          ides: manifestData.ides || [],
+        };
+      } catch (error) {
+        await prompts.log.error(`Failed to read YAML manifest: ${error.message}`);
+      }
+    }
+
+    return null;
+  }
+
+  /**
+   * Read raw manifest data without flattening
+   * @param {string} bmadDir - Path to bmad directory
+   * @returns {Object|null} Raw manifest data or null if not found
+   */
+  async _readRaw(bmadDir) {
+    const yamlPath = path.join(bmadDir, '_config', 'manifest.yaml');
+    const yaml = require('yaml');
+
+    if (await fs.pathExists(yamlPath)) {
+      try {
+        const content = await fs.readFile(yamlPath, 'utf8');
+        return yaml.parse(content);
+      } catch (error) {
+        await prompts.log.error(`Failed to read YAML manifest: ${error.message}`);
+      }
+    }
+
+    return null;
+  }
+
+  /**
+   * Flatten manifest for backward compatibility
+   * @param {Object} manifest - Raw manifest data
+   * @returns {Object} Flattened manifest
+   */
+  _flattenManifest(manifest) {
+    const modules = manifest.modules || [];
+    const moduleNames = modules.map((m) => (typeof m === 'string' ? m : m.name));
+    const hasDetailedModules = modules.length > 0 && typeof modules[0] === 'object';
+
+    return {
+      version: manifest.installation?.version,
+      installDate: manifest.installation?.installDate,
+      lastUpdated: manifest.installation?.lastUpdated,
+      modules: moduleNames,
+      modulesDetailed: hasDetailedModules ? modules : null,
+      ides: manifest.ides || [],
+    };
+  }
+
+  /**
+   * Add a module to the manifest with optional version info
+   * If module already exists, update its version info
+   * @param {string} bmadDir - Path to bmad directory
+   * @param {string} moduleName - Module name to add
+   * @param {Object} options - Optional version info
+   */
+  async addModule(bmadDir, moduleName, options = {}) {
+    let manifest = await this._readRaw(bmadDir);
+    if (!manifest) {
+      // Bootstrap a minimal manifest if it doesn't exist yet
+      // (e.g., skill-only modules with no agents to compile)
+      manifest = { modules: [] };
+    }
+
+    if (!manifest.modules) {
+      manifest.modules = [];
+    }
+
+    const existingIndex = manifest.modules.findIndex((m) => m.name === moduleName);
+
+    if (existingIndex === -1) {
+      // Module doesn't exist, add it
+      const entry = {
+        name: moduleName,
+        version: options.version || null,
+        installDate: new Date().toISOString(),
+        lastUpdated: new Date().toISOString(),
+        source: options.source || 'unknown',
+        npmPackage: options.npmPackage || null,
+        repoUrl: options.repoUrl || null,
+      };
+      if (options.channel) entry.channel = options.channel;
+      if (options.sha) entry.sha = options.sha;
+      if (options.localPath) entry.localPath = options.localPath;
+      if (options.rawSource) entry.rawSource = options.rawSource;
+      if (options.registryApprovedTag) entry.registryApprovedTag = options.registryApprovedTag;
+      if (options.registryApprovedSha) entry.registryApprovedSha = options.registryApprovedSha;
+      manifest.modules.push(entry);
+    } else {
+      // Module exists, update its version info
+      const existing = manifest.modules[existingIndex];
+      manifest.modules[existingIndex] = {
+        ...existing,
+        version: options.version === undefined ? existing.version : options.version,
+        source: options.source || existing.source,
+        npmPackage: options.npmPackage === undefined ? existing.npmPackage : options.npmPackage,
+        repoUrl: options.repoUrl === undefined ? existing.repoUrl : options.repoUrl,
+        localPath: options.localPath === undefined ? existing.localPath : options.localPath,
+        channel: options.channel === undefined ? existing.channel : options.channel,
+        sha: options.sha === undefined ? existing.sha : options.sha,
+        rawSource: options.rawSource === undefined ? existing.rawSource : options.rawSource,
+        registryApprovedTag: options.registryApprovedTag === undefined ? existing.registryApprovedTag : options.registryApprovedTag,
+        registryApprovedSha: options.registryApprovedSha === undefined ? existing.registryApprovedSha : options.registryApprovedSha,
+        lastUpdated: new Date().toISOString(),
+      };
+    }
+
+    await this._writeRaw(bmadDir, manifest);
+  }
+
+  /**
+   * Get all modules with their version info
+   * @param {string} bmadDir - Path to bmad directory
+   * @returns {Array} Array of module info objects
+   */
+  async getAllModuleVersions(bmadDir) {
+    const manifest = await this._readRaw(bmadDir);
+    if (!manifest || !manifest.modules) {
+      return [];
+    }
+
+    return manifest.modules;
+  }
+
+  /**
+   * Write raw manifest data to file
+   * @param {string} bmadDir - Path to bmad directory
+   * @param {Object} manifestData - Raw manifest data to write
+   */
+  async _writeRaw(bmadDir, manifestData) {
+    const yaml = require('yaml');
+    const manifestPath = path.join(bmadDir, '_config', 'manifest.yaml');
+
+    await fs.ensureDir(path.dirname(manifestPath));
+
+    const cleanManifestData = structuredClone(manifestData);
+
+    const yamlContent = yaml.stringify(cleanManifestData, {
+      indent: 2,
+      lineWidth: 0,
+      sortKeys: false,
+    });
+
+    const content = yamlContent.endsWith('\n') ? yamlContent : yamlContent + '\n';
+    await fs.writeFile(manifestPath, content, 'utf8');
+  }
+
+  /**
+   * Calculate SHA256 hash of a file
+   * @param {string} filePath - Path to file
+   * @returns {string} SHA256 hash
+   */
+  async calculateFileHash(filePath) {
+    try {
+      const content = await fs.readFile(filePath);
+      return crypto.createHash('sha256').update(content).digest('hex');
+    } catch {
+      return null;
+    }
+  }
+
+  /**
+   * Get module version info from source
+   * @param {string} moduleName - Module name/code
+   * @param {string} bmadDir - Path to bmad directory
+   * @param {string} moduleSourcePath - Optional source path for custom modules
+   * @returns {Object} Version info object with version, source, npmPackage, repoUrl
+   */
+  async getModuleVersionInfo(moduleName, bmadDir, moduleSourcePath = null) {
+    // Resolve source type first, then read version with the correct path context
+    if (['core', 'bmm'].includes(moduleName)) {
+      const versionInfo = await resolveModuleVersion(moduleName, { moduleSourcePath });
+      return {
+        version: versionInfo.version,
+        source: 'built-in',
+        npmPackage: null,
+        repoUrl: null,
+      };
+    }
+
+    // Check if this is an external official module
+    const { ExternalModuleManager } = require('../modules/external-manager');
+    const extMgr = new ExternalModuleManager();
+    const moduleInfo = await extMgr.getModuleByCode(moduleName);
+
+    if (moduleInfo) {
+      const externalResolution = extMgr.getResolution(moduleName);
+      const versionInfo = await resolveModuleVersion(moduleName, { moduleSourcePath });
+      return {
+        // Git tag recorded during install trumps the on-disk package.json
+        // version, so the manifest carries "v1.7.0" instead of "1.7.0".
+        version: externalResolution?.version || versionInfo.version,
+        source: 'external',
+        npmPackage: moduleInfo.npmPackage || null,
+        repoUrl: moduleInfo.url || null,
+        channel: externalResolution?.channel || null,
+        sha: externalResolution?.sha || null,
+      };
+    }
+
+    // Check if this is a custom module (from user-provided URL or local path)
+    const { CustomModuleManager } = require('../modules/custom-module-manager');
+    const customMgr = new CustomModuleManager();
+    const resolved = customMgr.getResolution(moduleName);
+    const customSource = await customMgr.findModuleSourceByCode(moduleName, { bmadDir });
+    if (customSource || resolved) {
+      const versionInfo = await resolveModuleVersion(moduleName, {
+        moduleSourcePath: moduleSourcePath || customSource,
+        fallbackVersion: resolved?.version,
+        marketplacePluginNames: resolved?.pluginName ? [resolved.pluginName] : [],
+      });
+      const hasGitClone = !!resolved?.repoUrl;
+      return {
+        // Prefer the git ref we actually cloned over the package.json version.
+        version: resolved?.cloneRef || (hasGitClone ? 'main' : versionInfo.version),
+        source: 'custom',
+        npmPackage: null,
+        repoUrl: resolved?.repoUrl || null,
+        localPath: resolved?.localPath || null,
+        channel: hasGitClone ? (resolved?.cloneRef ? 'pinned' : 'next') : null,
+        sha: resolved?.cloneSha || null,
+        rawSource: resolved?.rawInput || null,
+      };
+    }
+
+    // Unknown module
+    const versionInfo = await resolveModuleVersion(moduleName, { moduleSourcePath });
+    return {
+      version: versionInfo.version,
+      source: 'unknown',
+      npmPackage: null,
+      repoUrl: null,
+    };
+  }
+
+  /**
+   * Fetch latest version from npm for a package
+   * @param {string} packageName - npm package name
+   * @returns {string|null} Latest version or null
+   */
+  async fetchNpmVersion(packageName) {
+    if (!isValidNpmPackageName(packageName)) {
+      return null;
+    }
+
+    try {
+      // Try using npm view first (more reliable)
+      try {
+        const { stdout } = await execFileAsync('npm', ['view', packageName, 'version'], {
+          encoding: 'utf8',
+          timeout: NPM_LOOKUP_TIMEOUT_MS,
+        });
+        return stdout.trim();
+      } catch {
+        // Fallback to npm registry API
+        return new Promise((resolve) => {
+          const request = https.get(`https://registry.npmjs.org/${encodeURIComponent(packageName)}`, (res) => {
+            let data = '';
+            res.on('data', (chunk) => (data += chunk));
+            res.on('end', () => {
+              try {
+                const pkg = JSON.parse(data);
+                resolve(pkg['dist-tags']?.latest || pkg.version || null);
+              } catch {
+                resolve(null);
+              }
+            });
+          });
+
+          request.setTimeout(NPM_LOOKUP_TIMEOUT_MS, () => {
+            request.destroy();
+            resolve(null);
+          });
+
+          request.on('error', () => resolve(null));
+        });
+      }
+    } catch {
+      return null;
+    }
+  }
+
+  /**
+   * Check for available updates for installed modules
+   * @param {string} bmadDir - Path to bmad directory
+   * @returns {Array} Array of update info objects
+   */
+  async checkForUpdates(bmadDir) {
+    const semver = require('semver');
+    const modules = await this.getAllModuleVersions(bmadDir);
+    const updates = [];
+
+    for (const module of modules) {
+      if (!module.npmPackage) {
+        continue; // Skip modules without npm package (built-in)
+      }
+
+      const latestVersion = await this.fetchNpmVersion(module.npmPackage);
+      if (!latestVersion) {
+        continue;
+      }
+
+      const installedVersion = semver.valid(module.version) || semver.valid(semver.coerce(module.version || ''));
+      const availableVersion = semver.valid(latestVersion) || semver.valid(semver.coerce(latestVersion));
+
+      if (installedVersion && availableVersion && semver.gt(availableVersion, installedVersion)) {
+        updates.push({
+          name: module.name,
+          installedVersion: module.version,
+          latestVersion: latestVersion,
+          npmPackage: module.npmPackage,
+          updateAvailable: true,
+        });
+      }
+    }
+
+    return updates;
+  }
+}
+
+module.exports = { Manifest };

package/tools/installer/core/uv-check.js

@@ -0,0 +1,195 @@
+const { spawnSync } = require('node:child_process');
+const prompts = require('../prompts');
+
+// `uv` (https://docs.astral.sh/uv/) is how BMAD runs the Python scripts its
+// skills shell out to: `uv run <script>` resolves the interpreter and any
+// dependencies on demand from the script's own `requires-python` metadata, so
+// skills don't have to assume a particular `python3` is on PATH.
+//
+// As of v6.11.0 this is a requirement, not a preference: the rendered skills
+// (`bmad-build`, `bmad-build-auto`) render through `render_skill.py` and HALT
+// on activation if `uv` is unavailable — there is no interpreter fallback.
+//
+// The check still never blocks the install. Core-only, docs-only, and CI
+// installs are legitimate and never touch a rendered skill, so a missing `uv`
+// must not fail the run. What it does is tell the truth about what will and
+// will not work afterwards, here and again in the post-install summary.
+const RUNTIME_COMMAND = 'uv';
+
+// Probed only when `uv` is absent. Some skills still invoke the interpreter
+// directly (`python3 .../resolve_customization.py`), and those scripts declare
+// `requires-python = ">=3.11"` — `resolve_config.py` hard-exits below it
+// because `tomllib` is a 3.11 stdlib addition. When `uv` is present it
+// provisions its own interpreter and whatever `python3` resolves to on PATH is
+// irrelevant, so probing it then would report a problem that doesn't exist.
+const PYTHON_COMMAND = 'python3';
+const MIN_PYTHON = { major: 3, minor: 11 };
+
+/**
+ * Parse `uv --version` output into version parts.
+ * Example outputs: "uv 0.5.31", "uv 0.5.31 (Homebrew 2025-02-12)".
+ * @param {string} output - stdout/stderr from `uv --version`
+ * @returns {{major: number, minor: number, patch: number, raw: string}|null}
+ */
+function parseUvVersion(output) {
+  if (!output) return null;
+  const match = output.match(/uv\s+(\d+)\.(\d+)(?:\.(\d+))?/i);
+  if (!match) return null;
+  return {
+    major: Number(match[1]),
+    minor: Number(match[2]),
+    patch: Number(match[3] || 0),
+    raw: `${match[1]}.${match[2]}.${match[3] || 0}`,
+  };
+}
+
+/**
+ * Parse `python3 --version` output into version parts.
+ * Example outputs: "Python 3.11.7", "Python 3.13.0rc1".
+ * @param {string} output - stdout/stderr from `python3 --version`
+ * @returns {{major: number, minor: number, patch: number, raw: string}|null}
+ */
+function parsePythonVersion(output) {
+  if (!output) return null;
+  const match = output.match(/Python\s+(\d+)\.(\d+)(?:\.(\d+))?/i);
+  if (!match) return null;
+  return {
+    major: Number(match[1]),
+    minor: Number(match[2]),
+    patch: Number(match[3] || 0),
+    raw: `${match[1]}.${match[2]}.${match[3] || 0}`,
+  };
+}
+
+/**
+ * Whether a parsed Python version satisfies the 3.11+ floor the scripts declare.
+ * @param {{major: number, minor: number}|null} version
+ * @returns {boolean}
+ */
+function pythonMeetsMinimum(version) {
+  if (!version) return false;
+  if (version.major !== MIN_PYTHON.major) return version.major > MIN_PYTHON.major;
+  return version.minor >= MIN_PYTHON.minor;
+}
+
+/**
+ * Run `<command> --version` and hand the combined output to a parser.
+ * @param {string} command
+ * @param {(output: string) => Object|null} parse
+ * @returns {{version: Object}|null}
+ */
+function probeVersion(command, parse) {
+  let result;
+  try {
+    result = spawnSync(command, ['--version'], {
+      encoding: 'utf8',
+      timeout: 5000,
+      windowsHide: true,
+    });
+  } catch {
+    return null;
+  }
+  if (!result || result.error) return null;
+  const version = parse(`${result.stdout || ''}\n${result.stderr || ''}`);
+  return version ? { version } : null;
+}
+
+/**
+ * Probe the local environment for `uv`.
+ * @returns {{version: {major: number, minor: number, patch: number, raw: string}}|null}
+ */
+function detectUv() {
+  return probeVersion(RUNTIME_COMMAND, parseUvVersion);
+}
+
+/**
+ * Probe the local environment for `python3`.
+ * @returns {{version: {major: number, minor: number, patch: number, raw: string}}|null}
+ */
+function detectPython3() {
+  return probeVersion(PYTHON_COMMAND, parsePythonVersion);
+}
+
+function setupHints() {
+  return [
+    '`uv run` provisions the interpreter and dependencies for you — no manual',
+    'venv or pip, and no need for a particular python3 on PATH.',
+    '',
+    'Easiest path: ask your AI agent to "install and set up uv for me".',
+    '',
+    'Or install it yourself:',
+    '  macOS/Linux:  curl -LsSf https://astral.sh/uv/install.sh | sh',
+    '  Windows:      powershell -c "irm https://astral.sh/uv/install.ps1 | iex"',
+    '  Homebrew:     brew install uv',
+    '  Docs:         https://docs.astral.sh/uv/getting-started/installation/',
+  ].join('\n');
+}
+
+/**
+ * Describe what a missing `uv` leaves working, based on the `python3` fallback.
+ *
+ * With `uv` gone the rendered skills are lost either way; the only question is
+ * whether the skills that invoke the interpreter directly still run, and that
+ * turns on `python3` being 3.11+.
+ *
+ * @param {{version: Object}|null} python - result of detectPython3()
+ * @returns {string}
+ */
+function pythonFallbackNote(python) {
+  if (!python) {
+    return 'No python3 on PATH either, so no Python-backed skill will run.';
+  }
+  if (pythonMeetsMinimum(python.version)) {
+    return (
+      `python3 ${python.version.raw} is present, so skills that call the interpreter ` +
+      'directly still work — but the rendered skills above stay unavailable.'
+    );
+  }
+  return (
+    `python3 ${python.version.raw} is present but below the required ` +
+    `${MIN_PYTHON.major}.${MIN_PYTHON.minor}, so no Python-backed skill will run.`
+  );
+}
+
+/**
+ * Check whether `uv` is available and inform the user.
+ *
+ * Warn-don't-block: a missing `uv` never stops or fails the install, because
+ * core-only and CI installs are legitimate and never render a skill. But the
+ * warning names the concrete consequence — `bmad-build` and `bmad-build-auto`
+ * halt — rather than describing `uv` as a nice-to-have, and `installer.js`
+ * repeats it in the post-install summary so it isn't lost in the scrollback.
+ *
+ * @returns {Promise<{status: 'found'|'missing', detected: Object|null, python: Object|null}>}
+ */
+async function checkUvEnvironment() {
+  // Called via module.exports so tests can stub detection.
+  const detected = module.exports.detectUv();
+
+  if (detected) {
+    await prompts.log.success(`✅ Python UV check pass (uv ${detected.version.raw} detected).`);
+    return { status: 'found', detected, python: null };
+  }
+
+  const python = module.exports.detectPython3();
+
+  await prompts.log.warn(
+    'uv not found on PATH. BMAD requires it to run the Python scripts its skills\n' +
+      'shell out to: bmad-build and bmad-build-auto render through `uv run` and will\n' +
+      'HALT on activation without it — there is no interpreter fallback.\n' +
+      `${pythonFallbackNote(python)}\n` +
+      'The install itself completes either way.',
+  );
+  await prompts.note(setupHints(), 'uv required');
+  return { status: 'missing', detected: null, python };
+}
+
+module.exports = {
+  checkUvEnvironment,
+  detectUv,
+  detectPython3,
+  parseUvVersion,
+  parsePythonVersion,
+  pythonMeetsMinimum,
+  MIN_PYTHON,
+};