memtrace 0.3.42 → 0.3.44

package/bin/memtrace.js

@@ -138,12 +138,17 @@ if (args[0] === "install" || args[0] === "update" || args[0] === "upgrade") {
   const memtraceCmd = platformBinary("memtrace", process.platform);
 
   process.stdout.write("memtrace: fetching latest from npm registry…\n");
+  // Tell the postinstall RTK opt-in to stay silent — *we* own the
+  // prompt and have a clean TTY (npm's progress spinner shares the
+  // user's terminal with the postinstall, which makes its prompt
+  // unreadable and readline picks up a phantom EOF, default-yes
+  // installing RTK without the user seeing the question).
   const installResult = spawnSync(
     npmCmd,
     ["install", "-g", "memtrace@latest"],
     spawnOptionsForPlatform(process.platform, {
       stdio: "inherit",
-      env: process.env,
+      env: { ...process.env, MEMTRACE_INSTALL_PARENT: "1" },
     })
   );
 

package/install.js

@@ -197,6 +197,14 @@ if (require.main === module) {
     const readline = require("readline");
     const rtk = require("./lib/rtk-integration");
 
+    // Nested under `memtrace install` shim? The parent owns the prompt
+    // and has a clean TTY. Two prompt paths racing over the same
+    // terminal means npm's progress spinner overwrites the question
+    // line and readline observes a phantom EOF — user gets RTK
+    // installed without ever seeing or answering Y/n. Bail out here;
+    // bin/memtrace.js will run the prompt cleanly after npm exits.
+    if (rtk.isPostinstallNestedUnderShim({ env: process.env })) return;
+
     let alreadyInstalled = false;
     try { alreadyInstalled = rtk.detectRtk(); } catch (_) { /* skip */ }
 

package/lib/rtk-integration.js

@@ -53,6 +53,23 @@ function isRtkAutoInstall(input = {}) {
     return isTruthyEnv(env.MEMTRACE_AUTO_INSTALL_RTK);
 }
 
+/**
+ * True when this postinstall is running nested under the `memtrace
+ * install` shim — i.e. the parent process is bin/memtrace.js spawning
+ * `npm install -g memtrace@latest`. The parent owns user interaction
+ * (it has a clean TTY, and it runs its own RTK opt-in flow after npm
+ * exits). The nested postinstall must therefore stay completely silent
+ * for RTK — otherwise both prompt paths race over the same terminal,
+ * the spinner overwrites the prompt, and readline picks up a phantom
+ * EOF.
+ *
+ * Coordinated via `MEMTRACE_INSTALL_PARENT=1` in the spawn env.
+ */
+function isPostinstallNestedUnderShim(input = {}) {
+    const env = input.env || {};
+    return isTruthyEnv(env.MEMTRACE_INSTALL_PARENT);
+}
+
 // ── Decision helpers ────────────────────────────────────────────────
 
 /**
@@ -186,6 +203,91 @@ function detectHomebrew(opts = {}) {
     return r.status === 0;
 }
 
+// ── rtk init (hook activation) ──────────────────────────────────────
+//
+// `brew install rtk` (or curl|sh) only installs the binary. Without
+// `rtk init -g`, RTK is dormant — Claude Code does NOT auto-rewrite
+// commands through the hook, so the user sees zero token savings.
+// To deliver "maximum token savings" we must chain rtk init right
+// after the binary install.
+//
+// rtk init -g --auto-patch:
+//   - installs hook to ~/.claude/hooks/rtk-rewrite.sh
+//   - creates ~/.claude/RTK.md (10-line breadcrumb)
+//   - adds @RTK.md reference to ~/.claude/CLAUDE.md
+//   - patches ~/.claude/settings.json's hooks (with .bak)
+//
+// The CLAUDE.md / settings.json edits coexist with memtrace's own
+// blocks via the sentinel-installer contract (see test/uninstall-
+// cleanliness.test.js's 7 coexistence tests).
+
+/**
+ * Choose the rtk init command to run, or null to skip.
+ *
+ * Env-var overrides:
+ *   MEMTRACE_NO_RTK_INIT=1  → skip init entirely (binary only)
+ *   MEMTRACE_RTK_INIT_MODE  → "global" (default) | "hook-only" | "local"
+ */
+function chooseRtkInitCommand(input = {}) {
+    const env = (input && input.env) || {};
+    if (isTruthyEnv(env.MEMTRACE_NO_RTK_INIT)) return null;
+
+    const mode = (env.MEMTRACE_RTK_INIT_MODE || "global").trim().toLowerCase();
+    switch (mode) {
+        case "local":
+            return ["rtk", "init", "--auto-patch"];
+        case "hook-only":
+            return ["rtk", "init", "-g", "--hook-only", "--auto-patch"];
+        case "global":
+        default:
+            return ["rtk", "init", "-g", "--auto-patch"];
+    }
+}
+
+/**
+ * Pure check: has rtk init already been run? Detects by looking for
+ * the two artefacts rtk init -g writes. Avoids re-running on every
+ * memtrace upgrade.
+ */
+function isRtkInitAlreadyDone(input = {}) {
+    const home = input && input.home;
+    if (!home) return false;
+    const fs = (input && input.fs) || require("fs");
+    const path = (input && input.path) || require("path");
+    const hookPath = path.join(home, ".claude", "hooks", "rtk-rewrite.sh");
+    const rtkMdPath = path.join(home, ".claude", "RTK.md");
+    return fs.existsSync(hookPath) && fs.existsSync(rtkMdPath);
+}
+
+/**
+ * Side-effecting: run `rtk init` with the chosen flags. Returns
+ *   { ok: boolean, ranCommand?: string[], error?: string, skipped?: string }
+ */
+function runRtkInit(opts = {}) {
+    const env = opts.env || process.env;
+    const home = opts.home || require("os").homedir();
+    const spawnSync = opts.spawnSync || require("child_process").spawnSync;
+
+    const cmd = chooseRtkInitCommand({ env });
+    if (!cmd) {
+        return { ok: true, skipped: "MEMTRACE_NO_RTK_INIT" };
+    }
+    if (isRtkInitAlreadyDone({ home })) {
+        return { ok: true, skipped: "already-initialized" };
+    }
+
+    const [bin, ...args] = cmd;
+    const r = spawnSync(bin, args, { stdio: "inherit", timeout: 30000 });
+    if (r.status !== 0) {
+        return {
+            ok: false,
+            ranCommand: cmd,
+            error: `${bin} ${args.join(" ")} exited with status ${r.status}`,
+        };
+    }
+    return { ok: true, ranCommand: cmd };
+}
+
 /**
  * Side-effecting RTK installer. Spawns the chosen install command,
  * inheriting stdio so the user sees progress. Returns
@@ -229,7 +331,28 @@ function installRtk(opts = {}) {
         };
     }
 
-    return { ok: true, method: strategy.method };
+    // CRITICAL: run rtk init -g --auto-patch so the hook actually
+    // activates. Without this, the binary is installed but RTK is
+    // dormant — Claude Code does not auto-rewrite anything and the
+    // user gets zero token savings. This is what delivers the
+    // "maximum token savings" promise of the opt-in.
+    const initResult = runRtkInit({ spawnSync });
+    if (!initResult.ok) {
+        return {
+            ok: false,
+            method: strategy.method,
+            error:
+                `binary installed but \`rtk init\` failed: ${initResult.error}. ` +
+                `Run manually: rtk init -g --auto-patch`,
+        };
+    }
+
+    return {
+        ok: true,
+        method: strategy.method,
+        initSkipped: initResult.skipped, // "already-initialized" | "MEMTRACE_NO_RTK_INIT" | undefined
+        initCommand: initResult.ranCommand,
+    };
 }
 
 /**
@@ -275,19 +398,27 @@ function openTtyStreams(opts = {}) {
     const fs = opts.fs || require("fs");
     const tty = opts.tty || require("tty");
 
-    let fd;
+    // Open TWO fds — one for read, one for write. Sharing a single
+    // r+ fd between ReadStream and WriteStream causes readline to
+    // immediately observe EOF on some setups (notably when a parent
+    // process is also writing progress to the same controlling tty,
+    // e.g. npm's spinner during `memtrace install`).
+    let inFd, outFd;
     try {
-        fd = fs.openSync("/dev/tty", "r+");
+        inFd = fs.openSync("/dev/tty", "r");
+        outFd = fs.openSync("/dev/tty", "w");
     } catch (_) {
+        if (inFd != null) { try { fs.closeSync(inFd); } catch (_) {} }
         return null; // no controlling tty (Docker, CI, etc.)
     }
 
     let input, output;
     try {
-        input = new tty.ReadStream(fd);
-        output = new tty.WriteStream(fd);
+        input = new tty.ReadStream(inFd);
+        output = new tty.WriteStream(outFd);
     } catch (e) {
-        try { fs.closeSync(fd); } catch (_) { /* best-effort */ }
+        try { fs.closeSync(inFd); } catch (_) {}
+        try { fs.closeSync(outFd); } catch (_) {}
         return null;
     }
 
@@ -341,9 +472,12 @@ module.exports = {
     // Pure helpers
     isRtkPromptDisabled,
     isRtkAutoInstall,
+    isPostinstallNestedUnderShim,
     shouldPromptForRtk,
     effectiveRtkAction,
     chooseInstallStrategy,
+    chooseRtkInitCommand,
+    isRtkInitAlreadyDone,
     rtkHintLine,
     parseRtkAnswer,
     rtkPromptText,
@@ -351,6 +485,7 @@ module.exports = {
     detectRtk,
     detectHomebrew,
     installRtk,
+    runRtkInit,
     openTtyStreams,
     // Constants
     RTK_INSTALL_URL,

package/package.json

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