@phuc1403/musketeer 0.1.0

package/src/muster.js

@@ -0,0 +1,48 @@
+'use strict';
+
+// The muster — the interactive picker. Uses @clack/prompts (ESM-only), loaded
+// via dynamic import() for CommonJS interop. `core` is always re-added after
+// selection (clack has no per-option lock), enforcing the locked-on invariant.
+
+/**
+ * @param {object} manifest
+ * @param {{musketeers:string[]}} prev current lockfile company
+ * @returns {Promise<?string[]>} chosen ids (incl. core), or null if cancelled
+ */
+async function pick(manifest, prev) {
+  const clack = await import('@clack/prompts');
+  const entries = Object.entries(manifest.musketeers);
+  const installed = new Set(prev.musketeers);
+  const hasLock = prev.musketeers.length > 0;
+
+  // Pre-checked: locked always; else current install (if any) else defaultChecked.
+  const initialValues = entries
+    .filter(([id, m]) => m.locked || (hasLock ? installed.has(id) : m.defaultChecked))
+    .map(([id]) => id);
+
+  const options = entries.map(([id, m]) => ({
+    value: id,
+    label: m.locked ? `${m.label} (core — always included)` : m.label,
+    hint: m.description,
+  }));
+
+  clack.intro('musketeer — muster');
+  const selected = await clack.multiselect({
+    message: 'Select your company (core is always installed):',
+    options,
+    initialValues,
+    required: false,
+  });
+
+  if (clack.isCancel(selected)) {
+    clack.cancel('Cancelled.');
+    return null;
+  }
+
+  const chosen = new Set(Array.isArray(selected) ? selected : []);
+  chosen.add('core'); // enforce locked-on
+  clack.outro(`Company: ${[...chosen].join(', ')}`);
+  return [...chosen];
+}
+
+module.exports = { pick };

package/src/provisioner/detect.js

@@ -0,0 +1,93 @@
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+const { spawnSync } = require('child_process');
+
+// Map of secret prereq name → environment variable that satisfies it.
+const SECRET_ENV = { 'anthropic-api-key': 'ANTHROPIC_API_KEY' };
+
+/**
+ * Default command runner. Captures stdout+stderr (java prints version to stderr)
+ * and never throws. Tests inject their own `ctx.run` to avoid touching the host.
+ * @param {string} cmd
+ * @returns {{code:number, stdout:string, stderr:string}}
+ */
+function defaultRun(cmd) {
+  const r = spawnSync(cmd, { shell: true, encoding: 'utf8', windowsHide: true });
+  return {
+    code: typeof r.status === 'number' ? r.status : 1,
+    stdout: r.stdout || '',
+    stderr: r.stderr || '',
+  };
+}
+
+/** Extract a numeric version tuple from arbitrary command output. */
+function parseVersion(text) {
+  const m = String(text).match(/(\d+)(?:\.(\d+))?(?:\.(\d+))?/);
+  if (!m) return null;
+  return [Number(m[1] || 0), Number(m[2] || 0), Number(m[3] || 0)];
+}
+
+/** found >= min ? (min may be "18" or "3.8") */
+function versionGte(found, min) {
+  if (!found) return false;
+  const want = parseVersion(min) || [0, 0, 0];
+  for (let i = 0; i < 3; i++) {
+    if (found[i] > want[i]) return true;
+    if (found[i] < want[i]) return false;
+  }
+  return true;
+}
+
+/**
+ * Detect whether a single prereq is satisfied. Detection NEVER mutates the host.
+ * @param {string} name prereq id
+ * @param {object} prereq manifest prereq entry
+ * @param {object} ctx { run, platform, projectDir }
+ * @returns {{name:string, present:boolean, version:?string, reason:string}}
+ */
+function detectPrereq(name, prereq, ctx) {
+  const run = ctx.run || defaultRun;
+
+  switch (prereq.kind) {
+    case 'secret': {
+      const envVar = SECRET_ENV[name];
+      const present = !!(envVar && process.env[envVar]);
+      return { name, present, version: null, reason: present ? `${envVar} set` : `${envVar} unset` };
+    }
+    case 'venv': {
+      const dir = path.join(ctx.projectDir, '.claude', 'skills', '.venv');
+      const present = fs.existsSync(dir);
+      return { name, present, version: null, reason: present ? 'venv exists' : 'venv missing' };
+    }
+    case 'mcp': {
+      const r = run('claude mcp list');
+      const present = r.code === 0 && /playwright/i.test(r.stdout + r.stderr);
+      return { name, present, version: null, reason: present ? 'mcp registered' : 'mcp not registered' };
+    }
+    case 'note':
+      // Nothing to probe directly; satisfied iff its `needs` are (handled by caller).
+      return { name, present: false, version: null, reason: 'note (self-bootstrap)' };
+    default: {
+      // package
+      if (!prereq.detect) return { name, present: false, version: null, reason: 'no detect command' };
+      let r = run(prereq.detect);
+      if (r.code !== 0 && name === 'python') r = run('python3 --version'); // unix fallback
+      const out = r.stdout + r.stderr;
+      const ver = parseVersion(out);
+      if (r.code !== 0) return { name, present: false, version: null, reason: 'not found' };
+      if (prereq.minVersion && !versionGte(ver, prereq.minVersion)) {
+        return {
+          name,
+          present: false,
+          version: ver ? ver.join('.') : null,
+          reason: `version ${ver ? ver.join('.') : '?'} < required ${prereq.minVersion}`,
+        };
+      }
+      return { name, present: true, version: ver ? ver.join('.') : null, reason: 'present' };
+    }
+  }
+}
+
+module.exports = { detectPrereq, parseVersion, versionGte, defaultRun, SECRET_ENV };

package/src/provisioner/guide.js

@@ -0,0 +1,32 @@
+'use strict';
+
+const { resolveInstallCommand } = require('./os-package-manager');
+const { SECRET_ENV } = require('./detect');
+
+/**
+ * Print a manual-install fallback for a prereq that could not be auto-installed.
+ * @param {string} name
+ * @param {object} prereq
+ * @param {object} ctx
+ */
+function printGuide(name, prereq, ctx) {
+  const log = ctx.log || console.log;
+  if (prereq.kind === 'secret') return printSecretGuide(name, ctx);
+
+  const { command } = resolveInstallCommand(prereq, ctx);
+  log(`  ⚠ Could not auto-install "${name}". Install it manually:`);
+  if (command) log(`      ${command}`);
+  else log(`      (no package-manager command available — see INSTALLATION.md for "${name}")`);
+}
+
+/**
+ * Secrets are never auto-installed: tell the user how to set the env var.
+ */
+function printSecretGuide(name, ctx) {
+  const log = ctx.log || console.log;
+  const envVar = SECRET_ENV[name] || name;
+  log(`  ℹ ${name}: export ${envVar} when you use the scripts that need it (e.g. skill-creator improve/loop).`);
+  log('      musketeer never writes secrets to the repo.');
+}
+
+module.exports = { printGuide, printSecretGuide };

package/src/provisioner/index.js

@@ -0,0 +1,113 @@
+'use strict';
+
+const { detectPrereq } = require('./detect');
+const opm = require('./os-package-manager');
+const { ensureVenv } = require('./venv');
+const { ensurePlaywrightMcp } = require('./mcp');
+const guide = require('./guide');
+
+/**
+ * Order prereq names so that `needs` (deps) come before their dependents
+ * (java before cm-cli, python before venv-anthropic). Stable topo sort.
+ */
+function orderByNeeds(names, manifest) {
+  const set = new Set(names);
+  const out = [];
+  const seen = new Set();
+  function visit(n) {
+    if (seen.has(n)) return;
+    seen.add(n);
+    const p = manifest.prereqs[n];
+    if (p && Array.isArray(p.needs)) {
+      for (const need of p.needs) if (set.has(need)) visit(need);
+    }
+    out.push(n);
+  }
+  for (const n of names) visit(n);
+  return out;
+}
+
+async function consentSudo(name, ctx) {
+  if (!ctx.isInteractive) return true; // CI: attempt (announced); shell sudo may still prompt
+  if (typeof ctx.prompt !== 'function') return true;
+  return !!(await ctx.prompt(`Installing ${name} requires sudo. Proceed?`));
+}
+
+async function ensureOne(name, prereq, ctx) {
+  const log = ctx.log || (() => {});
+  const det = detectPrereq(name, prereq, ctx);
+
+  switch (prereq.kind) {
+    case 'secret':
+      if (!det.present) guide.printGuide(name, prereq, ctx);
+      return { name, ok: det.present, status: det.present ? 'present' : 'guide (secret)' };
+
+    case 'note':
+      log(`  • ${name}: self-bootstraps from Maven on first use (needs: ${(prereq.needs || []).join(', ') || 'none'})`);
+      return { name, ok: true, status: 'note' };
+
+    case 'venv': {
+      if (det.present) return { name, ok: true, status: 'present' };
+      const r = ensureVenv(ctx);
+      if (r.skipped) return { name, ok: false, status: 'skipped' };
+      const ok = r.code === 0;
+      if (!ok) guide.printGuide(name, prereq, ctx);
+      return { name, ok, status: ok ? 'installed' : 'failed → guide' };
+    }
+
+    case 'mcp': {
+      if (det.present) return { name, ok: true, status: 'present' };
+      const r = ensurePlaywrightMcp(ctx);
+      if (r.skipped) return { name, ok: false, status: 'skipped' };
+      const ok = r.code === 0;
+      if (!ok) guide.printGuide(name, prereq, ctx);
+      return { name, ok, status: ok ? 'installed' : 'failed → guide' };
+    }
+
+    default: {
+      // package
+      if (det.present) return { name, ok: true, status: `present (${det.version || 'ok'})` };
+      const { command, needsSudo } = opm.resolveInstallCommand(prereq, ctx);
+      if (!command) {
+        guide.printGuide(name, prereq, ctx);
+        return { name, ok: false, status: 'no installer → guide' };
+      }
+      if (needsSudo && !(await consentSudo(name, ctx))) {
+        guide.printGuide(name, prereq, ctx);
+        return { name, ok: false, status: 'sudo refused → guide' };
+      }
+      const ins = opm.installPackage(name, command, ctx);
+      if (ins.skipped) return { name, ok: false, status: 'skipped' };
+      const re = detectPrereq(name, prereq, ctx);
+      if (!re.present) guide.printGuide(name, prereq, ctx);
+      return { name, ok: re.present, status: re.present ? 'installed' : 'install failed → guide' };
+    }
+  }
+}
+
+/**
+ * Detect + auto-install every prereq required by the desired company.
+ * Partial-success tolerant: a failure prints a guide and never aborts reconcile.
+ * @param {string[]} prereqNames
+ * @param {object} manifest
+ * @param {object} ctx { projectDir, templateDir, platform, run, prompt, isInteractive, log }
+ * @returns {Promise<Array<{name,ok,status}>>}
+ */
+async function ensure(prereqNames, manifest, ctx) {
+  const log = ctx.log || (() => {});
+  const unique = [...new Set(prereqNames)].filter((n) => manifest.prereqs[n]);
+  if (unique.length === 0) return [];
+
+  const ordered = orderByNeeds(unique, manifest);
+  log('Provisioning prerequisites...');
+  const summary = [];
+  for (const name of ordered) {
+    summary.push(await ensureOne(name, manifest.prereqs[name], ctx));
+  }
+
+  log('\nPrereq summary:');
+  for (const s of summary) log(`  ${s.ok ? '✓' : '•'} ${s.name}: ${s.status}`);
+  return summary;
+}
+
+module.exports = { ensure, orderByNeeds, ensureOne };

package/src/provisioner/mcp.js

@@ -0,0 +1,26 @@
+'use strict';
+
+const { defaultRun } = require('./detect');
+
+/**
+ * Register the Playwright MCP via the claude CLI (which owns MCP config) and
+ * install the Chromium browser. Best-effort; failures degrade to a guide.
+ * @param {object} ctx { run, log }
+ * @returns {{ran:boolean, code:number, skipped?:boolean}}
+ */
+function ensurePlaywrightMcp(ctx) {
+  const run = ctx.run || defaultRun;
+  const log = ctx.log || (() => {});
+
+  if (process.env.MUSKETEER_SKIP_INSTALL) {
+    log('  [skip-install] would register Playwright MCP + install Chromium');
+    return { ran: false, code: 0, skipped: true };
+  }
+
+  log('  → registering Playwright MCP (claude mcp add) + installing Chromium (heavy download)');
+  const add = run('claude mcp add playwright -- npx @playwright/mcp@latest');
+  const chromium = run('npx playwright install chromium');
+  return { ran: true, code: add.code === 0 && chromium.code === 0 ? 0 : 1 };
+}
+
+module.exports = { ensurePlaywrightMcp };

package/src/provisioner/os-package-manager.js

@@ -0,0 +1,71 @@
+'use strict';
+
+const { defaultRun } = require('./detect');
+
+/**
+ * Normalize process.platform (or ctx override) to a manifest install key.
+ * @returns {"win"|"mac"|"linux"}
+ */
+function osKey(ctx) {
+  const p = ctx.platform || process.platform;
+  if (p === 'win32') return 'win';
+  if (p === 'darwin') return 'mac';
+  return 'linux';
+}
+
+/**
+ * Detect which Linux package manager is available (apt/dnf/pacman).
+ * Mockable via ctx.run; overridable via ctx.linuxPm.
+ * @returns {?string}
+ */
+function detectLinuxPm(ctx) {
+  if (ctx.linuxPm) return ctx.linuxPm;
+  const run = ctx.run || defaultRun;
+  for (const [pm, probe] of [
+    ['apt', 'apt-get'],
+    ['dnf', 'dnf'],
+    ['pacman', 'pacman'],
+  ]) {
+    const r = run(`command -v ${probe}`);
+    if (r.code === 0 && (r.stdout || '').trim()) return pm;
+  }
+  return null;
+}
+
+/**
+ * Resolve the OS-specific install command string for a prereq, or null when
+ * none applies (note/secret/venv/mcp, or no package manager on Linux).
+ * @returns {{command:?string, needsSudo:boolean, pm:?string}}
+ */
+function resolveInstallCommand(prereq, ctx) {
+  if (!prereq.install) return { command: null, needsSudo: false, pm: null };
+  const key = osKey(ctx);
+  const spec = prereq.install[key];
+  if (spec == null) return { command: null, needsSudo: false, pm: null };
+
+  if (typeof spec === 'string') {
+    return { command: spec, needsSudo: /\bsudo\b/.test(spec), pm: null };
+  }
+  // Linux object keyed by package manager.
+  const pm = detectLinuxPm(ctx);
+  if (!pm || !spec[pm]) return { command: null, needsSudo: false, pm };
+  return { command: spec[pm], needsSudo: /\bsudo\b/.test(spec[pm]), pm };
+}
+
+/**
+ * Run an install command, announced. Honors MUSKETEER_SKIP_INSTALL (dry-run).
+ * @returns {{ran:boolean, code:number, skipped?:boolean}}
+ */
+function installPackage(name, command, ctx) {
+  const run = ctx.run || defaultRun;
+  const log = ctx.log || (() => {});
+  if (process.env.MUSKETEER_SKIP_INSTALL) {
+    log(`  [skip-install] would run: ${command}`);
+    return { ran: false, code: 0, skipped: true };
+  }
+  log(`  → installing ${name}: ${command}`);
+  const r = run(command);
+  return { ran: true, code: r.code };
+}
+
+module.exports = { osKey, detectLinuxPm, resolveInstallCommand, installPackage };

package/src/provisioner/venv.js

@@ -0,0 +1,44 @@
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+const { defaultRun } = require('./detect');
+
+/**
+ * Create the skills venv + install `anthropic` by invoking the shipped
+ * orchestrator (install.ps1 on Windows, install.sh elsewhere). Prefers the copy
+ * inside the project's .claude/skills; falls back to the package template.
+ * @param {object} ctx { run, log, platform, projectDir, templateDir, isInteractive }
+ * @returns {{ran:boolean, code:number, skipped?:boolean, reason?:string}}
+ */
+function ensureVenv(ctx) {
+  const run = ctx.run || defaultRun;
+  const log = ctx.log || (() => {});
+  const isWin = (ctx.platform || process.platform) === 'win32';
+  const script = isWin ? 'install.ps1' : 'install.sh';
+
+  let scriptPath = path.join(ctx.projectDir, '.claude', 'skills', script);
+  if (!fs.existsSync(scriptPath) && ctx.templateDir) {
+    const alt = path.join(ctx.templateDir, 'skills', script);
+    if (fs.existsSync(alt)) scriptPath = alt;
+  }
+  if (!fs.existsSync(scriptPath)) {
+    log(`  venv orchestrator not found (${script}); skipping`);
+    return { ran: false, code: 1, reason: 'orchestrator missing' };
+  }
+
+  if (process.env.MUSKETEER_SKIP_INSTALL) {
+    log(`  [skip-install] would run ${script}`);
+    return { ran: false, code: 0, skipped: true };
+  }
+
+  const yes = ctx.isInteractive ? '' : ' --yes';
+  const cmd = isWin
+    ? `powershell -NoProfile -ExecutionPolicy Bypass -File "${scriptPath}"${yes}`
+    : `bash "${scriptPath}"${yes}`;
+  log(`  → creating skills venv via ${script}`);
+  const r = run(cmd);
+  return { ran: true, code: r.code };
+}
+
+module.exports = { ensureVenv };

package/src/reconcile.js

@@ -0,0 +1,94 @@
+'use strict';
+
+const { loadManifest, templateClaudeDir } = require('./manifest-loader');
+const { resolveClosure, CORE_ID } = require('./resolver');
+const { readLockfile, writeLockfile } = require('./lockfile');
+const copier = require('./copier');
+const settingsMerger = require('./settings-merger');
+const provisioner = require('./provisioner');
+
+/**
+ * Build the default dependency set. Tests override any of these (manifest,
+ * templateDir, muster, provisioner, log, now) to stay hermetic.
+ */
+function defaultDeps() {
+  return {
+    manifest: loadManifest(),
+    templateDir: templateClaudeDir(),
+    settingsMerger,
+    provisioner,
+    muster: require('./muster'),
+    now: () => new Date().toISOString(),
+    log: (m) => process.stdout.write(m + '\n'),
+  };
+}
+
+/**
+ * The ONE idempotent command: resolve desired company → diff vs lockfile →
+ * copy/remove files → regenerate settings.json → provision prereqs → write lockfile.
+ * @param {{desiredIds:?string[], interactive:boolean, projectDir?:string}} opts
+ * @param {object} [overrides] dependency injection for tests
+ */
+async function run(opts, overrides = {}) {
+  const { desiredIds, interactive } = opts;
+  const projectDir = opts.projectDir || process.cwd();
+  const d = { ...defaultDeps(), ...overrides };
+  const manifest = d.manifest;
+
+  const prev = readLockfile(projectDir);
+
+  let chosen = desiredIds;
+  if (interactive) {
+    chosen = await d.muster.pick(manifest, prev, d);
+    if (chosen === null) {
+      d.log('Cancelled — no changes made.');
+      return;
+    }
+  }
+
+  const desired = resolveClosure(manifest, chosen || [], d.templateDir);
+  const plan = copier.planFiles(prev.files, desired.files);
+
+  d.log(`Company: ${desired.ids.join(', ')}`);
+  d.log(`Files: ${plan.copy.length} managed, ${plan.remove.length} to remove.`);
+
+  copier.apply(plan, d.templateDir, projectDir);
+  d.settingsMerger.generate(desired, projectDir);
+
+  await d.provisioner.ensure(desired.prereqs, manifest, {
+    projectDir,
+    templateDir: d.templateDir,
+    isInteractive: !!interactive,
+    log: d.log,
+    prompt: d.prompt,
+    run: d.run,
+    platform: d.platform,
+  });
+
+  writeLockfile(projectDir, {
+    musketeers: desired.ids,
+    files: desired.files,
+    updatedAt: d.now(),
+  });
+  d.log('Done. Your .claude/ company is reconciled.');
+}
+
+/**
+ * Print current company + all available musketeers (no UI).
+ */
+async function list(opts = {}, overrides = {}) {
+  const projectDir = opts.projectDir || process.cwd();
+  const d = { ...defaultDeps(), ...overrides };
+  const prev = readLockfile(projectDir);
+  const company = new Set(prev.musketeers.length ? prev.musketeers : []);
+
+  d.log(`Current company: ${prev.musketeers.length ? prev.musketeers.join(', ') : '(none installed yet)'}`);
+  d.log('\nAvailable musketeers:');
+  for (const [id, m] of Object.entries(d.manifest.musketeers)) {
+    const mark = company.has(id) || id === CORE_ID ? '[x]' : '[ ]';
+    const lock = m.locked ? ' (locked)' : m.defaultChecked ? '' : ' (opt-in)';
+    d.log(`  ${mark} ${id}${lock} — ${m.description}`);
+  }
+}
+
+module.exports = { run, list, defaultDeps };

package/src/resolver.js

@@ -0,0 +1,130 @@
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+
+const CORE_ID = 'core';
+
+/**
+ * Recursively list every file under `root`, returned as POSIX-style paths
+ * relative to `root` (forward slashes, stable sorted).
+ * @param {string} root
+ * @returns {string[]}
+ */
+function listFiles(root) {
+  const out = [];
+  function walk(dir) {
+    let entries;
+    try {
+      entries = fs.readdirSync(dir, { withFileTypes: true });
+    } catch {
+      return;
+    }
+    for (const e of entries) {
+      const abs = path.join(dir, e.name);
+      if (e.isDirectory()) walk(abs);
+      else if (e.isFile()) out.push(path.relative(root, abs).split(path.sep).join('/'));
+    }
+  }
+  walk(root);
+  return out.sort();
+}
+
+/**
+ * Match one glob pattern against a list of relative POSIX paths.
+ * Supported forms (KISS — no full glob engine needed):
+ *   "a/b/**"  → every file at or below a/b
+ *   "a/b/*"   → direct file children of a/b
+ *   "a/b.js"  → exact file
+ * @param {string} pattern
+ * @param {string[]} files
+ * @returns {string[]} matched files
+ */
+function matchGlob(pattern, files) {
+  const p = pattern.split(path.sep).join('/');
+  if (p.endsWith('/**')) {
+    const prefix = p.slice(0, -3); // drop "/**"
+    return files.filter((f) => f === prefix || f.startsWith(prefix + '/'));
+  }
+  if (p.endsWith('/*')) {
+    const prefix = p.slice(0, -2);
+    return files.filter((f) => {
+      if (!f.startsWith(prefix + '/')) return false;
+      return !f.slice(prefix.length + 1).includes('/');
+    });
+  }
+  return files.filter((f) => f === p);
+}
+
+/**
+ * Expand a musketeer's `files` globs to concrete relative paths.
+ * @param {object} musketeer
+ * @param {string[]} templateFiles
+ * @returns {string[]}
+ */
+function expandFiles(musketeer, templateFiles) {
+  const set = new Set();
+  for (const glob of musketeer.files) {
+    for (const f of matchGlob(glob, templateFiles)) set.add(f);
+  }
+  return [...set];
+}
+
+/**
+ * Resolve the desired company into a concrete install plan.
+ * Desired = {core} ∪ requested, with intra-package `deps` expanded transitively.
+ *
+ * @param {object} manifest validated manifest
+ * @param {string[]} requestedIds musketeer ids the user wants (core auto-added)
+ * @param {string} templateDir absolute path to template/.claude
+ * @returns {{ids:string[], files:string[], prereqs:string[], settings:object[]}}
+ */
+function resolveClosure(manifest, requestedIds, templateDir) {
+  const known = manifest.musketeers;
+  const wanted = new Set([CORE_ID]);
+
+  // Validate + seed
+  for (const id of requestedIds || []) {
+    if (!known[id]) {
+      const valid = Object.keys(known).join(', ');
+      throw new Error(`Unknown musketeer "${id}". Valid: ${valid}`);
+    }
+    wanted.add(id);
+  }
+
+  // Transitive dep closure (empty for all v1 musketeers, kept for extensibility).
+  let changed = true;
+  while (changed) {
+    changed = false;
+    for (const id of [...wanted]) {
+      for (const dep of known[id].deps) {
+        if (!wanted.has(dep)) {
+          wanted.add(dep);
+          changed = true;
+        }
+      }
+    }
+  }
+
+  const templateFiles = listFiles(templateDir);
+  const ids = [...wanted].sort((a, b) => (a === CORE_ID ? -1 : b === CORE_ID ? 1 : a.localeCompare(b)));
+
+  const files = new Set();
+  const prereqs = new Set();
+  const settings = [];
+  for (const id of ids) {
+    const m = known[id];
+    for (const f of expandFiles(m, templateFiles)) files.add(f);
+    for (const pr of m.prereqs) prereqs.add(pr);
+    for (const frag of m.settings) settings.push({ ...frag, musketeer: id });
+  }
+
+  return {
+    ids,
+    files: [...files].sort(),
+    prereqs: [...prereqs],
+    settings,
+  };
+}
+
+module.exports = { resolveClosure, listFiles, matchGlob, expandFiles, CORE_ID };