wyvrnpm 2.0.2 → 2.1.0

package/src/commands/profile.js

@@ -12,6 +12,7 @@ const {
   mergeProfile,
 } = require('../profile');
 const { readConfig, writeConfig } = require('../config');
+const log = require('../logger');
 
 // ---------------------------------------------------------------------------
 // list
@@ -27,8 +28,9 @@ function list() {
   const dir      = getProfilesDir();
   const defName  = config.defaultProfile ?? 'default';
 
-  console.log(`[wyvrn] Profiles directory: ${dir}`);
-  console.log(`[wyvrn] Default profile   : ${defName}\n`);
+  log.info(`Profiles directory: ${dir}`);
+  log.info(`Default profile   : ${defName}`);
+  console.log('');
 
   if (names.length === 0) {
     console.log('  (no profiles saved — run `wyvrnpm configure profile detect` to create one)');
@@ -60,12 +62,12 @@ function show(argv) {
   const stored  = readProfile(name);
 
   if (stored) {
-    console.log(`[wyvrn] Profile "${name}":`);
+    log.info(`Profile "${name}":`);
     console.log(formatProfile(stored));
     console.log(`\nProfile hash : ${hashProfile(stored)}`);
   } else {
     const detected = detectProfile();
-    console.log(`[wyvrn] Profile "${name}" not found — showing auto-detected environment:`);
+    log.info(`Profile "${name}" not found — showing auto-detected environment:`);
     console.log(formatProfile(detected));
     console.log(`\nProfile hash : ${hashProfile(detected)}`);
     console.log(`\nRun \`wyvrnpm configure profile detect --name ${name}\` to save this.`);
@@ -85,13 +87,14 @@ function detect(argv) {
   const name   = argv.name ?? config.defaultProfile ?? 'default';
   const p      = detectProfile();
 
-  console.log('[wyvrn] Detected profile:');
+  log.info('Detected profile:');
   console.log(formatProfile(p));
   console.log(`\nProfile hash : ${hashProfile(p)}`);
 
   if (!argv.dryRun) {
     writeProfile(name, p);
-    console.log(`\n[wyvrn] Saved as profile "${name}".`);
+    console.log('');
+    log.success(`Saved as profile "${name}".`);
   }
 }
 
@@ -120,7 +123,7 @@ function set(argv) {
 
   writeProfile(name, updated);
 
-  console.log(`[wyvrn] Profile "${name}" updated:`);
+  log.info(`Profile "${name}" updated:`);
   console.log(formatProfile(updated));
   console.log(`\nProfile hash : ${hashProfile(updated)}`);
 }
@@ -136,13 +139,13 @@ function set(argv) {
 function setDefault(argv) {
   const name = argv.name;
   if (!readProfile(name)) {
-    console.error(`[wyvrn] Error: profile "${name}" does not exist. Create it first.`);
+    log.error(`profile "${name}" does not exist. Create it first.`);
     process.exit(1);
   }
   const config = readConfig();
   config.defaultProfile = name;
   writeConfig(config);
-  console.log(`[wyvrn] Default profile set to "${name}".`);
+  log.info(`Default profile set to "${name}".`);
 }
 
 // ---------------------------------------------------------------------------
@@ -156,14 +159,14 @@ function setDefault(argv) {
 function del(argv) {
   const name = argv.name;
   if (name === 'default') {
-    console.error('[wyvrn] Error: cannot delete the "default" profile.');
+    log.error('cannot delete the "default" profile.');
     process.exit(1);
   }
   const removed = deleteProfile(name);
   if (removed) {
-    console.log(`[wyvrn] Profile "${name}" deleted.`);
+    log.info(`Profile "${name}" deleted.`);
   } else {
-    console.error(`[wyvrn] Error: profile "${name}" not found.`);
+    log.error(`profile "${name}" not found.`);
     process.exit(1);
   }
 }

package/src/commands/publish.js

@@ -8,7 +8,9 @@ const AdmZip = require('adm-zip');
 const { readManifest }                                     = require('../manifest');
 const { getProvider }                                      = require('../providers');
 const { readConfig }                                       = require('../config');
-const { loadProfile, hashProfile, sha256Of, getGitSha, getGitRepo } = require('../profile');
+const { loadProfile, hashProfile, sha256Of, getGitSha, getGitRepo, isShaOnRemote } = require('../profile');
+const { defaultCompatBlock }                               = require('../compat');
+const log                                                  = require('../logger');
 
 // ---------------------------------------------------------------------------
 // .wyvrnignore helpers (unchanged from v1)
@@ -40,7 +42,7 @@ function addFolderFiltered(zip, dir, base, ignoreRe) {
     const fullPath = path.join(dir, entry);
     const relPath  = path.relative(base, fullPath).replace(/\\/g, '/');
     if (ignoreRe.some((re) => re.test(relPath))) {
-      console.log(`[wyvrn]   Ignoring: ${relPath}`);
+      log.info(`  Ignoring: ${relPath}`);
       continue;
     }
     const stat = fs.statSync(fullPath);
@@ -64,21 +66,21 @@ function resolveSource(argv) {
   if (source) {
     const named = config.publishSources.find((s) => s.name === source);
     if (named) {
-      console.log(`[wyvrn] Using publish source "${named.name}" from config`);
+      log.info(`Using publish source "${named.name}" from config`);
       source     = named.url;
       awsProfile = awsProfile ?? named.profile;
       token      = token      ?? named.token;
     }
   } else {
     if (config.publishSources.length === 0) {
-      console.error(
-        '[wyvrn] Error: --source is required (or configure one with: ' +
+      log.error(
+        '--source is required (or configure one with: ' +
           'wyvrnpm configure add-source --kind publish ...)',
       );
       process.exit(1);
     }
     const first = config.publishSources[0];
-    console.log(`[wyvrn] Using publish source "${first.name}" from config`);
+    log.info(`Using publish source "${first.name}" from config`);
     source     = first.url;
     awsProfile = awsProfile ?? first.profile;
     token      = token      ?? first.token;
@@ -104,19 +106,19 @@ async function publish(argv) {
   const manifestPath = path.resolve(manifestArg || './wyvrn.json');
   const manifest = await readManifest(manifestPath);
   if (!manifest) {
-    console.error(`[wyvrn] Error: Could not read manifest at ${manifestPath}`);
+    log.error(`Could not read manifest at ${manifestPath}`);
     process.exit(1);
   }
 
   const { name, version } = manifest;
   if (!name || !version) {
-    console.error('[wyvrn] Error: Manifest must have "name" and "version" fields');
+    log.error('Manifest must have "name" and "version" fields');
     process.exit(1);
   }
 
   const srcDir = path.resolve(publishPath || '.');
   if (!fs.existsSync(srcDir)) {
-    console.error(`[wyvrn] Error: Publish path does not exist: ${srcDir}`);
+    log.error(`Publish path does not exist: ${srcDir}`);
     process.exit(1);
   }
 
@@ -125,7 +127,7 @@ async function publish(argv) {
   try {
     provider = getProvider(source);
   } catch (err) {
-    console.error(`[wyvrn] Error: ${err.message}`);
+    log.error(err.message);
     process.exit(1);
   }
 
@@ -135,25 +137,25 @@ async function publish(argv) {
   const { profile: buildProfile, fromFile } = loadProfile(activeProfileName);
   const profileHash = hashProfile(buildProfile);
 
-  console.log(
-    `[wyvrn] Publishing ${name}@${version}\n` +
-    `[wyvrn] Profile     : "${activeProfileName}"${fromFile ? '' : ' (auto-detected — save with `wyvrnpm configure profile detect`)'}\n` +
-    `[wyvrn]   ${buildProfile.os}/${buildProfile.arch}  ` +
+  log.info(
+    `Publishing ${name}@${version}\n` +
+    `Profile     : "${activeProfileName}"${fromFile ? '' : ' (auto-detected — save with `wyvrnpm configure profile detect`)'}\n` +
+    `  ${buildProfile.os}/${buildProfile.arch}  ` +
     `${buildProfile.compiler} ${buildProfile['compiler.version']}  ` +
     `C++${buildProfile['compiler.cppstd']}` +
     (buildProfile['compiler.runtime'] ? `  [${buildProfile['compiler.runtime']}]` : '') + '\n' +
-    `[wyvrn] Profile hash: ${profileHash}\n` +
-    `[wyvrn] Provider    : ${provider.constructor.providerName}`,
+    `Profile hash: ${profileHash}\n` +
+    `Provider    : ${provider.constructor.providerName}`,
   );
 
   // ── Check v2 existence ────────────────────────────────────────────────────
   const v2AlreadyExists = await provider.v2Exists({ source, name, version, profileHash, awsProfile, token });
   if (v2AlreadyExists) {
     if (force) {
-      console.warn(`[wyvrn] Warning: ${name}@${version} [${profileHash}] already exists — overwriting (--force)`);
+      log.warn(`${name}@${version} [${profileHash}] already exists — overwriting (--force)`);
     } else {
-      console.error(
-        `[wyvrn] Error: ${name}@${version} [${profileHash}] already exists.\n` +
+      log.error(
+        `${name}@${version} [${profileHash}] already exists.\n` +
           '  Bump the version, use a different profile, or pass --force to overwrite.',
       );
       process.exit(1);
@@ -170,43 +172,76 @@ async function publish(argv) {
         const ver = typeof entry === 'string' ? entry : entry.version;
         if (ver) lockedDependencies[pkgName] = ver;
       }
-      console.log(`[wyvrn] Lock file  : ${Object.keys(lockedDependencies).length} pinned package(s)`);
+      log.info(`Lock file  : ${Object.keys(lockedDependencies).length} pinned package(s)`);
     } catch {
-      console.warn('[wyvrn] Warning: could not read wyvrn.lock — dependency versions will be published as-is from wyvrn.json');
+      log.warn('could not read wyvrn.lock — dependency versions will be published as-is from wyvrn.json');
     }
   } else {
-    console.warn('[wyvrn] Warning: no wyvrn.lock found — run `wyvrnpm install` before publishing to pin dependency versions');
+    log.warn('no wyvrn.lock found — run `wyvrnpm install` before publishing to pin dependency versions');
   }
 
   // ── Git metadata ──────────────────────────────────────────────────────────
   const gitSha  = getGitSha(srcDir);
   const gitRepo = getGitRepo(srcDir);
-  if (gitSha)  console.log(`[wyvrn] Git commit : ${gitSha}`);
-  if (gitRepo) console.log(`[wyvrn] Git remote : ${gitRepo}`);
+  if (gitSha)  log.info(`Git commit : ${gitSha}`);
+  if (gitRepo) log.info(`Git remote : ${gitRepo}`);
+
+  // Warn (but don't block) if HEAD isn't reachable from origin. Downstream
+  // `--build=missing` consumers will fail to fetch this commit — the fix
+  // is almost always `git push` before publishing.
+  if (gitSha && gitRepo && !isShaOnRemote(gitSha, srcDir)) {
+    log.warn(
+      `commit ${gitSha.slice(0, 12)} is not reachable from any remote ` +
+      `branch or tag on origin.\n` +
+      `  Consumers building this package from source will fail to retrieve it.\n` +
+      `  Fix: push your branch (or tag the commit) before publishing.`,
+    );
+  }
 
   // ── .wyvrnignore ──────────────────────────────────────────────────────────
   const ignoreFile = path.join(srcDir, '.wyvrnignore');
   const ignorePatterns = loadIgnorePatterns(ignoreFile);
   const ignoreRe = ignorePatterns.map(patternToRegex);
   if (ignorePatterns.length > 0) {
-    console.log(`[wyvrn] Loaded ${ignorePatterns.length} pattern(s) from .wyvrnignore`);
+    log.info(`Loaded ${ignorePatterns.length} pattern(s) from .wyvrnignore`);
   }
 
   // ── Build zip ─────────────────────────────────────────────────────────────
   const tmpZipPath = path.join(os.tmpdir(), `wyvrnpm-${name}-${version}-${Date.now()}.zip`);
+
+  // ── Inject default `compatibility` block if the source manifest lacks one ──
+  // Written to a temp file so the source wyvrn.json is never modified.
+  // A published manifest must always carry a compat block so install-time
+  // resolution has something to evaluate (default = all fields `exact`,
+  // identical semantics to pre-phase-2 strict behaviour).
+  const tmpManifestPath = path.join(
+    os.tmpdir(),
+    `wyvrnpm-manifest-${name}-${version}-${Date.now()}.json`,
+  );
+  const manifestForPublish = {
+    ...manifest,
+    compatibility: manifest.compatibility ?? defaultCompatBlock(),
+  };
+  fs.writeFileSync(tmpManifestPath, JSON.stringify(manifestForPublish, null, 2), 'utf8');
+  if (!manifest.compatibility) {
+    log.info('Injecting default `compatibility` block (all fields `exact`) — override by adding one to wyvrn.json');
+  } else {
+    log.info(`Using package-declared compatibility: ${JSON.stringify(manifest.compatibility)}`);
+  }
+
   try {
-    console.log(`[wyvrn] Zipping ${srcDir} ...`);
+    log.info(`Zipping ${srcDir} ...`);
     const zip = new AdmZip();
     addFolderFiltered(zip, srcDir, srcDir, ignoreRe);
     zip.writeZip(tmpZipPath);
 
     const contentSha256 = sha256Of(tmpZipPath);
-    console.log(`[wyvrn] Content SHA256 : ${contentSha256}`);
+    log.info(`Content SHA256 : ${contentSha256}`);
 
     // ── v2 publish ────────────────────────────────────────────────────────
-    console.log('[wyvrn] Publishing (v2) ...');
+    log.info('Publishing (v2) ...');
     await provider.v2Publish(
-      { manifest: manifestPath, zip: tmpZipPath },
+      { manifest: tmpManifestPath, zip: tmpZipPath },
       {
         source,
         name,
@@ -223,9 +258,10 @@ async function publish(argv) {
       },
     );
 
-    console.log(`[wyvrn] Successfully published ${name}@${version} [${profileHash}] to ${source}`);
+    log.success(`Successfully published ${name}@${version} [${profileHash}] to ${source}`);
   } finally {
-    if (fs.existsSync(tmpZipPath)) fs.unlinkSync(tmpZipPath);
+    if (fs.existsSync(tmpZipPath))      fs.unlinkSync(tmpZipPath);
+    if (fs.existsSync(tmpManifestPath)) fs.unlinkSync(tmpManifestPath);
   }
 }
 

package/src/compat.js

@@ -0,0 +1,232 @@
+'use strict';
+
+/**
+ * Declarative compatibility evaluator for v2 build profiles.
+ *
+ * Publishers declare a `compatibility` block in their package's `wyvrn.json`
+ * stating which profile fields must match exactly vs which may differ.
+ * At install time, when no exact profileHash match exists, this module
+ * evaluates each registry-side build against the consumer's profile and
+ * picks a compatible one if any.
+ *
+ * The block format is per-field: either a string shorthand or an object.
+ *
+ *   "compatibility": {
+ *     "compiler.cppstd":   "lte",
+ *     "compiler.runtime":  "exact",
+ *     "compiler.version":  "exact-or-newer"
+ *   }
+ *
+ *   equivalent object form (allows future extensions):
+ *
+ *   "compatibility": {
+ *     "compiler.cppstd":   { "mode": "lte" }
+ *   }
+ *
+ * Modes:
+ *   exact           | Package and consumer values must be equal.
+ *   any             | Field is ignored.
+ *   lte             | Package value ≤ consumer value (consumer is at least as
+ *                   | new/high — e.g. cppstd=20 package usable by cppstd=23).
+ *   gte             | Package value ≥ consumer value (symmetry; rarely useful).
+ *   exact-or-newer  | Semantically identical to `lte` at MVP — kept as a
+ *                   | distinct name because it reads naturally for compiler
+ *                   | version fields and leaves room for future "same major"
+ *                   | semantics without renaming.
+ *
+ * Missing fields default to `exact`. `os` and `arch` are ALWAYS evaluated
+ * as `exact` regardless of what the block says — cross-arch/cross-OS
+ * binaries are never ABI-compatible.
+ */
+
+const OS_ARCH_ALWAYS_EXACT = new Set(['os', 'arch']);
+
+const DEFAULT_COMPAT_FIELDS = [
+  'os',
+  'arch',
+  'compiler',
+  'compiler.version',
+  'compiler.cppstd',
+  'compiler.runtime',
+];
+
+const VALID_MODES = new Set(['exact', 'any', 'lte', 'gte', 'exact-or-newer']);
+
+/**
+ * Normalise a raw compatibility block into `{ field → mode }`.
+ * Missing fields fall back to `exact`. Unknown modes fall back to `exact`.
+ * `os` and `arch` are forced to `exact`.
+ *
+ * @param {object|null|undefined} rawCompat
+ * @returns {Record<string, string>}
+ */
+function normalizeCompat(rawCompat) {
+  const result = {};
+  for (const field of DEFAULT_COMPAT_FIELDS) result[field] = 'exact';
+
+  if (!rawCompat || typeof rawCompat !== 'object') return result;
+
+  for (const [field, spec] of Object.entries(rawCompat)) {
+    if (OS_ARCH_ALWAYS_EXACT.has(field)) continue;
+    const mode = typeof spec === 'string' ? spec : (spec && spec.mode);
+    if (mode && VALID_MODES.has(mode)) result[field] = mode;
+  }
+  return result;
+}
+
+/**
+ * Return the default compatibility block — all fields `exact`.
+ * Used by `publish` when the source manifest lacks a block.
+ * @returns {Record<string, string>}
+ */
+function defaultCompatBlock() {
+  const result = {};
+  for (const field of DEFAULT_COMPAT_FIELDS) result[field] = 'exact';
+  return result;
+}
+
+/**
+ * Evaluate a single field under a given mode.
+ *
+ * @returns {'match'|'compat-lte'|'compat-gte'|'compat-newer'|'compat-any'|'incompatible'}
+ */
+function evaluateField(mode, consumerVal, packageVal) {
+  switch (mode) {
+    case 'any':
+      return 'compat-any';
+
+    case 'exact':
+      return consumerVal === packageVal ? 'match' : 'incompatible';
+
+    case 'lte': {
+      if (consumerVal === packageVal) return 'match';
+      const c = Number(consumerVal);
+      const p = Number(packageVal);
+      if (Number.isFinite(c) && Number.isFinite(p)) {
+        return p <= c ? 'compat-lte' : 'incompatible';
+      }
+      return 'incompatible';
+    }
+
+    case 'gte': {
+      if (consumerVal === packageVal) return 'match';
+      const c = Number(consumerVal);
+      const p = Number(packageVal);
+      if (Number.isFinite(c) && Number.isFinite(p)) {
+        return p >= c ? 'compat-gte' : 'incompatible';
+      }
+      return 'incompatible';
+    }
+
+    case 'exact-or-newer': {
+      if (consumerVal === packageVal) return 'match';
+      const c = Number(consumerVal);
+      const p = Number(packageVal);
+      if (Number.isFinite(c) && Number.isFinite(p)) {
+        return c >= p ? 'compat-newer' : 'incompatible';
+      }
+      return 'incompatible';
+    }
+
+    default:
+      // Unknown mode → fail safe
+      return 'incompatible';
+  }
+}
+
+/**
+ * Evaluate a package's compatibility block against a consumer's profile.
+ *
+ * @param {Record<string, string|null>} consumerProfile
+ * @param {Record<string, string|null>} packageProfile  - what the package was built with
+ * @param {object|null|undefined}       rawCompat       - compatibility block from the package manifest
+ * @returns {{
+ *   compatible: boolean,
+ *   reasons: Array<{ field: string, mode: string, consumer: any, package: any, outcome: string }>,
+ * }}
+ */
+function evaluateCompat(consumerProfile, packageProfile, rawCompat) {
+  const compat = normalizeCompat(rawCompat);
+  const reasons = [];
+  let compatible = true;
+
+  for (const [field, mode] of Object.entries(compat)) {
+    const cVal = consumerProfile[field];
+    const pVal = packageProfile[field];
+    const outcome = evaluateField(mode, cVal, pVal);
+    reasons.push({ field, mode, consumer: cVal, package: pVal, outcome });
+    if (outcome === 'incompatible') compatible = false;
+  }
+
+  return { compatible, reasons };
+}
+
+/**
+ * Deterministic tiebreaker when multiple compatible candidates exist.
+ *
+ *   1. Prefer candidates whose `compiler` matches the consumer's.
+ *   2. Prefer the highest numeric `compiler.version`.
+ *   3. Prefer candidates whose `compiler.runtime` matches the consumer's.
+ *   4. Prefer the lexicographically earliest profile hash (stable fallback).
+ *
+ * @param {Array<{ profileHash: string, packageProfile: Record<string, any>, reasons: Array<any> }>} candidates
+ * @param {Record<string, string|null>} consumerProfile
+ * @returns {object|null}  The preferred candidate (or null if list is empty).
+ */
+function pickBestCandidate(candidates, consumerProfile) {
+  if (!candidates || candidates.length === 0) return null;
+  if (candidates.length === 1) return candidates[0];
+
+  const sorted = candidates.slice().sort((a, b) => {
+    const compilerA = a.packageProfile.compiler === consumerProfile.compiler ? 0 : 1;
+    const compilerB = b.packageProfile.compiler === consumerProfile.compiler ? 0 : 1;
+    if (compilerA !== compilerB) return compilerA - compilerB;
+
+    const verA = Number(a.packageProfile['compiler.version']) || 0;
+    const verB = Number(b.packageProfile['compiler.version']) || 0;
+    if (verA !== verB) return verB - verA; // descending
+
+    const runtimeA = a.packageProfile['compiler.runtime'] === consumerProfile['compiler.runtime'] ? 0 : 1;
+    const runtimeB = b.packageProfile['compiler.runtime'] === consumerProfile['compiler.runtime'] ? 0 : 1;
+    if (runtimeA !== runtimeB) return runtimeA - runtimeB;
+
+    return a.profileHash < b.profileHash ? -1 : 1;
+  });
+
+  return sorted[0];
+}
+
+/**
+ * Render a reasons array into a compact human-readable summary — used for
+ * the "chose candidate X because …" log line at install time.
+ *
+ * @param {Array<{ field, mode, consumer, package, outcome }>} reasons
+ * @returns {string}
+ */
+function summarizeReasons(reasons) {
+  return reasons
+    .filter((r) => r.outcome !== 'compat-any' || r.mode !== 'any') // skip trivial any
+    .map((r) => {
+      switch (r.outcome) {
+        case 'match':         return `${r.field}=${r.consumer}`;
+        case 'compat-lte':    return `${r.field} ${r.package}→${r.consumer} (lte)`;
+        case 'compat-gte':    return `${r.field} ${r.package}←${r.consumer} (gte)`;
+        case 'compat-newer':  return `${r.field} ${r.package}→${r.consumer} (newer)`;
+        case 'compat-any':    return `${r.field}=* (any)`;
+        case 'incompatible':  return `${r.field} INCOMPAT (need ${r.consumer}, have ${r.package})`;
+        default:              return `${r.field} ${r.outcome}`;
+      }
+    })
+    .join(', ');
+}
+
+module.exports = {
+  normalizeCompat,
+  defaultCompatBlock,
+  evaluateCompat,
+  evaluateField,
+  pickBestCandidate,
+  summarizeReasons,
+  DEFAULT_COMPAT_FIELDS,
+  VALID_MODES,
+};

package/src/config.js

@@ -4,6 +4,8 @@ const fs = require('fs');
 const path = require('path');
 const os = require('os');
 
+const log = require('./logger');
+
 /**
  * Returns the directory where wyvrnpm stores its config.
  *   Windows : %LOCALAPPDATA%\wyvrnpm
@@ -41,7 +43,7 @@ function readConfig() {
       defaultProfile: raw.defaultProfile  ?? 'default',
     };
   } catch {
-    console.warn('[wyvrn] Warning: could not parse config.json — using defaults');
+    log.warn('could not parse config.json — using defaults');
     return { installSources: [], publishSources: [], linkedPackages: {}, defaultProfile: 'default' };
   }
 }