wyvrnpm 1.2.1 → 2.0.1

package/src/link-utils.js

@@ -0,0 +1,95 @@
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+
+/**
+ * Creates a symlink/junction from linkPath pointing to targetPath.
+ * Uses junctions on Windows (no admin rights required), symlinks on Unix.
+ *
+ * @param {string} targetPath - The actual directory to link to.
+ * @param {string} linkPath - The path where the link will be created.
+ */
+function createLink(targetPath, linkPath) {
+  const absoluteTarget = path.resolve(targetPath);
+  const absoluteLink = path.resolve(linkPath);
+
+  // Ensure parent directory exists
+  const parentDir = path.dirname(absoluteLink);
+  if (!fs.existsSync(parentDir)) {
+    fs.mkdirSync(parentDir, { recursive: true });
+  }
+
+  // Remove existing link/directory if present
+  if (fs.existsSync(absoluteLink)) {
+    const stats = fs.lstatSync(absoluteLink);
+    if (stats.isSymbolicLink()) {
+      fs.unlinkSync(absoluteLink);
+    } else {
+      fs.rmSync(absoluteLink, { recursive: true, force: true });
+    }
+  }
+
+  // Use 'junction' on Windows (no admin required), 'dir' on Unix
+  const linkType = process.platform === 'win32' ? 'junction' : 'dir';
+  fs.symlinkSync(absoluteTarget, absoluteLink, linkType);
+}
+
+/**
+ * Checks if a path is a symlink or junction.
+ *
+ * @param {string} linkPath - Path to check.
+ * @returns {boolean} True if it's a symlink/junction.
+ */
+function isLink(linkPath) {
+  try {
+    const stats = fs.lstatSync(linkPath);
+    return stats.isSymbolicLink();
+  } catch {
+    return false;
+  }
+}
+
+/**
+ * Removes a symlink/junction without affecting the target directory.
+ *
+ * @param {string} linkPath - Path to the symlink/junction to remove.
+ * @returns {boolean} True if removed, false if it didn't exist or wasn't a link.
+ */
+function removeLink(linkPath) {
+  try {
+    const stats = fs.lstatSync(linkPath);
+    if (stats.isSymbolicLink()) {
+      fs.unlinkSync(linkPath);
+      return true;
+    }
+    return false;
+  } catch {
+    return false;
+  }
+}
+
+/**
+ * Gets the target path of a symlink/junction.
+ *
+ * @param {string} linkPath - Path to the symlink/junction.
+ * @returns {string|null} The target path, or null if not a link.
+ */
+function getLinkTarget(linkPath) {
+  try {
+    const stats = fs.lstatSync(linkPath);
+    if (stats.isSymbolicLink()) {
+      return fs.readlinkSync(linkPath);
+    }
+    return null;
+  } catch {
+    return null;
+  }
+}
+
+module.exports = {
+  createLink,
+  isLink,
+  removeLink,
+  getLinkTarget,
+};

package/src/manifest.js

@@ -1,77 +1,133 @@
-'use strict';
-
-const fs = require('fs');
-const path = require('path');
-
-/**
- * Valid project kind values, matching the C# serialisation enum.
- * @type {string[]}
- */
-const VALID_KINDS = [
-  'ConsoleApp',
-  'StaticLib',
-  'DynamicLib',
-  'HeaderOnlyLib',
-  'WebApp',
-  'Utility',
-  'Service',
-  'TestProject',
-];
-
-/**
- * Returns a blank manifest object populated with sensible defaults.
- *
- * @param {string} name - Project name (typically the directory basename).
- * @returns {object}
- */
-function defaultManifest(name) {
-  return {
-    name: name,
-    version: '1.0.0.0',
-    description: '',
-    kind: 'ConsoleApp',
-    dependencies: {},
-  };
-}
-
-/**
- * Reads and parses a wyvrn.json manifest from disk.
- *
- * @param {string} manifestPath - Absolute or relative path to wyvrn.json.
- * @returns {object} Parsed manifest data.
- * @throws {Error} If the file does not exist or contains invalid JSON.
- */
-function readManifest(manifestPath) {
-  const resolved = path.resolve(manifestPath);
-  if (!fs.existsSync(resolved)) {
-    throw new Error(`Manifest not found: ${resolved}`);
-  }
-  const raw = fs.readFileSync(resolved, 'utf8');
-  try {
-    return JSON.parse(raw);
-  } catch (err) {
-    throw new Error(`Failed to parse manifest at ${resolved}: ${err.message}`);
-  }
-}
-
-/**
- * Serialises and writes manifest data to disk with 2-space indentation.
- *
- * @param {string} manifestPath - Absolute or relative path to wyvrn.json.
- * @param {object} data - Manifest object to serialise.
- */
-function writeManifest(manifestPath, data) {
-  const resolved = path.resolve(manifestPath);
-  const dir = path.dirname(resolved);
-  if (!fs.existsSync(dir)) {
-    fs.mkdirSync(dir, { recursive: true });
-  }
-  fs.writeFileSync(resolved, JSON.stringify(data, null, 2) + '\n', 'utf8');
-}
-
-module.exports = {
-  VALID_KINDS,
-  defaultManifest,
-  readManifest,
-  writeManifest,
-};
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+
+/** Current manifest schema version emitted by v2 tooling. */
+const SCHEMA_VERSION = 2;
+
+/**
+ * Valid project kind values, matching the C# serialisation enum.
+ * @type {string[]}
+ */
+const VALID_KINDS = [
+  'ConsoleApp',
+  'StaticLib',
+  'DynamicLib',
+  'HeaderOnlyLib',
+  'WebApp',
+  'Utility',
+  'Service',
+  'TestProject',
+];
+
+/**
+ * Returns a blank v2 manifest object populated with sensible defaults.
+ *
+ * Build profile settings are NOT stored in wyvrn.json — they live in named
+ * profile files under the wyvrnpm config directory
+ * (%LOCALAPPDATA%\wyvrnpm\profiles\ on Windows).
+ *
+ * Dependencies can optionally carry per-package settings overrides that are
+ * merged on top of the active machine profile at install/publish time:
+ *
+ *   "dependencies": {
+ *     "zlib":    "1.2.11",
+ *     "openssl": { "version": "3.0.0", "settings": { "compiler.runtime": "static" } }
+ *   }
+ *
+ * @param {string} name - Project name (typically the directory basename).
+ * @returns {object}
+ */
+function defaultManifest(name) {
+  return {
+    name,
+    version: '1.0.0.0',
+    schemaVersion: SCHEMA_VERSION,
+    description: '',
+    kind: 'ConsoleApp',
+    dependencies: {},
+  };
+}
+
+/**
+ * Normalise the raw `dependencies` field from a manifest into a consistent
+ * `{ name → { version, settings } }` map, regardless of the input format:
+ *
+ *   • String value  : "1.0.0"               → { version: "1.0.0", settings: {} }
+ *   • Object value  : { version, settings? } → kept (settings defaults to {})
+ *   • Array format  : [{ Name, Version }]    → converted
+ *
+ * @param {object|Array|undefined} rawDeps
+ * @returns {Record<string, { version: string, settings: object }>}
+ */
+function normalizeDependencies(rawDeps) {
+  if (!rawDeps || typeof rawDeps !== 'object') return {};
+
+  if (Array.isArray(rawDeps)) {
+    const result = {};
+    for (const d of rawDeps) {
+      const n = d.Name ?? d.name;
+      const v = d.Version ?? d.version;
+      if (n && v) result[n] = { version: v, settings: {} };
+    }
+    return result;
+  }
+
+  const result = {};
+  for (const [n, value] of Object.entries(rawDeps)) {
+    if (typeof value === 'string') {
+      result[n] = { version: value, settings: {} };
+    } else if (value && typeof value === 'object') {
+      result[n] = {
+        version:  value.version ?? value.Version ?? '',
+        settings: value.settings ?? {},
+      };
+    }
+  }
+  return result;
+}
+
+/**
+ * Reads and parses a wyvrn.json manifest from disk.
+ *
+ * @param {string} manifestPath - Absolute or relative path to wyvrn.json.
+ * @returns {object} Parsed manifest data.
+ * @throws {Error} If the file does not exist or contains invalid JSON.
+ */
+function readManifest(manifestPath) {
+  const resolved = path.resolve(manifestPath);
+  if (!fs.existsSync(resolved)) {
+    throw new Error(`Manifest not found: ${resolved}`);
+  }
+  const raw = fs.readFileSync(resolved, 'utf8');
+  try {
+    return JSON.parse(raw);
+  } catch (err) {
+    throw new Error(`Failed to parse manifest at ${resolved}: ${err.message}`);
+  }
+}
+
+/**
+ * Serialises and writes manifest data to disk with 2-space indentation.
+ *
+ * @param {string} manifestPath - Absolute or relative path to wyvrn.json.
+ * @param {object} data - Manifest object to serialise.
+ */
+function writeManifest(manifestPath, data) {
+  const resolved = path.resolve(manifestPath);
+  const dir = path.dirname(resolved);
+  if (!fs.existsSync(dir)) {
+    fs.mkdirSync(dir, { recursive: true });
+  }
+  fs.writeFileSync(resolved, JSON.stringify(data, null, 2) + '\n', 'utf8');
+}
+
+module.exports = {
+  SCHEMA_VERSION,
+  VALID_KINDS,
+  defaultManifest,
+  normalizeDependencies,
+  readManifest,
+  writeManifest,
+};

package/src/profile.js

@@ -0,0 +1,377 @@
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+const crypto = require('crypto');
+const { execSync } = require('child_process');
+
+// ---------------------------------------------------------------------------
+// OS / Arch mapping (Node → Conan-style names)
+// ---------------------------------------------------------------------------
+const OS_MAP = {
+  win32:  'Windows',
+  linux:  'Linux',
+  darwin: 'Macos',
+};
+
+const ARCH_MAP = {
+  x64:    'x86_64',
+  ia32:   'x86',
+  arm:    'armv7',
+  arm64:  'armv8',
+  ppc64:  'ppc64le',
+  s390x:  's390x',
+  mips:   'mips',
+  mipsel: 'mipsel',
+};
+
+// ---------------------------------------------------------------------------
+// Helpers
+// ---------------------------------------------------------------------------
+function tryExec(cmd) {
+  try {
+    return execSync(cmd, { stdio: ['ignore', 'pipe', 'pipe'], timeout: 5000 })
+      .toString()
+      .trim();
+  } catch {
+    return null;
+  }
+}
+
+function detectOs() {
+  return OS_MAP[process.platform] ?? process.platform;
+}
+
+function detectArch() {
+  return ARCH_MAP[process.arch] ?? process.arch;
+}
+
+// ---------------------------------------------------------------------------
+// Compiler detection (per platform)
+// ---------------------------------------------------------------------------
+
+function detectCompilerWindows() {
+  // 1) MSVC via vswhere
+  const vswhere = tryExec(
+    '"C:\\Program Files (x86)\\Microsoft Visual Studio\\Installer\\vswhere.exe"' +
+    ' -latest -property installationVersion',
+  );
+  if (vswhere) {
+    const major = parseInt(vswhere.split('.')[0], 10);
+    // VS17 → MSVC 193x, VS16 → 192x, VS15 → 191x, VS14 → 190x
+    const vsToMsvc = { 17: '193', 16: '192', 15: '191', 14: '190' };
+    return {
+      compiler:           'msvc',
+      'compiler.version': vsToMsvc[major] ?? String(major),
+      'compiler.runtime': 'dynamic',
+    };
+  }
+
+  // 2) Clang / clang-cl
+  const clang = tryExec('clang --version');
+  if (clang) {
+    const m = clang.match(/version (\d+)/);
+    return {
+      compiler:           'clang',
+      'compiler.version': m ? m[1] : 'unknown',
+      'compiler.runtime': null,
+    };
+  }
+
+  // 3) MinGW GCC
+  const gcc = tryExec('gcc --version');
+  if (gcc) {
+    const m = gcc.match(/(\d+\.\d+\.\d+)/);
+    return {
+      compiler:           'gcc',
+      'compiler.version': m ? m[1].split('.')[0] : 'unknown',
+      'compiler.runtime': null,
+    };
+  }
+
+  return { compiler: 'unknown', 'compiler.version': 'unknown', 'compiler.runtime': null };
+}
+
+function detectCompilerMacos() {
+  const clang = tryExec('clang --version');
+  if (clang) {
+    const appleMatch = clang.match(/Apple clang version (\d+)/i);
+    if (appleMatch) {
+      return { compiler: 'apple-clang', 'compiler.version': appleMatch[1], 'compiler.runtime': null };
+    }
+    const llvmMatch = clang.match(/version (\d+)/);
+    return {
+      compiler:           'clang',
+      'compiler.version': llvmMatch ? llvmMatch[1] : 'unknown',
+      'compiler.runtime': null,
+    };
+  }
+  return { compiler: 'unknown', 'compiler.version': 'unknown', 'compiler.runtime': null };
+}
+
+function detectCompilerLinux() {
+  // Prefer GCC on Linux
+  const gcc = tryExec('gcc --version');
+  if (gcc) {
+    const m = gcc.match(/(\d+\.\d+\.\d+)/);
+    if (m) {
+      return {
+        compiler:           'gcc',
+        'compiler.version': m[1].split('.')[0],
+        'compiler.runtime': null,
+      };
+    }
+  }
+
+  const clang = tryExec('clang --version');
+  if (clang) {
+    const m = clang.match(/version (\d+)/);
+    return {
+      compiler:           'clang',
+      'compiler.version': m ? m[1] : 'unknown',
+      'compiler.runtime': null,
+    };
+  }
+
+  return { compiler: 'unknown', 'compiler.version': 'unknown', 'compiler.runtime': null };
+}
+
+// ---------------------------------------------------------------------------
+// Public API
+// ---------------------------------------------------------------------------
+
+/**
+ * Auto-detect the current build environment profile.
+ * Mirrors Conan 2.0 profile structure.
+ *
+ * @returns {WyvrnProfile}
+ */
+function detectProfile() {
+  const compilerInfo =
+    process.platform === 'win32'  ? detectCompilerWindows()
+    : process.platform === 'darwin' ? detectCompilerMacos()
+    : detectCompilerLinux();
+
+  return {
+    os:                 detectOs(),
+    arch:               detectArch(),
+    compiler:           compilerInfo.compiler,
+    'compiler.version': compilerInfo['compiler.version'],
+    'compiler.cppstd':  '20',
+    'compiler.runtime': compilerInfo['compiler.runtime'],
+  };
+}
+
+/**
+ * Compute a stable 16-char SHA256 prefix that identifies a unique build profile.
+ * Only non-null, non-wildcard fields contribute to the hash.
+ *
+ * @param {WyvrnProfile} profile
+ * @returns {string} 16-character lowercase hex string
+ */
+function hashProfile(profile) {
+  const significant = Object.fromEntries(
+    Object.entries(profile)
+      .filter(([, v]) => v !== null && v !== undefined && v !== '*' && v !== '')
+      .sort(([a], [b]) => a.localeCompare(b)),
+  );
+  return crypto
+    .createHash('sha256')
+    .update(JSON.stringify(significant))
+    .digest('hex')
+    .slice(0, 16);
+}
+
+/**
+ * Compute the SHA256 hash of a file or Buffer.
+ *
+ * @param {string|Buffer} source - Absolute path to a file, or a Buffer.
+ * @returns {string} Full 64-character lowercase hex SHA256.
+ */
+function sha256Of(source) {
+  const buf = Buffer.isBuffer(source) ? source : fs.readFileSync(source);
+  return crypto.createHash('sha256').update(buf).digest('hex');
+}
+
+/**
+ * Try to get the current git commit SHA in the given directory.
+ *
+ * @param {string} [cwd] - Directory to run git in (defaults to process.cwd()).
+ * @returns {string|null}
+ */
+function getGitSha(cwd) {
+  const result = tryExec(`git -C "${cwd || '.'}" rev-parse HEAD`);
+  return result && /^[0-9a-f]{40}$/i.test(result) ? result : null;
+}
+
+/**
+ * Try to get the remote origin URL for the current git repo.
+ *
+ * @param {string} [cwd]
+ * @returns {string|null}
+ */
+function getGitRepo(cwd) {
+  return tryExec(`git -C "${cwd || '.'}" remote get-url origin`) || null;
+}
+
+/**
+ * Format a profile for human-readable display (Conan-style).
+ *
+ * @param {WyvrnProfile} profile
+ * @returns {string}
+ */
+function formatProfile(profile) {
+  const fieldOrder = [
+    'os', 'arch', 'compiler', 'compiler.version', 'compiler.cppstd', 'compiler.runtime',
+  ];
+  const lines = ['[settings]'];
+  for (const key of fieldOrder) {
+    const val = profile[key];
+    if (val !== null && val !== undefined) {
+      lines.push(`${key}=${val}`);
+    }
+  }
+  return lines.join('\n');
+}
+
+/**
+ * Merge a partial override into a base profile, ignoring null/undefined overrides.
+ *
+ * @param {WyvrnProfile} base
+ * @param {Partial<WyvrnProfile>} overrides
+ * @returns {WyvrnProfile}
+ */
+function mergeProfile(base, overrides) {
+  return {
+    ...base,
+    ...Object.fromEntries(Object.entries(overrides).filter(([, v]) => v != null)),
+  };
+}
+
+// ---------------------------------------------------------------------------
+// Profile file management
+// ---------------------------------------------------------------------------
+
+/**
+ * Returns the directory where named build profiles are stored.
+ *   Windows : %LOCALAPPDATA%\wyvrnpm\profiles
+ *   Other   : ~/.config/wyvrnpm/profiles
+ *
+ * @returns {string}
+ */
+function getProfilesDir() {
+  const base = process.env.LOCALAPPDATA
+    ? path.join(process.env.LOCALAPPDATA, 'wyvrnpm')
+    : path.join(require('os').homedir(), '.config', 'wyvrnpm');
+  return path.join(base, 'profiles');
+}
+
+/**
+ * Read a named profile from the profiles directory.
+ * Looks for `{name}.json`, then `{name}` without extension.
+ *
+ * @param {string} name - Profile name (e.g. "default", "msvc_release").
+ * @returns {WyvrnProfile|null} Parsed profile, or null if not found.
+ */
+function readProfile(name) {
+  const dir = getProfilesDir();
+  for (const filename of [`${name}.json`, name]) {
+    const p = path.join(dir, filename);
+    if (fs.existsSync(p)) {
+      try { return JSON.parse(fs.readFileSync(p, 'utf8')); }
+      catch { return null; }
+    }
+  }
+  return null;
+}
+
+/**
+ * Write a named profile to the profiles directory as `{name}.json`.
+ *
+ * @param {string}       name
+ * @param {WyvrnProfile} profile
+ */
+function writeProfile(name, profile) {
+  const dir = getProfilesDir();
+  fs.mkdirSync(dir, { recursive: true });
+  fs.writeFileSync(
+    path.join(dir, `${name}.json`),
+    JSON.stringify(profile, null, 2) + '\n',
+    'utf8',
+  );
+}
+
+/**
+ * Delete a named profile file. Does nothing if the profile does not exist.
+ *
+ * @param {string} name
+ * @returns {boolean} true if a file was deleted.
+ */
+function deleteProfile(name) {
+  const dir = getProfilesDir();
+  for (const filename of [`${name}.json`, name]) {
+    const p = path.join(dir, filename);
+    if (fs.existsSync(p)) {
+      fs.unlinkSync(p);
+      return true;
+    }
+  }
+  return false;
+}
+
+/**
+ * List all profile names available in the profiles directory.
+ *
+ * @returns {string[]} Sorted list of profile names (without `.json` extension).
+ */
+function listProfiles() {
+  const dir = getProfilesDir();
+  if (!fs.existsSync(dir)) return [];
+  return fs
+    .readdirSync(dir)
+    .filter((f) => f.endsWith('.json'))
+    .map((f) => f.slice(0, -5))
+    .sort();
+}
+
+/**
+ * Load the active build profile by name. Falls back to auto-detection if the
+ * named profile file does not exist yet.
+ *
+ * @param {string} [name='default']
+ * @returns {{ profile: WyvrnProfile, fromFile: boolean }}
+ */
+function loadProfile(name = 'default') {
+  const stored = readProfile(name);
+  if (stored) return { profile: stored, fromFile: true };
+  return { profile: detectProfile(), fromFile: false };
+}
+
+module.exports = {
+  // Detection
+  detectProfile,
+  hashProfile,
+  sha256Of,
+  getGitSha,
+  getGitRepo,
+  formatProfile,
+  mergeProfile,
+  // Profile file management
+  getProfilesDir,
+  readProfile,
+  writeProfile,
+  deleteProfile,
+  listProfiles,
+  loadProfile,
+};
+
+/**
+ * @typedef {{
+ *   os:                  string,
+ *   arch:                string,
+ *   compiler:            string,
+ *   'compiler.version':  string,
+ *   'compiler.cppstd':   string,
+ *   'compiler.runtime':  string|null,
+ * }} WyvrnProfile
+ */