bmad-method 6.3.1-next.2 → 6.3.1-next.21

package/tools/installer/file-ops.js

@@ -1,4 +1,4 @@
-const fs = require('fs-extra');
+const fs = require('./fs-native');
 const path = require('node:path');
 const crypto = require('node:crypto');
 

package/tools/installer/fs-native.js

@@ -0,0 +1,116 @@
+// Drop-in replacement for fs-extra using native node:fs APIs.
+// Eliminates graceful-fs monkey-patching that causes non-deterministic
+// file loss during multi-module installs on macOS (issue #1779).
+const fsp = require('node:fs/promises');
+const fs = require('node:fs');
+const path = require('node:path');
+
+async function pathExists(p) {
+  try {
+    await fsp.access(p);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+async function ensureDir(dir) {
+  await fsp.mkdir(dir, { recursive: true });
+}
+
+async function remove(p) {
+  await fsp.rm(p, { recursive: true, force: true });
+}
+
+async function copy(src, dest, options = {}) {
+  const filterFn = options.filter;
+  const overwrite = options.overwrite !== false;
+  const srcStat = await fsp.stat(src);
+
+  if (srcStat.isFile()) {
+    if (filterFn && !(await filterFn(src, dest))) return;
+    await fsp.mkdir(path.dirname(dest), { recursive: true });
+    if (!overwrite) {
+      try {
+        await fsp.access(dest);
+        if (options.errorOnExist) throw new Error(`${dest} already exists`);
+        return;
+      } catch (error) {
+        if (error.message.includes('already exists')) throw error;
+      }
+    }
+    await fsp.copyFile(src, dest);
+    return;
+  }
+
+  if (srcStat.isDirectory()) {
+    if (filterFn && !(await filterFn(src, dest))) return;
+    await fsp.mkdir(dest, { recursive: true });
+    const entries = await fsp.readdir(src, { withFileTypes: true });
+    for (const entry of entries) {
+      await copy(path.join(src, entry.name), path.join(dest, entry.name), options);
+    }
+  }
+}
+
+async function move(src, dest) {
+  try {
+    await fsp.rename(src, dest);
+  } catch (error) {
+    if (error.code === 'EXDEV') {
+      await copy(src, dest);
+      await fsp.rm(src, { recursive: true, force: true });
+    } else {
+      throw error;
+    }
+  }
+}
+
+function readJsonSync(p) {
+  return JSON.parse(fs.readFileSync(p, 'utf8'));
+}
+
+async function writeJson(p, data, options = {}) {
+  const spaces = options.spaces ?? 2;
+  await fsp.writeFile(p, JSON.stringify(data, null, spaces) + '\n', 'utf8');
+}
+
+module.exports = {
+  // Native async (node:fs/promises)
+  readFile: fsp.readFile,
+  writeFile: fsp.writeFile,
+  stat: fsp.stat,
+  readdir: fsp.readdir,
+  access: fsp.access,
+  realpath: fsp.realpath,
+  rename: fsp.rename,
+  rmdir: fsp.rmdir,
+  unlink: fsp.unlink,
+  chmod: fsp.chmod,
+  mkdir: fsp.mkdir,
+  mkdtemp: fsp.mkdtemp,
+  copyFile: fsp.copyFile,
+  rm: fsp.rm,
+
+  // fs-extra compatible helpers (native implementations)
+  pathExists,
+  ensureDir,
+  remove,
+  copy,
+  move,
+  readJsonSync,
+  writeJson,
+
+  // Sync methods from core node:fs
+  existsSync: fs.existsSync.bind(fs),
+  readFileSync: fs.readFileSync.bind(fs),
+  writeFileSync: fs.writeFileSync.bind(fs),
+  statSync: fs.statSync.bind(fs),
+  accessSync: fs.accessSync.bind(fs),
+  readdirSync: fs.readdirSync.bind(fs),
+  createReadStream: fs.createReadStream.bind(fs),
+  pathExistsSync: fs.existsSync.bind(fs),
+
+  // Constants
+  constants: fs.constants,
+};

package/tools/installer/ide/_config-driven.js

@@ -1,6 +1,6 @@
 const os = require('node:os');
 const path = require('node:path');
-const fs = require('fs-extra');
+const fs = require('../fs-native');
 const yaml = require('yaml');
 const prompts = require('../prompts');
 const csv = require('csv-parse/sync');

package/tools/installer/ide/platform-codes.js

@@ -1,4 +1,4 @@
-const fs = require('fs-extra');
+const fs = require('../fs-native');
 const path = require('node:path');
 const yaml = require('yaml');
 

package/tools/installer/ide/shared/path-utils.js

@@ -15,8 +15,6 @@
  * - standalone/agents/fred.md → bmad-agent-standalone-fred.md
  */
 
-// Type segments - agents are included in naming, others are filtered out
-const TYPE_SEGMENTS = ['workflows', 'tasks', 'tools'];
 const AGENT_SEGMENT = 'agents';
 
 // BMAD installation folder name - centralized constant for all installers
@@ -194,125 +192,6 @@ function parseDashName(filename) {
   };
 }
 
-// ============================================================================
-// LEGACY FUNCTIONS (underscore format) - kept for backward compatibility
-// ============================================================================
-
-/**
- * Convert hierarchical path to flat underscore-separated name (LEGACY)
- * @deprecated Use toDashName instead
- */
-function toUnderscoreName(module, type, name) {
-  const isAgent = type === AGENT_SEGMENT;
-  if (module === 'core') {
-    return isAgent ? `bmad_agent_${name}.md` : `bmad_${name}.md`;
-  }
-  if (module === 'standalone') {
-    return isAgent ? `bmad_agent_standalone_${name}.md` : `bmad_standalone_${name}.md`;
-  }
-  return isAgent ? `bmad_${module}_agent_${name}.md` : `bmad_${module}_${name}.md`;
-}
-
-/**
- * Convert relative path to flat underscore-separated name (LEGACY)
- * @deprecated Use toDashPath instead
- */
-function toUnderscorePath(relativePath) {
-  // Strip common file extensions (same as toDashPath for consistency)
-  const withoutExt = relativePath.replace(/\.(md|yaml|yml|json|xml|toml)$/i, '');
-  const parts = withoutExt.split(/[/\\]/);
-
-  const module = parts[0];
-  const type = parts[1];
-  const name = parts.slice(2).join('_');
-
-  return toUnderscoreName(module, type, name);
-}
-
-/**
- * Create custom agent underscore name (LEGACY)
- * @deprecated Use customAgentDashName instead
- */
-function customAgentUnderscoreName(agentName) {
-  return `bmad_custom_${agentName}.md`;
-}
-
-/**
- * Check if a filename uses underscore format (LEGACY)
- * @deprecated Use isDashFormat instead
- */
-function isUnderscoreFormat(filename) {
-  return filename.startsWith('bmad_') && filename.includes('_');
-}
-
-/**
- * Extract parts from an underscore-formatted filename (LEGACY)
- * @deprecated Use parseDashName instead
- */
-function parseUnderscoreName(filename) {
-  const withoutExt = filename.replace('.md', '');
-  const parts = withoutExt.split('_');
-
-  if (parts.length < 2 || parts[0] !== 'bmad') {
-    return null;
-  }
-
-  const agentIndex = parts.indexOf('agent');
-
-  if (agentIndex !== -1) {
-    if (agentIndex === 1) {
-      // bmad_agent_... - check for standalone
-      if (parts.length >= 4 && parts[2] === 'standalone') {
-        return {
-          prefix: parts[0],
-          module: 'standalone',
-          type: 'agents',
-          name: parts.slice(3).join('_'),
-        };
-      }
-      return {
-        prefix: parts[0],
-        module: 'core',
-        type: 'agents',
-        name: parts.slice(agentIndex + 1).join('_'),
-      };
-    } else {
-      return {
-        prefix: parts[0],
-        module: parts[1],
-        type: 'agents',
-        name: parts.slice(agentIndex + 1).join('_'),
-      };
-    }
-  }
-
-  if (parts.length === 2) {
-    return {
-      prefix: parts[0],
-      module: 'core',
-      type: 'workflows',
-      name: parts[1],
-    };
-  }
-
-  // Check for standalone non-agent: bmad_standalone_name
-  if (parts[1] === 'standalone') {
-    return {
-      prefix: parts[0],
-      module: 'standalone',
-      type: 'workflows',
-      name: parts.slice(2).join('_'),
-    };
-  }
-
-  return {
-    prefix: parts[0],
-    module: parts[1],
-    type: 'workflows',
-    name: parts.slice(2).join('_'),
-  };
-}
-
 /**
  * Resolve the skill name for an artifact.
  * Prefers canonicalId from a bmad-skill-manifest.yaml sidecar when available,
@@ -328,37 +207,13 @@ function resolveSkillName(artifact) {
   return toDashPath(artifact.relativePath);
 }
 
-// Backward compatibility aliases (colon format was same as underscore)
-const toColonName = toUnderscoreName;
-const toColonPath = toUnderscorePath;
-const customAgentColonName = customAgentUnderscoreName;
-const isColonFormat = isUnderscoreFormat;
-const parseColonName = parseUnderscoreName;
-
 module.exports = {
-  // New standard (dash-based)
   toDashName,
   toDashPath,
   resolveSkillName,
   customAgentDashName,
   isDashFormat,
   parseDashName,
-
-  // Legacy (underscore-based) - kept for backward compatibility
-  toUnderscoreName,
-  toUnderscorePath,
-  customAgentUnderscoreName,
-  isUnderscoreFormat,
-  parseUnderscoreName,
-
-  // Backward compatibility aliases
-  toColonName,
-  toColonPath,
-  customAgentColonName,
-  isColonFormat,
-  parseColonName,
-
-  TYPE_SEGMENTS,
   AGENT_SEGMENT,
   BMAD_FOLDER_NAME,
 };

package/tools/installer/ide/shared/skill-manifest.js

@@ -1,5 +1,5 @@
 const path = require('node:path');
-const fs = require('fs-extra');
+const fs = require('../../fs-native');
 const yaml = require('yaml');
 
 /**

package/tools/installer/message-loader.js

@@ -1,4 +1,4 @@
-const fs = require('fs-extra');
+const fs = require('./fs-native');
 const path = require('node:path');
 const yaml = require('yaml');
 const prompts = require('./prompts');

package/tools/installer/modules/channel-plan.js

@@ -0,0 +1,203 @@
+/**
+ * Channel plan: the per-module resolution decision applied at install time.
+ *
+ * A "plan entry" for a module is:
+ *   { channel: 'stable'|'next'|'pinned', pin?: string }
+ *
+ * We build the plan from:
+ *   1. CLI flags (--channel / --all-* / --next=CODE / --pin CODE=TAG)
+ *   2. Interactive answers (the "all stable?" gate + per-module picker)
+ *   3. Registry defaults (default_channel from registry-fallback.yaml / official.yaml)
+ *   4. Hardcoded fallback 'stable'
+ *
+ * Precedence: --pin > --next=CODE > --channel (global) > registry default > 'stable'.
+ *
+ * This module is pure. No prompts, no git, no filesystem.
+ */
+
+const VALID_CHANNELS = new Set(['stable', 'next']);
+
+/**
+ * Parse raw commander options into a structured channel options object.
+ *
+ * @param {Object} options - raw command-line options
+ * @returns {{
+ *   global: 'stable'|'next'|null,
+ *   nextSet: Set<string>,
+ *   pins: Map<string, string>,
+ *   warnings: string[]
+ * }}
+ */
+function parseChannelOptions(options = {}) {
+  const warnings = [];
+
+  // Global channel from --channel / --all-stable / --all-next.
+  let global = null;
+  const aliases = [];
+  if (options.channel) aliases.push({ flag: '--channel', value: normalizeChannel(options.channel, warnings, '--channel') });
+  if (options.allStable) aliases.push({ flag: '--all-stable', value: 'stable' });
+  if (options.allNext) aliases.push({ flag: '--all-next', value: 'next' });
+
+  const distinct = new Set(aliases.map((a) => a.value).filter(Boolean));
+  if (distinct.size > 1) {
+    warnings.push(
+      `Conflicting channel flags: ${aliases
+        .filter((a) => a.value)
+        .map((a) => a.flag + '=' + a.value)
+        .join(', ')}. Using first: ${aliases.find((a) => a.value).flag}.`,
+    );
+  }
+  const firstValid = aliases.find((a) => a.value);
+  if (firstValid) global = firstValid.value;
+
+  // --next=CODE (repeatable)
+  const nextSet = new Set();
+  for (const code of options.next || []) {
+    const trimmed = String(code).trim();
+    if (!trimmed) continue;
+    nextSet.add(trimmed);
+  }
+
+  // --pin CODE=TAG (repeatable)
+  const pins = new Map();
+  for (const spec of options.pin || []) {
+    const parsed = parsePinSpec(spec);
+    if (!parsed) {
+      warnings.push(`Ignoring malformed --pin value '${spec}'. Expected CODE=TAG.`);
+      continue;
+    }
+    if (pins.has(parsed.code)) {
+      warnings.push(`--pin specified multiple times for '${parsed.code}'. Using last: ${parsed.tag}.`);
+    }
+    pins.set(parsed.code, parsed.tag);
+  }
+
+  // --yes auto-confirms the community-module curator-bypass prompt so
+  // headless installs with --next=/--pin for a community module don't hang.
+  const acceptBypass = options.yes === true || options.acceptBypass === true;
+
+  return { global, nextSet, pins, warnings, acceptBypass };
+}
+
+function normalizeChannel(raw, warnings, flagName) {
+  if (typeof raw !== 'string') return null;
+  const lower = raw.trim().toLowerCase();
+  if (VALID_CHANNELS.has(lower)) return lower;
+  warnings.push(`Ignoring invalid ${flagName} value '${raw}'. Expected one of: stable, next.`);
+  return null;
+}
+
+function parsePinSpec(spec) {
+  if (typeof spec !== 'string') return null;
+  const idx = spec.indexOf('=');
+  if (idx <= 0 || idx === spec.length - 1) return null;
+  const code = spec.slice(0, idx).trim();
+  const tag = spec.slice(idx + 1).trim();
+  if (!code || !tag) return null;
+  return { code, tag };
+}
+
+/**
+ * Build a per-module plan entry, applying precedence.
+ *
+ * @param {Object} args
+ * @param {string} args.code
+ * @param {Object} args.channelOptions - from parseChannelOptions
+ * @param {string} [args.registryDefault] - module's default_channel, if any
+ * @returns {{channel: 'stable'|'next'|'pinned', pin?: string, source: string}}
+ *   source describes where the decision came from, for logging / debugging.
+ */
+function decideChannelForModule({ code, channelOptions, registryDefault }) {
+  const { global, nextSet, pins } = channelOptions || { nextSet: new Set(), pins: new Map() };
+
+  if (pins && pins.has(code)) {
+    return { channel: 'pinned', pin: pins.get(code), source: 'flag:--pin' };
+  }
+  if (nextSet && nextSet.has(code)) {
+    return { channel: 'next', source: 'flag:--next' };
+  }
+  if (global) {
+    return { channel: global, source: 'flag:--channel' };
+  }
+  if (registryDefault && VALID_CHANNELS.has(registryDefault)) {
+    return { channel: registryDefault, source: 'registry' };
+  }
+  return { channel: 'stable', source: 'default' };
+}
+
+/**
+ * Build a full channel plan map for a set of modules.
+ *
+ * @param {Object} args
+ * @param {Array<{code: string, defaultChannel?: string, builtIn?: boolean}>} args.modules
+ *   Only the modules that need a channel entry; callers should filter out
+ *   bundled modules (core/bmm) before calling.
+ * @param {Object} args.channelOptions - from parseChannelOptions
+ * @returns {Map<string, {channel: string, pin?: string, source: string}>}
+ */
+function buildPlan({ modules, channelOptions }) {
+  const plan = new Map();
+  for (const mod of modules || []) {
+    plan.set(
+      mod.code,
+      decideChannelForModule({
+        code: mod.code,
+        channelOptions,
+        registryDefault: mod.defaultChannel,
+      }),
+    );
+  }
+  return plan;
+}
+
+/**
+ * Report any --pin CODE=TAG entries that don't correspond to a selected module.
+ * These get warned about but don't abort the install.
+ */
+function orphanPinWarnings(channelOptions, selectedCodes) {
+  const warnings = [];
+  const selected = new Set(selectedCodes || []);
+  for (const code of channelOptions?.pins?.keys() || []) {
+    if (!selected.has(code)) {
+      warnings.push(`--pin for '${code}' has no effect (module not selected).`);
+    }
+  }
+  for (const code of channelOptions?.nextSet || []) {
+    if (!selected.has(code)) {
+      warnings.push(`--next for '${code}' has no effect (module not selected).`);
+    }
+  }
+  return warnings;
+}
+
+/**
+ * Warn when --pin / --next targets a bundled module (core, bmm). Those are
+ * shipped inside the installer binary — there's no git clone to override, so
+ * the flag has no effect. Users who actually want a prerelease core/bmm
+ * should use `npx bmad-method@next install`.
+ */
+function bundledTargetWarnings(channelOptions, bundledCodes) {
+  const warnings = [];
+  const bundled = new Set(bundledCodes || []);
+  const hint = '(bundled module; use `npx bmad-method@next install` for a prerelease)';
+  for (const code of channelOptions?.pins?.keys() || []) {
+    if (bundled.has(code)) {
+      warnings.push(`--pin for '${code}' has no effect ${hint}.`);
+    }
+  }
+  for (const code of channelOptions?.nextSet || []) {
+    if (bundled.has(code)) {
+      warnings.push(`--next for '${code}' has no effect ${hint}.`);
+    }
+  }
+  return warnings;
+}
+
+module.exports = {
+  parseChannelOptions,
+  decideChannelForModule,
+  buildPlan,
+  orphanPinWarnings,
+  bundledTargetWarnings,
+  parsePinSpec,
+};