memtrace 0.3.55 → 0.3.67

package/install.js

@@ -9,6 +9,16 @@ const { platformBinary, spawnOptionsForPlatform } = require("./lib/spawn-helper"
 const { installToFs } = require("./lib/claude-integration");
 
 // ── Platform binary resolution (preserved from legacy) ───────────────────────
+//
+// Two parallel package families on x86_64:
+//   • default          — bundles MS prebuilt libonnxruntime (AVX2 baseline)
+//   • `*-noavx2`       — bundles a from-source build with AVX/AVX2/AVX-512
+//                        codegen disabled, for Ivy Bridge / Xeon E5 v2 etc.
+// Apple Silicon and Linux ARM don't need the split (no AVX in the ISA).
+//
+// The choice is made at install time by `hasAvx2()`. Users can force the
+// no-AVX2 variant via `MEMTRACE_FORCE_NOAVX2=1` (handy for testing or
+// when CPU detection is unreliable in containerised envs).
 
 const PLATFORM_MAP = {
   "darwin-arm64": "@memtrace/darwin-arm64",
@@ -18,13 +28,94 @@ const PLATFORM_MAP = {
   "win32-x64":    "@memtrace/win32-x64",
 };
 
+const NOAVX2_PLATFORM_MAP = {
+  "linux-x64":  "@memtrace/linux-x64-noavx2",
+  "win32-x64":  "@memtrace/win32-x64-noavx2",
+};
+
 function getPlatformKey() {
   return `${os.platform()}-${os.arch()}`;
 }
 
+// Best-effort runtime AVX2 check. Returns `true` (AVX2 present) when we
+// can't tell — the AVX2 path is the common case and the runtime gate in
+// the binary catches the wrong choice with a clean error if we guess
+// wrong. This is install-time best-effort; the actual bullet-proof check
+// happens at process start.
+function hasAvx2() {
+  if (process.env.MEMTRACE_FORCE_NOAVX2 === "1") {
+    return false;
+  }
+  if (process.env.MEMTRACE_FORCE_AVX2 === "1") {
+    return true;
+  }
+  const arch = os.arch();
+  // Only x86_64 CPUs have AVX as a concept. ARM hosts skip the check.
+  if (arch !== "x64") {
+    return true;
+  }
+  const platform = os.platform();
+  try {
+    if (platform === "linux") {
+      const cpuinfo = fs.readFileSync("/proc/cpuinfo", "utf8");
+      // `flags` line on Intel, `Features` on some emulators.
+      return /\b(avx2)\b/.test(cpuinfo);
+    }
+    if (platform === "win32") {
+      // PowerShell exposes ProcessorFeaturePresent via the kernel32 API
+      // through the PROCESSOR_FEATURE enum. PF_AVX2_INSTRUCTIONS_AVAILABLE
+      // is feature ID 40. A fresh PS process is ~300 ms — fine for an
+      // install-time hook that only runs once.
+      const result = spawnSync(
+        "powershell",
+        [
+          "-NoProfile",
+          "-NonInteractive",
+          "-Command",
+          "[System.Reflection.Assembly]::Load('mscorlib') | Out-Null; " +
+            "Add-Type -MemberDefinition '[DllImport(\"kernel32\")] " +
+            "public static extern bool IsProcessorFeaturePresent(uint f);' " +
+            "-Name PF -Namespace Memtrace; " +
+            "[Memtrace.PF]::IsProcessorFeaturePresent(40)",
+        ],
+        { encoding: "utf8", timeout: 5000 }
+      );
+      const out = (result.stdout || "").trim().toLowerCase();
+      if (out === "true") return true;
+      if (out === "false") return false;
+      return true; // ambiguous → assume AVX2
+    }
+    if (platform === "darwin") {
+      // sysctl exposes CPU feature leaves directly. macOS x86_64 was only
+      // ever shipped on Sandy Bridge → Coffee Lake; AVX2 lands in Haswell
+      // (mid-2013), which lines up with the 2013+ Mac Pro and every Mac
+      // Apple sold from late 2013 onward. We probe explicitly anyway in
+      // case someone is running on a Hackintosh with an older CPU.
+      const result = spawnSync("sysctl", ["-n", "machdep.cpu.leaf7_features"], {
+        encoding: "utf8",
+        timeout: 2000,
+      });
+      const out = (result.stdout || "").toUpperCase();
+      return /AVX2/.test(out);
+    }
+  } catch (_) {
+    // Detection failed (locked-down container, missing /proc, sysctl
+    // gone, etc.). Default to the AVX2 path — the runtime gate will
+    // catch a wrong guess with a clean error.
+  }
+  return true;
+}
+
+function platformPackageName(key) {
+  if (!hasAvx2() && Object.prototype.hasOwnProperty.call(NOAVX2_PLATFORM_MAP, key)) {
+    return NOAVX2_PLATFORM_MAP[key];
+  }
+  return PLATFORM_MAP[key];
+}
+
 function getBinaryPath() {
   const key = getPlatformKey();
-  const pkg = PLATFORM_MAP[key];
+  const pkg = platformPackageName(key);
   if (!pkg) {
     throw new Error(
       `Memtrace does not support platform: ${key}\n` +
@@ -33,16 +124,42 @@ function getBinaryPath() {
   }
   const ext = os.platform() === "win32" ? ".exe" : "";
   const binaryName = `memtrace${ext}`;
+  try {
+    return require.resolve(`${pkg}/bin/${binaryName}`);
+  } catch {
+    selfHealPlatformPackage();
+  }
   try {
     return require.resolve(`${pkg}/bin/${binaryName}`);
   } catch {
     throw new Error(
-      `Could not find memtrace binary for ${key}.\n` +
+      `Could not find memtrace binary for ${key} (package ${pkg}).\n` +
       `Try reinstalling: npm install -g memtrace`
     );
   }
 }
 
+function buildSelfHealInstallArgs(packageDir, versioned) {
+  return ["install", "--prefix", packageDir, "--no-save", "--include=optional", versioned];
+}
+
+function buildSelfHealEnv(env) {
+  const next = { ...env };
+
+  // During `npm install -g memtrace`, npm exposes global-mode config through
+  // the environment. A nested `npm install` can inherit that and install the
+  // platform package into the global prefix instead of this package directory.
+  delete next.npm_config_global;
+  delete next.NPM_CONFIG_GLOBAL;
+  next.npm_config_global = "false";
+
+  return next;
+}
+
+function getPinnedPlatformVersion(packageJson, platformPackage) {
+  return packageJson.optionalDependencies?.[platformPackage] ?? packageJson.version;
+}
+
 // ── Optional-dep self-heal ───────────────────────────────────────────────────
 //
 // `optionalDependencies` is supposed to fan out platform binaries
@@ -56,16 +173,16 @@ function getBinaryPath() {
 // versioned name comes from the same map the runtime resolver uses.
 function selfHealPlatformPackage() {
   const key = getPlatformKey();
-  const pkg = PLATFORM_MAP[key];
-  if (!pkg) return; // unsupported platform — getBinaryPath will surface it later
+  const pkg = platformPackageName(key);
+  if (!pkg) return false; // unsupported platform — getBinaryPath will surface it later
   try {
     require.resolve(`${pkg}/package.json`);
-    return; // already installed via optionalDependencies
+    return true; // already installed via optionalDependencies
   } catch (_) {
     // not installed — fall through to install
   }
   const ourPkg = require("./package.json");
-  const versioned = `${pkg}@${ourPkg.version}`;
+  const versioned = `${pkg}@${getPinnedPlatformVersion(ourPkg, pkg)}`;
   console.log(
     `memtrace: optional platform dep ${pkg} was not installed; ` +
     `running 'npm install ${versioned}' to fetch it…`
@@ -78,11 +195,11 @@ function selfHealPlatformPackage() {
   // `test/spawn-helper.test.js` for the full regression coverage.
   const result = spawnSync(
     platformBinary("npm", process.platform),
-    ["install", "--no-save", versioned],
+    buildSelfHealInstallArgs(__dirname, versioned),
     spawnOptionsForPlatform(process.platform, {
       cwd: __dirname,
       stdio: "inherit",
-      env: process.env,
+      env: buildSelfHealEnv(process.env),
     })
   );
   if (result.status !== 0) {
@@ -90,7 +207,9 @@ function selfHealPlatformPackage() {
       `memtrace: self-heal install of ${versioned} failed (exit ${result.status}). ` +
       `Run manually: npm install -g memtrace --include=optional`
     );
+    return false;
   }
+  return true;
 }
 
 // ── Main postinstall ─────────────────────────────────────────────────────────
@@ -176,4 +295,12 @@ if (require.main === module) {
   }
 }
 
-module.exports = { getBinaryPath };
+module.exports = {
+  getBinaryPath,
+  selfHealPlatformPackage,
+  buildSelfHealEnv,
+  buildSelfHealInstallArgs,
+  getPinnedPlatformVersion,
+  hasAvx2,
+  platformPackageName,
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "memtrace",
-  "version": "0.3.55",
+  "version": "0.3.67",
   "description": "Code intelligence graph — MCP server + AI agent skills + visualization UI",
   "keywords": [
     "mcp",
@@ -39,9 +39,11 @@
     "fs-extra": "^11.0.0"
   },
   "optionalDependencies": {
-    "@memtrace/darwin-arm64": "0.3.55",
-    "@memtrace/linux-x64": "0.3.55",
-    "@memtrace/win32-x64": "0.3.55"
+    "@memtrace/darwin-arm64": "0.3.67",
+    "@memtrace/linux-x64": "0.3.67",
+    "@memtrace/win32-x64": "0.3.67",
+    "@memtrace/linux-x64-noavx2": "0.3.67",
+    "@memtrace/win32-x64-noavx2": "0.3.67"
   },
   "engines": {
     "node": ">=18"