wyvrnpm 2.0.4 → 2.3.2

package/src/toolchain/index.js

@@ -0,0 +1,141 @@
+'use strict';
+
+const fs   = require('fs');
+const path = require('path');
+
+const { generateDepsCmake }     = require('./deps');
+const { generateCMakePresets } = require('./presets');
+
+/**
+ * Absolute path to the bundled `cmake/` directory shipped inside the
+ * wyvrnpm npm package. Returned in CMake-friendly form (forward slashes).
+ *
+ * @returns {string}
+ */
+function getBundledCmakeDir() {
+  const dir = path.resolve(__dirname, '..', '..', 'cmake');
+  return dir.replace(/\\/g, '/');
+}
+
+/**
+ * Substitute `{{KEY}}` placeholders in a template string.
+ *
+ * @param {string} template
+ * @param {Record<string, string>} values
+ * @returns {string}
+ */
+function renderTemplate(template, values) {
+  return template.replace(/\{\{(\w+)\}\}/g, (match, key) => {
+    if (Object.prototype.hasOwnProperty.call(values, key)) {
+      return values[key];
+    }
+    throw new Error(`Toolchain template has no value for placeholder {{${key}}}`);
+  });
+}
+
+/**
+ * Produce the toolchain template's placeholder substitutions.
+ *
+ * @param {object} args
+ * @param {import('../profile').WyvrnProfile} args.profile
+ * @param {string} args.profileName
+ * @param {string} args.profileHash
+ * @param {string[]} args.packageNames
+ * @returns {Record<string, string>}
+ */
+function buildPlaceholders({ profile, profileName, profileHash, packageNames }) {
+  const prefixPathEntries = packageNames
+    .map((name) => `    "\${CMAKE_CURRENT_LIST_DIR}/${name}"`)
+    .join('\n');
+
+  return {
+    GENERATED_AT:             new Date().toISOString(),
+    PROFILE_NAME:             profileName,
+    PROFILE_HASH:             profileHash,
+    PROFILE_OS:               profile.os ?? '',
+    PROFILE_ARCH:             profile.arch ?? '',
+    PROFILE_COMPILER:         profile.compiler ?? '',
+    PROFILE_COMPILER_VERSION: profile['compiler.version'] ?? '',
+    PROFILE_CPPSTD:           profile['compiler.cppstd'] ?? '20',
+    PROFILE_RUNTIME:          profile['compiler.runtime'] ?? '',
+    WYVRNPM_CMAKE_DIR:        getBundledCmakeDir(),
+    PREFIX_PATH_ENTRIES:      prefixPathEntries || '    # (no dependencies)',
+  };
+}
+
+/**
+ * Generate the three toolchain artefacts under `destDir`:
+ *   - wyvrn_toolchain.cmake
+ *   - wyvrn_deps.cmake
+ *   - wyvrn_profile.json
+ *
+ * ───────────────────────────────────────────────────────────────────────────
+ * CONTRACT (PLAN-CMAKE-TOOLCHAIN Phase F ↔ PLAN-BUILD-MISSING Phase 3)
+ * ───────────────────────────────────────────────────────────────────────────
+ * This function is the **single source of truth** for translating a build
+ * profile into a CMake configuration. Two callers exist:
+ *
+ *   1. `install`              — writes the toolchain into a consumer project's
+ *                               `wyvrn_internal/`, so `cmake --preset` picks it
+ *                               up at configure time.
+ *   2. `buildFromSource`      — (not yet implemented; PLAN-BUILD-MISSING §3)
+ *                               writes the toolchain into a scratch build dir
+ *                               when we source-build a package via
+ *                               `--build=missing`. The package is compiled
+ *                               with THIS function's output, guaranteeing the
+ *                               resulting binary's profile → flag mapping is
+ *                               bit-for-bit identical to what a consumer sees.
+ *
+ * Do NOT replicate this mapping elsewhere. If PLAN-BUILD-MISSING §3 finds it
+ * needs additional behaviour (e.g. extra CMake cache variables), extend this
+ * function — do not branch.
+ *
+ * Callers choose `destDir` and `packageNames`:
+ *   - `destDir`      — any directory; in source-build, points at the scratch
+ *                      `wyvrn_internal/` co-located with the cloned source.
+ *   - `packageNames` — in `install`, the consumer's resolved deps; in
+ *                      source-build, the *package's own* resolved deps.
+ *
+ * Profile arguments (`profile`, `profileName`, `profileHash`) are always the
+ * active consumer profile — source-build still uses the consumer's profile,
+ * not the package's. That is the whole point of the source-build path.
+ * ───────────────────────────────────────────────────────────────────────────
+ *
+ * @param {object} args
+ * @param {string} args.destDir         Where to write the three files.
+ * @param {import('../profile').WyvrnProfile} args.profile
+ * @param {string} args.profileName
+ * @param {string} args.profileHash
+ * @param {string[]} args.packageNames  Resolved dep names in topological order.
+ * @returns {{ toolchain: string, deps: string, profile: string }}
+ *          Absolute paths of the three files written.
+ */
+function generateToolchain({ destDir, profile, profileName, profileHash, packageNames }) {
+  fs.mkdirSync(destDir, { recursive: true });
+
+  const templatePath = path.join(__dirname, 'template.cmake');
+  const template     = fs.readFileSync(templatePath, 'utf8');
+  const placeholders = buildPlaceholders({ profile, profileName, profileHash, packageNames });
+  const toolchainContent = renderTemplate(template, placeholders);
+  const depsContent      = generateDepsCmake({ packageNames, profileHash });
+  const profileContent   = JSON.stringify({ name: profileName, hash: profileHash, ...profile }, null, 2) + '\n';
+
+  const toolchainPath = path.join(destDir, 'wyvrn_toolchain.cmake');
+  const depsPath      = path.join(destDir, 'wyvrn_deps.cmake');
+  const profilePath   = path.join(destDir, 'wyvrn_profile.json');
+
+  fs.writeFileSync(toolchainPath, toolchainContent, 'utf8');
+  fs.writeFileSync(depsPath,      depsContent,      'utf8');
+  fs.writeFileSync(profilePath,   profileContent,   'utf8');
+
+  return { toolchain: toolchainPath, deps: depsPath, profile: profilePath };
+}
+
+module.exports = {
+  generateToolchain,
+  generateCMakePresets,
+  getBundledCmakeDir,
+  // Exported for tests
+  buildPlaceholders,
+  renderTemplate,
+};

package/src/toolchain/presets.js

@@ -0,0 +1,263 @@
+'use strict';
+
+const fs   = require('fs');
+const path = require('path');
+
+const VENDOR_KEY = 'wyvrnpm/generated';
+const SCHEMA_VERSION = 3;  // requires CMake ≥ 3.21
+
+/**
+ * Safely parse a JSON file; returns null on any error (missing, malformed, …).
+ * @param {string} p
+ * @returns {object|null}
+ */
+function safeReadJson(p) {
+  try {
+    return JSON.parse(fs.readFileSync(p, 'utf8'));
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * True if the parsed presets object was produced by wyvrnpm (i.e. carries our
+ * vendor marker). Hand-edited or user-owned files return false.
+ *
+ * @param {object|null} presets
+ * @returns {boolean}
+ */
+function isWyvrnGenerated(presets) {
+  return !!presets && typeof presets.vendor === 'object' && !!presets.vendor[VENDOR_KEY];
+}
+
+/**
+ * Build the configure preset object for the active profile.
+ *
+ * When the project has its own `build` recipe (i.e. it's a publishable
+ * library with `build.generator` / `build.configure` declared), those are
+ * propagated into the generated preset so `wyvrnpm build` locally honours
+ * the same knobs the source-build + publish paths use. Without this, a
+ * publisher's recipe is effectively advisory at install-time (F15 fix).
+ *
+ * @param {object} args
+ * @param {string} args.profileName
+ * @param {string} args.profileHash
+ * @param {string} args.toolchainRelPath       Relative from project root, CMake-style
+ *                                             forward slashes.
+ * @param {string|null} [args.generator]       Single generator name to pin on the
+ *                                             preset (e.g. "Ninja Multi-Config").
+ *                                             Null / undefined → let CMake pick.
+ * @param {Record<string,string>|null} [args.extraCacheVariables]
+ *                                             Merged into cacheVariables alongside
+ *                                             `CMAKE_TOOLCHAIN_FILE`. Usually
+ *                                             derived from the project's own
+ *                                             `build.configure` -D args.
+ */
+function buildConfigurePreset({
+  profileName,
+  profileHash,
+  toolchainRelPath,
+  generator = null,
+  extraCacheVariables = null,
+  installDir = null,
+}) {
+  const binaryDir = `\${sourceDir}/build/wyvrn-${profileName}`;
+  // Spread `extraCacheVariables` FIRST, then the wyvrn-owned entries. This
+  // means the recipe cannot redirect `CMAKE_TOOLCHAIN_FILE` — our dep
+  // injection is always the authoritative toolchain pointer. A malicious
+  // or sloppy recipe trying to override it is silently ignored, not
+  // quietly obeyed. Same protection applies to `CMAKE_INSTALL_PREFIX`:
+  // if a recipe declares `build.installDir`, we resolve it under the
+  // binary dir; any cacheVariables override is overwritten below.
+  const cacheVariables = {
+    ...(extraCacheVariables ?? {}),
+    CMAKE_TOOLCHAIN_FILE: `\${sourceDir}/${toolchainRelPath}`,
+  };
+  if (installDir) {
+    // `installDir` in wyvrn.json is defined as relative to the binary dir
+    // (same semantics as the source-build path, which passes
+    // -DCMAKE_INSTALL_PREFIX=<buildDir>/<installDir>). Without this, a
+    // `wyvrnpm build --install` falls back to CMake's system default —
+    // on Windows that's `C:/Program Files (x86)/<Project>`, which needs
+    // admin rights and almost always fails.
+    cacheVariables.CMAKE_INSTALL_PREFIX = `${binaryDir}/${installDir}`;
+  }
+  const preset = {
+    name:         `wyvrn-${profileName}`,
+    displayName:  `wyvrnpm (${profileName})`,
+    description:  `Generated by wyvrnpm install — profile hash ${profileHash}`,
+    binaryDir,
+    cacheVariables,
+  };
+  if (generator) preset.generator = generator;
+  return preset;
+}
+
+/**
+ * Two build presets per configure preset: Debug and Release.
+ *
+ * @param {string} profileName
+ * @returns {Array<object>}
+ */
+function buildBuildPresets(profileName) {
+  const config = `wyvrn-${profileName}`;
+  return [
+    {
+      name:            `${config}-debug`,
+      displayName:     `wyvrn ${profileName} (Debug)`,
+      configurePreset: config,
+      configuration:   'Debug',
+    },
+    {
+      name:            `${config}-release`,
+      displayName:     `wyvrn ${profileName} (Release)`,
+      configurePreset: config,
+      configuration:   'Release',
+    },
+  ];
+}
+
+/**
+ * Build a fresh presets file from scratch (no prior content to merge).
+ */
+function buildFreshPresetsFile({
+  profileName,
+  profileHash,
+  toolchainRelPath,
+  generator = null,
+  extraCacheVariables = null,
+  installDir = null,
+}) {
+  return {
+    version: SCHEMA_VERSION,
+    vendor: {
+      [VENDOR_KEY]: {
+        profileName,
+        profileHash,
+        generatedAt: new Date().toISOString(),
+      },
+    },
+    configurePresets: [buildConfigurePreset({
+      profileName, profileHash, toolchainRelPath, generator, extraCacheVariables, installDir,
+    })],
+    buildPresets: buildBuildPresets(profileName),
+  };
+}
+
+/**
+ * Merge the current profile's presets into an existing wyvrnpm-generated
+ * file. Presets with matching `name` are replaced; others are preserved so
+ * `wyvrnpm install --profile release` followed by `wyvrnpm install --profile
+ * debug` leaves both profiles available in the file.
+ *
+ * @param {object} existing
+ * @param {object} args  forwarded to the preset builders
+ * @returns {object}
+ */
+function mergeIntoExisting(existing, {
+  profileName,
+  profileHash,
+  toolchainRelPath,
+  generator = null,
+  extraCacheVariables = null,
+  installDir = null,
+}) {
+  const newConfigure = buildConfigurePreset({
+    profileName, profileHash, toolchainRelPath, generator, extraCacheVariables, installDir,
+  });
+  const newBuilds    = buildBuildPresets(profileName);
+  const newConfigureNames = new Set([newConfigure.name]);
+  const newBuildNames     = new Set(newBuilds.map((b) => b.name));
+
+  const configurePresets = (existing.configurePresets ?? []).filter((p) => !newConfigureNames.has(p.name));
+  configurePresets.push(newConfigure);
+
+  const buildPresets = (existing.buildPresets ?? []).filter((p) => !newBuildNames.has(p.name));
+  buildPresets.push(...newBuilds);
+
+  return {
+    ...existing,
+    version: existing.version ?? SCHEMA_VERSION,
+    vendor: {
+      ...(existing.vendor ?? {}),
+      [VENDOR_KEY]: {
+        profileName,
+        profileHash,
+        generatedAt: new Date().toISOString(),
+      },
+    },
+    configurePresets,
+    buildPresets,
+  };
+}
+
+/**
+ * Write a CMakePresets.json (or CMakeUserPresets.json, as fallback) under
+ * `projectRoot`. Never overwrites a user-owned file.
+ *
+ * Resolution order:
+ *   1. CMakePresets.json
+ *      - Does not exist     → create it.
+ *      - Exists, wyvrn-gen  → merge into it.
+ *      - Exists, user-owned → leave alone, fall through.
+ *   2. CMakeUserPresets.json
+ *      - Does not exist     → create it.
+ *      - Exists, wyvrn-gen  → merge into it.
+ *      - Exists, user-owned → skip (action: "skipped").
+ *
+ * @param {object} args
+ * @param {string} args.projectRoot       Directory containing top-level CMakeLists.txt.
+ * @param {string} args.profileName
+ * @param {string} args.profileHash
+ * @param {string} args.toolchainRelPath  CMake-style forward slashes, relative to projectRoot.
+ * @param {string|null} [args.generator]  Propagated onto the configure preset's `generator` field.
+ * @param {Record<string,string>|null} [args.extraCacheVariables]
+ *                                        Merged into the configure preset's `cacheVariables`.
+ * @returns {{ path: string|null, action: 'created'|'updated'|'skipped', isUser: boolean }}
+ */
+function generateCMakePresets({
+  projectRoot,
+  profileName,
+  profileHash,
+  toolchainRelPath,
+  generator = null,
+  extraCacheVariables = null,
+  installDir = null,
+}) {
+  const args = { profileName, profileHash, toolchainRelPath, generator, extraCacheVariables, installDir };
+  const candidates = [
+    { filePath: path.join(projectRoot, 'CMakePresets.json'),     isUser: false },
+    { filePath: path.join(projectRoot, 'CMakeUserPresets.json'), isUser: true  },
+  ];
+
+  for (const { filePath, isUser } of candidates) {
+    if (!fs.existsSync(filePath)) {
+      const content = buildFreshPresetsFile(args);
+      fs.writeFileSync(filePath, JSON.stringify(content, null, 2) + '\n', 'utf8');
+      return { path: filePath, action: 'created', isUser };
+    }
+
+    const existing = safeReadJson(filePath);
+    if (isWyvrnGenerated(existing)) {
+      const merged = mergeIntoExisting(existing, args);
+      fs.writeFileSync(filePath, JSON.stringify(merged, null, 2) + '\n', 'utf8');
+      return { path: filePath, action: 'updated', isUser };
+    }
+
+    // User-owned — do not touch, try next candidate.
+  }
+
+  return { path: null, action: 'skipped', isUser: false };
+}
+
+module.exports = {
+  generateCMakePresets,
+  // Exported for tests
+  isWyvrnGenerated,
+  buildConfigurePreset,
+  buildBuildPresets,
+  buildFreshPresetsFile,
+  mergeIntoExisting,
+  VENDOR_KEY,
+  SCHEMA_VERSION,
+};

package/src/toolchain/template.cmake

@@ -0,0 +1,66 @@
+# Generated by wyvrnpm — do not edit.
+# Regenerated on every `wyvrnpm install`.
+#
+# Usage:
+#   cmake -B build -S . -DCMAKE_TOOLCHAIN_FILE=wyvrn_internal/wyvrn_toolchain.cmake
+#
+# Profile : {{PROFILE_NAME}}  [{{PROFILE_HASH}}]
+# Generated: {{GENERATED_AT}}
+
+if(WYVRNPM_TOOLCHAIN_INCLUDED)
+    return()
+endif()
+set(WYVRNPM_TOOLCHAIN_INCLUDED TRUE)
+
+# ── Active build profile (copied verbatim from wyvrn_profile.json) ────────────
+set(WYVRN_PROFILE_NAME             "{{PROFILE_NAME}}")
+set(WYVRN_PROFILE_HASH             "{{PROFILE_HASH}}")
+set(WYVRN_PROFILE_OS               "{{PROFILE_OS}}")
+set(WYVRN_PROFILE_ARCH             "{{PROFILE_ARCH}}")
+set(WYVRN_PROFILE_COMPILER         "{{PROFILE_COMPILER}}")
+set(WYVRN_PROFILE_COMPILER_VERSION "{{PROFILE_COMPILER_VERSION}}")
+set(WYVRN_PROFILE_CPPSTD           "{{PROFILE_CPPSTD}}")
+set(WYVRN_PROFILE_RUNTIME          "{{PROFILE_RUNTIME}}")
+
+# ── Path to wyvrnpm's bundled CMake utilities (variables.cmake, etc.) ─────────
+# Resolved at generation time so the toolchain works regardless of whether
+# wyvrnpm was installed globally, locally, or via npx.
+set(WYVRNPM_CMAKE_DIR "{{WYVRNPM_CMAKE_DIR}}")
+
+# ── C++ standard ──────────────────────────────────────────────────────────────
+if(NOT DEFINED CMAKE_CXX_STANDARD)
+    set(CMAKE_CXX_STANDARD {{PROFILE_CPPSTD}})
+    set(CMAKE_CXX_STANDARD_REQUIRED ON)
+    set(CMAKE_CXX_EXTENSIONS OFF)
+endif()
+
+# ── MSVC runtime library ──────────────────────────────────────────────────────
+# Only meaningful when the actual compiler is MSVC. CMake ignores this on other
+# compilers, so setting it unconditionally is safe.
+if("${WYVRN_PROFILE_RUNTIME}" STREQUAL "dynamic")
+    set(CMAKE_MSVC_RUNTIME_LIBRARY "MultiThreaded$<$<CONFIG:Debug>:Debug>DLL")
+elseif("${WYVRN_PROFILE_RUNTIME}" STREQUAL "static")
+    set(CMAKE_MSVC_RUNTIME_LIBRARY "MultiThreaded$<$<CONFIG:Debug>:Debug>")
+endif()
+
+# ── Position-independent code (sensible default for mixed static/shared) ──────
+if(NOT DEFINED CMAKE_POSITION_INDEPENDENT_CODE)
+    set(CMAKE_POSITION_INDEPENDENT_CODE ON)
+endif()
+
+# ── CMAKE_PREFIX_PATH: so find_package(<dep> CONFIG) finds installed deps ─────
+list(PREPEND CMAKE_PREFIX_PATH
+{{PREFIX_PATH_ENTRIES}}
+)
+
+# ── CMAKE_MODULE_PATH: so include(<script>) finds bundled *.cmake files ───────
+list(PREPEND CMAKE_MODULE_PATH
+    "${WYVRNPM_CMAKE_DIR}"
+)
+
+# ── Post-project() hook ───────────────────────────────────────────────────────
+# CMAKE_PROJECT_INCLUDE runs after the first project() call, which is when
+# CMAKE_SYSTEM_NAME / CMAKE_CXX_COMPILER_ID / CMAKE_SIZEOF_VOID_P become valid.
+# The bundled utilities (variables.cmake etc.) rely on those — so they must be
+# included from here, not from the toolchain body above.
+set(CMAKE_PROJECT_INCLUDE "${CMAKE_CURRENT_LIST_DIR}/wyvrn_deps.cmake")