@phuc1403/musketeer 0.4.0 → 0.6.0

package/package.json

@@ -1,46 +1,46 @@
-{
-  "name": "@phuc1403/musketeer",
-  "version": "0.4.0",
-  "description": "Distributable custom Claude Code harness — one declarative command scaffolds a curated company of musketeers (skills/agents/hooks) into any project's .claude/.",
-  "type": "commonjs",
-  "bin": {
-    "musketeer": "bin/musketeer.js"
-  },
-  "engines": {
-    "node": ">=18"
-  },
-  "scripts": {
-    "test": "node --test"
-  },
-  "files": [
-    "bin",
-    "src",
-    "manifest.json",
-    "template",
-    "README.md",
-    "INSTALLATION.md",
-    "LICENSE"
-  ],
-  "keywords": [
-    "claude",
-    "claude-code",
-    "harness",
-    "scaffolder",
-    "cli",
-    "skills",
-    "agents",
-    "hooks"
-  ],
-  "license": "MIT",
-  "repository": {
-    "type": "git",
-    "url": "git+https://github.com/phamhongphuc1403/musketeer.git"
-  },
-  "bugs": {
-    "url": "https://github.com/phamhongphuc1403/musketeer/issues"
-  },
-  "homepage": "https://github.com/phamhongphuc1403/musketeer#readme",
-  "dependencies": {
-    "@clack/prompts": "^0.7.0"
-  }
-}
+{
+  "name": "@phuc1403/musketeer",
+  "version": "0.6.0",
+  "description": "Distributable custom Claude Code harness — one declarative command scaffolds a curated company of musketeers (skills/agents/hooks) into any project's .claude/.",
+  "type": "commonjs",
+  "bin": {
+    "musketeer": "bin/musketeer.js"
+  },
+  "engines": {
+    "node": ">=18"
+  },
+  "scripts": {
+    "test": "node --test"
+  },
+  "files": [
+    "bin",
+    "src",
+    "manifest.json",
+    "template",
+    "README.md",
+    "INSTALLATION.md",
+    "LICENSE"
+  ],
+  "keywords": [
+    "claude",
+    "claude-code",
+    "harness",
+    "scaffolder",
+    "cli",
+    "skills",
+    "agents",
+    "hooks"
+  ],
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/phamhongphuc1403/musketeer.git"
+  },
+  "bugs": {
+    "url": "https://github.com/phamhongphuc1403/musketeer/issues"
+  },
+  "homepage": "https://github.com/phamhongphuc1403/musketeer#readme",
+  "dependencies": {
+    "@clack/prompts": "^0.7.0"
+  }
+}

package/src/dotnet-scaffold-copier.js

@@ -1,72 +1,72 @@
-'use strict';
-
-const fs = require('fs');
-const path = require('path');
-
-function containedPath(root, candidate) {
-  const resolvedRoot = path.resolve(root);
-  const resolved = path.resolve(candidate);
-  if (resolved !== resolvedRoot && !resolved.startsWith(resolvedRoot + path.sep)) return null;
-  return resolved;
-}
-
-function substitute(text, token, replacement) {
-  return text.split(token).join(replacement);
-}
-
-/**
- * Recursively copy every file under srcDir into stagingDir, substituting
- * `token` with `replacement` in both path segments and file contents. Every
- * computed destination path is validated to stay under `stagingDir` — rejects
- * (throws) rather than writing outside it.
- * @param {string} srcDir
- * @param {string} stagingDir
- * @param {string} token
- * @param {string} replacement
- */
-function copyTemplateWithTokenSubstitution(srcDir, stagingDir, token, replacement) {
-  walk(srcDir, stagingDir, stagingDir, token, replacement);
-}
-
-function walk(currentSrc, currentDest, stagingRoot, token, replacement) {
-  const entries = fs.readdirSync(currentSrc, { withFileTypes: true });
-  for (const entry of entries) {
-    const substitutedName = substitute(entry.name, token, replacement);
-    const srcPath = path.join(currentSrc, entry.name);
-    const destPath = containedPath(stagingRoot, path.join(currentDest, substitutedName));
-    if (!destPath) {
-      throw new Error(`copyTemplateWithTokenSubstitution: computed path escapes staging dir: "${substitutedName}"`);
-    }
-
-    if (entry.isDirectory()) {
-      fs.mkdirSync(destPath, { recursive: true });
-      walk(srcPath, destPath, stagingRoot, token, replacement);
-    } else if (entry.isFile()) {
-      fs.mkdirSync(path.dirname(destPath), { recursive: true });
-      const content = fs.readFileSync(srcPath, 'utf8');
-      fs.writeFileSync(destPath, substitute(content, token, replacement), 'utf8');
-    }
-  }
-}
-
-/**
- * Move every top-level entry from stagingDir into projectDir. Pre-checks all
- * names for collisions before moving any of them, then moves each via
- * fs.renameSync (atomic per entry on the same filesystem). Throws instead of
- * silently overwriting if a destination name already exists.
- * @param {string} stagingDir
- * @param {string} projectDir
- */
-function promoteStagedScaffold(stagingDir, projectDir) {
-  const entries = fs.readdirSync(stagingDir, { withFileTypes: true });
-  for (const entry of entries) {
-    if (fs.existsSync(path.join(projectDir, entry.name))) {
-      throw new Error(`promoteStagedScaffold: "${entry.name}" already exists at destination`);
-    }
-  }
-  for (const entry of entries) {
-    fs.renameSync(path.join(stagingDir, entry.name), path.join(projectDir, entry.name));
-  }
-}
-
-module.exports = { copyTemplateWithTokenSubstitution, promoteStagedScaffold };
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+
+function containedPath(root, candidate) {
+  const resolvedRoot = path.resolve(root);
+  const resolved = path.resolve(candidate);
+  if (resolved !== resolvedRoot && !resolved.startsWith(resolvedRoot + path.sep)) return null;
+  return resolved;
+}
+
+function substitute(text, token, replacement) {
+  return text.split(token).join(replacement);
+}
+
+/**
+ * Recursively copy every file under srcDir into stagingDir, substituting
+ * `token` with `replacement` in both path segments and file contents. Every
+ * computed destination path is validated to stay under `stagingDir` — rejects
+ * (throws) rather than writing outside it.
+ * @param {string} srcDir
+ * @param {string} stagingDir
+ * @param {string} token
+ * @param {string} replacement
+ */
+function copyTemplateWithTokenSubstitution(srcDir, stagingDir, token, replacement) {
+  walk(srcDir, stagingDir, stagingDir, token, replacement);
+}
+
+function walk(currentSrc, currentDest, stagingRoot, token, replacement) {
+  const entries = fs.readdirSync(currentSrc, { withFileTypes: true });
+  for (const entry of entries) {
+    const substitutedName = substitute(entry.name, token, replacement);
+    const srcPath = path.join(currentSrc, entry.name);
+    const destPath = containedPath(stagingRoot, path.join(currentDest, substitutedName));
+    if (!destPath) {
+      throw new Error(`copyTemplateWithTokenSubstitution: computed path escapes staging dir: "${substitutedName}"`);
+    }
+
+    if (entry.isDirectory()) {
+      fs.mkdirSync(destPath, { recursive: true });
+      walk(srcPath, destPath, stagingRoot, token, replacement);
+    } else if (entry.isFile()) {
+      fs.mkdirSync(path.dirname(destPath), { recursive: true });
+      const content = fs.readFileSync(srcPath, 'utf8');
+      fs.writeFileSync(destPath, substitute(content, token, replacement), 'utf8');
+    }
+  }
+}
+
+/**
+ * Move every top-level entry from stagingDir into projectDir. Pre-checks all
+ * names for collisions before moving any of them, then moves each via
+ * fs.renameSync (atomic per entry on the same filesystem). Throws instead of
+ * silently overwriting if a destination name already exists.
+ * @param {string} stagingDir
+ * @param {string} projectDir
+ */
+function promoteStagedScaffold(stagingDir, projectDir) {
+  const entries = fs.readdirSync(stagingDir, { withFileTypes: true });
+  for (const entry of entries) {
+    if (fs.existsSync(path.join(projectDir, entry.name))) {
+      throw new Error(`promoteStagedScaffold: "${entry.name}" already exists at destination`);
+    }
+  }
+  for (const entry of entries) {
+    fs.renameSync(path.join(stagingDir, entry.name), path.join(projectDir, entry.name));
+  }
+}
+
+module.exports = { copyTemplateWithTokenSubstitution, promoteStagedScaffold };

package/src/provisioner/detect.js

@@ -1,93 +1,113 @@
-'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 };
+'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) {
+  // An array is an argv, spawned without a shell. Windows quoting cannot be
+  // trusted to survive a nested `bash -lc "..."` inside cmd.exe, so probes that
+  // need a shell of their own pass their arguments already separated.
+  const r = Array.isArray(cmd)
+    ? spawnSync(cmd[0], cmd.slice(1), { encoding: 'utf8', windowsHide: true })
+    : spawnSync(cmd, { shell: true, encoding: 'utf8', windowsHide: true });
+  return {
+    code: typeof r.status === 'number' ? r.status : 1,
+    stdout: r.stdout || '',
+    stderr: r.stderr || '',
+  };
+}
+
+/**
+ * Probe for a prereq whose manifest entry sets `detectShell: "bash"`.
+ * adr-tools ships as bash scripts living in Git's own `usr/bin`, which Windows
+ * cannot see or execute: `adr config` fails there while working fine in Git
+ * Bash. Probing through the same shell the ADR hooks use stops muster reporting
+ * a tool that is installed as missing.
+ * @param {string} detect
+ * @returns {string[]} argv
+ */
+function bashProbe(detect) {
+  return [process.env.CLAUDE_CODE_GIT_BASH_PATH || 'bash', '-lc', detect];
+}
+
+/** 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.detectShell === 'bash' ? bashProbe(prereq.detect) : prereq.detect);
+      // A shell-script tool invisible to Windows still answers through Git Bash.
+      if (r.code !== 0 && prereq.detectShell === 'bash') 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, bashProbe, SECRET_ENV };

package/src/self-update.js

@@ -1,73 +1,77 @@
-'use strict';
-
-// Self-update gate for `musketeer muster`. Before the picker applies the bundled
-// template, make sure the CLI is at the latest PUBLISHED version — otherwise
-// "muster" would refresh installed skills to a stale package's template.
-//
-// When behind: promote (npm i -g @latest), then re-exec `musketeer muster` so the
-// picker runs under the freshly-installed template. A running Node process can't
-// reliably hot-swap its own package files mid-run, so re-exec is the safe path.
-//
-// Guards:
-//   MUSKETEER_REEXEC=1        set on the child so it never re-checks (no loop)
-//   MUSKETEER_NO_SELF_UPDATE=1 user opt-out (offline / pinned version)
-
-const { spawnSync } = require('child_process');
-const { fetchLatest, compareVersions, defaultRun } = require('./promote');
-const pkg = require('../package.json');
-
-/**
- * Decide whether muster should self-update first. Pure — injectable exec/env.
- * @param {{exec?:Function, current?:string, name?:string, env?:object}} [o]
- * @returns {{action:'proceed'|'update', latest:?string}}
- */
-function decide(o = {}) {
-  const exec = o.exec || defaultRun;
-  const current = o.current || pkg.version;
-  const name = o.name || pkg.name;
-  const env = o.env || process.env;
-
-  if (env.MUSKETEER_REEXEC === '1' || env.MUSKETEER_NO_SELF_UPDATE === '1') {
-    return { action: 'proceed', latest: null };
-  }
-  const latest = fetchLatest(exec, name);
-  if (!latest) return { action: 'proceed', latest: null }; // offline / unknown — proceed as-is
-  if (compareVersions(latest, current) <= 0) return { action: 'proceed', latest }; // already latest
-  return { action: 'update', latest };
-}
-
-/**
- * Ensure the CLI is latest before muster applies the template.
- * @param {object} [io] injectable { log, exec, spawn, env, name, current } for tests
- * @returns {?number} an exit code if it re-exec'd a fresh muster (caller should
- *   exit with it); null to mean "proceed in-process".
- */
-function ensureLatest(io = {}) {
-  const log = io.log || ((m) => process.stdout.write(m + '\n'));
-  const exec = io.exec || defaultRun;
-  const spawn = io.spawn || spawnSync;
-  const env = io.env || process.env;
-  const name = io.name || pkg.name;
-  const current = io.current || pkg.version;
-
-  const d = decide({ exec, current, name, env });
-  if (d.action === 'proceed') return null;
-
-  log(`Updating musketeer ${current} → ${d.latest} before muster…`);
-  const ins = exec(`npm i -g ${name}@latest`);
-  if (ins.code !== 0) {
-    log('Self-update failed — continuing with the current version.');
-    if (ins.stderr) log(ins.stderr.trim());
-    return null;
-  }
-
-  // Re-exec the now-latest binary's muster, inheriting the TTY for the picker.
-  const r = spawn('musketeer', ['muster'], {
-    stdio: 'inherit',
-    shell: true,
-    env: { ...env, MUSKETEER_REEXEC: '1' },
-  });
-  return typeof r.status === 'number' ? r.status : 0;
-}
-
-module.exports = { decide, ensureLatest };
+'use strict';
+
+// Self-update gate for `musketeer muster`. Before the picker applies the bundled
+// template, make sure the CLI is at the latest PUBLISHED version — otherwise
+// "muster" would refresh installed skills to a stale package's template.
+//
+// When behind: promote (npm i -g @latest), then re-exec `musketeer muster` so the
+// picker runs under the freshly-installed template. A running Node process can't
+// reliably hot-swap its own package files mid-run, so re-exec is the safe path.
+//
+// Guards:
+//   MUSKETEER_REEXEC=1        set on the child so it never re-checks (no loop)
+//   MUSKETEER_NO_SELF_UPDATE=1 user opt-out (offline / pinned version)
+
+const { spawnSync } = require('child_process');
+const { fetchLatest, compareVersions, defaultRun } = require('./promote');
+const pkg = require('../package.json');
+
+/**
+ * Decide whether muster should self-update first. Pure — injectable exec/env.
+ * @param {{exec?:Function, current?:string, name?:string, env?:object}} [o]
+ * @returns {{action:'proceed'|'update', latest:?string}}
+ */
+function decide(o = {}) {
+  const exec = o.exec || defaultRun;
+  const current = o.current || pkg.version;
+  const name = o.name || pkg.name;
+  const env = o.env || process.env;
+
+  if (env.MUSKETEER_REEXEC === '1' || env.MUSKETEER_NO_SELF_UPDATE === '1') {
+    return { action: 'proceed', latest: null };
+  }
+  const latest = fetchLatest(exec, name);
+  if (!latest) return { action: 'proceed', latest: null }; // offline / unknown — proceed as-is
+  if (compareVersions(latest, current) <= 0) return { action: 'proceed', latest }; // already latest
+  return { action: 'update', latest };
+}
+
+/**
+ * Ensure the CLI is latest before muster applies the template.
+ * @param {object} [io] injectable { log, exec, spawn, env, name, current } for tests
+ * @returns {?number} an exit code if it re-exec'd a fresh muster (caller should
+ *   exit with it); null to mean "proceed in-process".
+ */
+function ensureLatest(io = {}) {
+  const log = io.log || ((m) => process.stdout.write(m + '\n'));
+  const exec = io.exec || defaultRun;
+  const spawn = io.spawn || spawnSync;
+  const env = io.env || process.env;
+  const name = io.name || pkg.name;
+  const current = io.current || pkg.version;
+
+  const d = decide({ exec, current, name, env });
+  if (d.action === 'proceed') return null;
+
+  log(`Updating musketeer ${current} → ${d.latest} before muster…`);
+  const ins = exec(`npm i -g ${name}@latest`);
+  if (ins.code !== 0) {
+    log('Self-update failed — continuing with the current version.');
+    if (ins.stderr) log(ins.stderr.trim());
+    return null;
+  }
+
+  // Re-exec the now-latest binary's muster, inheriting the TTY for the picker.
+  // The caller's flags come along: dropping them here would send a scripted
+  // `muster --keep` back to the interactive picker, which is the one place it
+  // cannot run.
+  const args = io.args || [];
+  const r = spawn('musketeer', ['muster', ...args], {
+    stdio: 'inherit',
+    shell: true,
+    env: { ...env, MUSKETEER_REEXEC: '1' },
+  });
+  return typeof r.status === 'number' ? r.status : 0;
+}
+
+module.exports = { decide, ensureLatest };