memtrace 0.3.56 → 0.3.70

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` +
@@ -42,7 +133,7 @@ function getBinaryPath() {
     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`
     );
   }
@@ -82,7 +173,7 @@ function getPinnedPlatformVersion(packageJson, platformPackage) {
 // versioned name comes from the same map the runtime resolver uses.
 function selfHealPlatformPackage() {
   const key = getPlatformKey();
-  const pkg = PLATFORM_MAP[key];
+  const pkg = platformPackageName(key);
   if (!pkg) return false; // unsupported platform — getBinaryPath will surface it later
   try {
     require.resolve(`${pkg}/package.json`);
@@ -210,4 +301,6 @@ module.exports = {
   buildSelfHealEnv,
   buildSelfHealInstallArgs,
   getPinnedPlatformVersion,
+  hasAvx2,
+  platformPackageName,
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "memtrace",
-  "version": "0.3.56",
+  "version": "0.3.70",
   "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.70",
+    "@memtrace/linux-x64": "0.3.70",
+    "@memtrace/win32-x64": "0.3.70",
+    "@memtrace/linux-x64-noavx2": "0.3.70",
+    "@memtrace/win32-x64-noavx2": "0.3.70"
   },
   "engines": {
     "node": ">=18"