wyvrnpm 2.0.4 → 2.3.2

package/src/commands/build.js

@@ -0,0 +1,283 @@
+'use strict';
+
+const fs   = require('fs');
+const path = require('path');
+const { spawn } = require('child_process');
+
+const { readConfig }   = require('../config');
+const { loadProfile }  = require('../profile');
+const { readManifest } = require('../manifest');
+const { normalizeRecipe, hasBuildRecipe } = require('../build/recipe');
+const { loadMsvcEnv }  = require('../build/msvc-env');
+const install          = require('./install');
+const log              = require('../logger');
+
+// ---------------------------------------------------------------------------
+// Pure helpers (unit-testable — no process spawning, no filesystem writes)
+// ---------------------------------------------------------------------------
+
+/**
+ * Decide whether `wyvrn install` must run before build.
+ *
+ *   - toolchain-missing : wyvrn_toolchain.cmake does not exist → definitely stale.
+ *   - lock-newer        : wyvrn.lock was modified after the toolchain was written,
+ *                         so the toolchain's package list is out of date.
+ *   - fresh             : no action needed.
+ *
+ * @param {{ rootDir: string, manifestPath: string }} args
+ * @returns {{ stale: boolean, reason: string }}
+ */
+function isToolchainStale({ rootDir, manifestPath }) {
+  const lockPath      = path.join(path.dirname(manifestPath), 'wyvrn.lock');
+  const toolchainPath = path.join(rootDir, 'wyvrn_internal', 'wyvrn_toolchain.cmake');
+
+  if (!fs.existsSync(toolchainPath)) {
+    return { stale: true, reason: 'toolchain-missing' };
+  }
+  if (!fs.existsSync(lockPath)) {
+    return { stale: false, reason: 'no-lock' };
+  }
+
+  const lockMtime      = fs.statSync(lockPath).mtimeMs;
+  const toolchainMtime = fs.statSync(toolchainPath).mtimeMs;
+  if (lockMtime > toolchainMtime) {
+    return { stale: true, reason: 'lock-newer-than-toolchain' };
+  }
+  return { stale: false, reason: 'fresh' };
+}
+
+/**
+ * Resolve the configure preset name from CLI override or profile convention.
+ *
+ * @param {{ presetOverride?: string, profileName: string }} args
+ * @returns {string}
+ */
+function resolvePresetName({ presetOverride, profileName }) {
+  if (presetOverride) return presetOverride;
+  return `wyvrn-${profileName}`;
+}
+
+/**
+ * Compute the build directory for a preset, matching the pattern emitted
+ * by [src/toolchain/presets.js](../toolchain/presets.js) — `${sourceDir}/build/<preset>`.
+ *
+ * @param {{ rootDir: string, presetName: string }} args
+ * @returns {string}
+ */
+function resolveBinaryDir({ rootDir, presetName }) {
+  return path.join(rootDir, 'build', presetName);
+}
+
+/**
+ * Args passed to `cmake` for the configure step.
+ * @param {{ presetName: string }} args
+ * @returns {string[]}
+ */
+function buildConfigureArgs({ presetName }) {
+  return ['--preset', presetName];
+}
+
+/**
+ * Args passed to `cmake` for the build step.
+ *
+ * @param {{
+ *   binaryDir: string,
+ *   config:    string,
+ *   target?:   string,
+ *   verbose?:  boolean,
+ *   passthru?: string[],
+ * }} args
+ * @returns {string[]}
+ */
+function buildBuildArgs({ binaryDir, config, target, verbose, passthru = [] }) {
+  const args = ['--build', binaryDir, '--config', config];
+  if (verbose) args.push('--verbose');
+  if (target)  args.push('--target', target);
+  if (passthru.length > 0) args.push('--', ...passthru);
+  return args;
+}
+
+/**
+ * Args passed to `cmake --install` for the install step.
+ *
+ * @param {{
+ *   binaryDir: string,
+ *   config:    string,
+ *   prefix?:   string,   // override CMAKE_INSTALL_PREFIX at install time
+ * }} args
+ * @returns {string[]}
+ */
+function buildInstallArgs({ binaryDir, config, prefix }) {
+  const args = ['--install', binaryDir, '--config', config];
+  if (prefix) args.push('--prefix', prefix);
+  return args;
+}
+
+// ---------------------------------------------------------------------------
+// Spawn wrapper
+// ---------------------------------------------------------------------------
+
+/**
+ * Run `cmake` with the given args. Inherits stdio for real-time output.
+ * Rejects if the process exits non-zero or fails to spawn.
+ *
+ * When `env` is provided, it replaces the ambient environment (used to
+ * activate MSVC via vcvarsall for non-VS generators on Windows).
+ *
+ * @param {string[]} args
+ * @param {NodeJS.ProcessEnv|null} [env]
+ * @returns {Promise<void>}
+ */
+function runCmake(args, env = null) {
+  return new Promise((resolve, reject) => {
+    const opts = { stdio: 'inherit' };
+    if (env) opts.env = env;
+    const proc = spawn('cmake', args, opts);
+    proc.on('error', (err) => {
+      reject(new Error(
+        `Failed to spawn cmake: ${err.message}\n` +
+        '  Is CMake installed and on PATH?',
+      ));
+    });
+    proc.on('close', (code) => {
+      if (code === 0) resolve();
+      else reject(new Error(`cmake ${args.join(' ')} exited with code ${code}`));
+    });
+  });
+}
+
+// ---------------------------------------------------------------------------
+// Command entry
+// ---------------------------------------------------------------------------
+
+/**
+ * `wyvrnpm build` — configure + build via the generated CMake preset.
+ *
+ * Defaults:
+ *   - preset : `wyvrn-<profileName>` (from --profile or config.defaultProfile)
+ *   - config : Release
+ *   - auto-install when toolchain is missing / older than wyvrn.lock
+ *
+ * @param {object} argv
+ */
+async function build(argv) {
+  const rootDir      = path.resolve(argv.root);
+  const manifestPath = path.resolve(argv.manifest);
+
+  const config      = readConfig();
+  const profileName = argv.profile ?? config.defaultProfile ?? 'default';
+  const presetName  = resolvePresetName({ presetOverride: argv.preset, profileName });
+  const buildConfig = argv.config ?? 'Release';
+
+  // ── Stale check / auto-install ────────────────────────────────────────────
+  // `--auto-install` gates the "run `wyvrnpm install` first when the
+  // toolchain is missing or older than wyvrn.lock" behaviour. The separate
+  // `--install` flag below runs `cmake --install` AFTER build; the two are
+  // deliberately distinct concepts.
+  const staleness = isToolchainStale({ rootDir, manifestPath });
+  if (staleness.stale) {
+    if (argv.autoInstall === false) {
+      log.error(
+        `toolchain is stale (${staleness.reason}) and --no-auto-install was passed.\n` +
+        '  Run: wyvrnpm install',
+      );
+      process.exit(1);
+    }
+    log.info(`Toolchain ${staleness.reason} — running install first`);
+    await install({
+      manifest: argv.manifest,
+      root:     argv.root,
+      profile:  argv.profile,
+      source:   argv.source,
+      platform: argv.platform ?? 'win_x64',
+      timeout:  argv.timeout  ?? 300,
+    });
+  }
+
+  const binaryDir = resolveBinaryDir({ rootDir, presetName });
+
+  // ── Clean ─────────────────────────────────────────────────────────────────
+  if (argv.clean && fs.existsSync(binaryDir)) {
+    log.info(`Removing ${binaryDir}`);
+    fs.rmSync(binaryDir, { recursive: true, force: true });
+  }
+
+  // ── MSVC env activation (Windows + non-VS generator) ───────────────────
+  // When the preset's generator is Ninja / Ninja Multi-Config / Make / etc.
+  // and the active profile is MSVC, we need `vcvarsall.bat` to have been
+  // sourced — otherwise cmake's compiler detection fails with "CXX compiler
+  // identification is unknown". VS generators sidestep this because MSBuild
+  // finds MSVC via its own toolset resolution.
+  //
+  // Same mechanism the source-build path already uses (src/build/msvc-env.js).
+  let cmakeEnv = null;
+  try {
+    const { profile: activeProfile } = loadProfile(profileName);
+    // Which generator will the preset actually use? Read it from the
+    // project's own recipe if one exists. If not, default to null and let
+    // cmake/CMakePresets decide — in which case MSVC env activation is
+    // skipped (because VS is usually the default on Windows).
+    const manifest = readManifest(manifestPath);
+    let presetGenerator = null;
+    if (hasBuildRecipe(manifest)) {
+      try {
+        const recipe = normalizeRecipe(manifest.build, null);
+        if (recipe.generators.length > 0) [presetGenerator] = recipe.generators;
+      } catch { /* templates need options → skip env activation */ }
+    }
+    cmakeEnv = await loadMsvcEnv({
+      profile:          activeProfile,
+      skipForGenerator: presetGenerator,
+    });
+  } catch (err) {
+    log.warn(`Could not resolve MSVC env activation: ${err.message}`);
+  }
+
+  // ── Configure ─────────────────────────────────────────────────────────────
+  const configureArgs = buildConfigureArgs({ presetName });
+  log.info(`cmake ${configureArgs.join(' ')}`);
+  await runCmake(configureArgs, cmakeEnv);
+
+  // ── Build ─────────────────────────────────────────────────────────────────
+  const buildArgs = buildBuildArgs({
+    binaryDir,
+    config:   buildConfig,
+    target:   argv.target,
+    verbose:  argv.verbose,
+    passthru: argv['--'] ?? [],
+  });
+  log.info(`cmake ${buildArgs.join(' ')}`);
+  await runCmake(buildArgs, cmakeEnv);
+
+  // ── Install (optional) ────────────────────────────────────────────────────
+  // `--install` runs `cmake --install <binaryDir>` after the build. Prefix
+  // defaults to whatever was baked into the cache at configure time; pass
+  // `--install-prefix` to override without reconfiguring.
+  if (argv.install) {
+    const installArgs = buildInstallArgs({
+      binaryDir,
+      config: buildConfig,
+      prefix: argv.installPrefix,
+    });
+    log.info(`cmake ${installArgs.join(' ')}`);
+    await runCmake(installArgs, cmakeEnv);
+  }
+
+  const suffix = argv.install
+    ? ` + installed${argv.installPrefix ? ` to ${argv.installPrefix}` : ''}`
+    : '';
+  log.success(`Build complete: ${binaryDir} (${buildConfig})${suffix}`);
+}
+
+module.exports = build;
+module.exports.default = build;
+
+// Exported for unit tests
+module.exports._helpers = {
+  isToolchainStale,
+  resolvePresetName,
+  resolveBinaryDir,
+  buildConfigureArgs,
+  buildBuildArgs,
+  buildInstallArgs,
+};

package/src/commands/clean.js

@@ -3,37 +3,77 @@
 const fs = require('fs');
 const path = require('path');
 
+const {
+  clearBuildCache,
+  getBuildCacheRoot,
+  clearUploadSidecars,
+} = require('../build/cache');
+const log = require('../logger');
+
 /**
- * Removes the wyvrn_internal/ package cache directory and the wyvrn.lock file.
+ * Removes the project's `wyvrn_internal/` package cache and `wyvrn.lock` file.
+ * With `--build-cache`, also clears the machine-wide source-build cache
+ * under `%LOCALAPPDATA%\wyvrnpm\bc\` (shared across projects).
+ *
+ * `--uploaded-built` wipes just the consumer's local RECORD of what they
+ * have uploaded via `wyvrnpm install --build=missing --upload-built` (the
+ * `.uploaded-to.json` sidecars under the build cache). It does NOT touch
+ * the registry, the artefact zips, or the source clones. Privacy / local
+ * audit cleanup only.
  *
- * @param {object} argv - Parsed yargs arguments.
- * @param {string} argv.root - Project root directory.
- * @param {string} argv.manifest - Path to the manifest file (used to locate wyvrn.lock).
+ * @param {object}  argv
+ * @param {string}  argv.root             Project root directory.
+ * @param {string}  argv.manifest         Path to the manifest file (used to locate wyvrn.lock).
+ * @param {boolean} [argv.buildCache]     When true, also nukes the source-build cache.
+ * @param {boolean} [argv.uploadedBuilt]  When true, wipes upload sidecars only.
  * @returns {Promise<void>}
  */
 async function clean(argv) {
-  const rootDir = path.resolve(argv.root);
+  const rootDir  = path.resolve(argv.root);
   const razerDir = path.join(rootDir, 'wyvrn_internal');
   const lockPath = path.join(path.dirname(path.resolve(argv.manifest)), 'wyvrn.lock');
 
+  // --uploaded-built is a targeted cleanup mode. When passed on its own,
+  // skip the default wyvrn_internal/ + wyvrn.lock scrub so a user can
+  // "forget uploads" without also wiping their project-local install.
+  const targetedOnly = argv.uploadedBuilt && !argv.buildCache;
+
   let removedAnything = false;
 
-  if (fs.existsSync(razerDir)) {
-    fs.rmSync(razerDir, { recursive: true, force: true });
-    console.log(`[wyvrn] Removed ${razerDir}`);
-    removedAnything = true;
-  } else {
-    console.log(`[wyvrn] Nothing to clean at ${razerDir}`);
+  if (!targetedOnly) {
+    if (fs.existsSync(razerDir)) {
+      fs.rmSync(razerDir, { recursive: true, force: true });
+      log.info(`Removed ${razerDir}`);
+      removedAnything = true;
+    } else {
+      log.info(`Nothing to clean at ${razerDir}`);
+    }
+
+    if (fs.existsSync(lockPath)) {
+      fs.unlinkSync(lockPath);
+      log.info(`Removed ${lockPath}`);
+      removedAnything = true;
+    }
   }
 
-  if (fs.existsSync(lockPath)) {
-    fs.unlinkSync(lockPath);
-    console.log(`[wyvrn] Removed ${lockPath}`);
-    removedAnything = true;
+  if (argv.buildCache) {
+    const removed = clearBuildCache();
+    if (removed) {
+      log.info(`Removed source-build cache ${removed}`);
+      removedAnything = true;
+    } else {
+      log.info(`No source-build cache at ${getBuildCacheRoot()}`);
+    }
+  } else if (argv.uploadedBuilt) {
+    // clearBuildCache() would have nuked the sidecars as a side-effect, so
+    // only bother with the sidecar sweep when the cache itself is surviving.
+    const removed = clearUploadSidecars();
+    log.info(`Removed ${removed} upload record${removed === 1 ? '' : 's'} from the build cache`);
+    if (removed > 0) removedAnything = true;
   }
 
   if (!removedAnything) {
-    console.log('[wyvrn] Nothing to clean.');
+    log.info('Nothing to clean.');
   }
 }
 

package/src/commands/configure.js

@@ -1,6 +1,7 @@
 'use strict';
 
 const { readConfig, writeConfig, getConfigPath } = require('../config');
+const log = require('../logger');
 
 /** wyvrnpm configure list */
 function list() {
@@ -47,14 +48,14 @@ function addSource(argv) {
   const idx = config[key].findIndex((s) => s.name === name);
   if (idx !== -1) {
     config[key][idx] = entry;
-    console.log(`[wyvrn] Updated ${kind} source "${name}"`);
+    log.info(`Updated ${kind} source "${name}"`);
   } else {
     config[key].push(entry);
-    console.log(`[wyvrn] Added ${kind} source "${name}"`);
+    log.info(`Added ${kind} source "${name}"`);
   }
 
   writeConfig(config);
-  console.log(`[wyvrn] Saved to ${getConfigPath()}`);
+  log.info(`Saved to ${getConfigPath()}`);
 }
 
 /**
@@ -69,12 +70,12 @@ function removeSource(argv) {
   config[key] = config[key].filter((s) => s.name !== name);
 
   if (config[key].length === before) {
-    console.error(`[wyvrn] Error: No ${kind} source named "${name}"`);
+    log.error(`No ${kind} source named "${name}"`);
     process.exit(1);
   }
 
   writeConfig(config);
-  console.log(`[wyvrn] Removed ${kind} source "${name}"`);
+  log.info(`Removed ${kind} source "${name}"`);
 }
 
 module.exports = { list, addSource, removeSource };

package/src/commands/init.js

@@ -3,6 +3,7 @@
 const fs = require('fs');
 const path = require('path');
 const { defaultManifest, writeManifest } = require('../manifest');
+const log = require('../logger');
 
 /**
  * Initialises a new wyvrn.json manifest in the project root.
@@ -18,7 +19,7 @@ async function init(argv) {
   const rootDir = path.resolve(argv.root);
 
   if (fs.existsSync(manifestPath)) {
-    console.log(`[wyvrn] Manifest already exists at ${manifestPath}`);
+    log.info(`Manifest already exists at ${manifestPath}`);
     return;
   }
 
@@ -27,7 +28,7 @@ async function init(argv) {
 
   writeManifest(manifestPath, manifest);
 
-  console.log(`[wyvrn] Created manifest at ${manifestPath}`);
+  log.success(`Created manifest at ${manifestPath}`);
 }
 
 module.exports = init;

package/src/commands/install-skill.js

@@ -0,0 +1,107 @@
+'use strict';
+
+const fs   = require('fs');
+const os   = require('os');
+const path = require('path');
+const AdmZip = require('adm-zip');
+
+const log = require('../logger');
+
+// ---------------------------------------------------------------------------
+// `wyvrnpm install-skill --claude`
+//
+// Copies the bundled wyvrnpm Agent Skill (claude/skills/wyvrnpm.skill) into
+// the user's Claude Code skills directory so Claude picks it up automatically.
+//
+// Works for both install shapes:
+//   - `npm i -g wyvrnpm` → skill zip ships under <pkg>/claude/skills/
+//   - `git clone` of this repo → same path, just not from node_modules
+//
+// Destination, per target:
+//   --claude  → %USERPROFILE%\.claude\skills\wyvrnpm\  (Windows)
+//               ~/.claude/skills/wyvrnpm/               (macOS / Linux)
+// ---------------------------------------------------------------------------
+
+const SKILL_NAME = 'wyvrnpm';
+
+function bundledSkillPath() {
+  // __dirname = <pkg>/src/commands; the .skill zip lives at
+  // <pkg>/claude/skills/wyvrnpm.skill.
+  return path.resolve(__dirname, '..', '..', 'claude', 'skills', `${SKILL_NAME}.skill`);
+}
+
+function claudeSkillsDir() {
+  const home = os.homedir();
+  if (!home) throw new Error('cannot resolve user home directory');
+  return path.join(home, '.claude', 'skills');
+}
+
+function rmrf(target) {
+  if (!fs.existsSync(target)) return;
+  fs.rmSync(target, { recursive: true, force: true });
+}
+
+function installForClaude({ force, dryRun }) {
+  const zipPath = bundledSkillPath();
+  if (!fs.existsSync(zipPath)) {
+    log.error(`bundled skill not found at ${zipPath}`);
+    log.error('this is a packaging bug — please file an issue');
+    process.exit(1);
+  }
+
+  const skillsDir = claudeSkillsDir();
+  const destDir   = path.join(skillsDir, SKILL_NAME);
+  const destZip   = path.join(skillsDir, `${SKILL_NAME}.skill`);
+
+  log.info(`Source      : ${zipPath}`);
+  log.info(`Destination : ${destDir}`);
+
+  if (fs.existsSync(destDir) && !force) {
+    log.warn(`${destDir} already exists`);
+    log.warn('re-run with --force to overwrite');
+    process.exit(1);
+  }
+
+  if (dryRun) {
+    log.info('(--dry-run) would remove existing skill dir and zip, then extract fresh copy');
+    return;
+  }
+
+  fs.mkdirSync(skillsDir, { recursive: true });
+  rmrf(destDir);
+  rmrf(destZip);
+
+  const zip = new AdmZip(zipPath);
+  zip.extractAllTo(skillsDir, /* overwrite */ true);
+  fs.copyFileSync(zipPath, destZip);
+
+  if (!fs.existsSync(path.join(destDir, 'SKILL.md'))) {
+    log.error(`extraction produced no SKILL.md under ${destDir}`);
+    log.error('the bundled .skill zip may be malformed');
+    process.exit(1);
+  }
+
+  log.success(`Installed ${SKILL_NAME} skill to ${destDir}`);
+  log.info('Claude Code will pick it up on next session start.');
+}
+
+async function installSkill(argv) {
+  const targets = [];
+  if (argv.claude) targets.push('claude');
+
+  if (targets.length === 0) {
+    log.error('no target specified — pass --claude');
+    log.error('(more targets may be added in future releases)');
+    process.exit(1);
+  }
+
+  for (const target of targets) {
+    if (target === 'claude') {
+      installForClaude({ force: !!argv.force, dryRun: !!argv['dry-run'] });
+    }
+  }
+}
+
+module.exports = installSkill;
+module.exports.bundledSkillPath = bundledSkillPath;
+module.exports.claudeSkillsDir  = claudeSkillsDir;