engramx 2.0.2 → 2.1.0

package/dist/{core-6IY5L6II.js → core-TSXA5XZH.js}

@@ -11,7 +11,7 @@ import {
   path,
   query,
   stats
-} from "./chunk-SJT7VS2G.js";
+} from "./chunk-ZVWRIVWQ.js";
 import "./chunk-PEH54LYC.js";
 export {
   benchmark,

package/dist/{cursor-mdc-GJ7E5LDD.js → cursor-mdc-VEOFFDVO.js}

@@ -33,7 +33,7 @@ function buildSection(heading, bullets) {
   return [`## ${heading}`, "", ...bullets, ""].join("\n");
 }
 async function generateCursorMdc(projectPath) {
-  const { getStore } = await import("./core-6IY5L6II.js");
+  const { getStore } = await import("./core-TSXA5XZH.js");
   const store = await getStore(projectPath);
   try {
     const allNodes = store.getAllNodes();

package/dist/{exporter-GWU2GF23.js → exporter-AWXS34AS.js}

@@ -12,7 +12,7 @@ function buildSection(heading, nodes) {
   return [`## ${heading}`, "", ...bullets, ""].join("\n");
 }
 async function exportCcs(projectRoot) {
-  const { getStore } = await import("./core-6IY5L6II.js");
+  const { getStore } = await import("./core-TSXA5XZH.js");
   const store = await getStore(projectRoot);
   try {
     const allNodes = store.getAllNodes();

package/dist/{importer-V62NGZRK.js → importer-3Q5M6QBL.js}

@@ -25,7 +25,7 @@ async function importCcs(projectRoot) {
   if (!existsSync(filePath)) {
     return { nodesCreated: 0, sectionsFound: 0 };
   }
-  const { getStore } = await import("./core-6IY5L6II.js");
+  const { getStore } = await import("./core-TSXA5XZH.js");
   const store = await getStore(projectRoot);
   try {
     const raw = readFileSync(filePath, "utf-8");

package/dist/index.js

@@ -4,7 +4,7 @@ import {
   generateSummary,
   install,
   uninstall
-} from "./chunk-C6GBUOAL.js";
+} from "./chunk-4XA6ENNL.js";
 import {
   GraphStore,
   SUPPORTED_EXTENSIONS,
@@ -23,7 +23,7 @@ import {
   sliceGraphemeSafe,
   stats,
   truncateGraphemeSafe
-} from "./chunk-SJT7VS2G.js";
+} from "./chunk-ZVWRIVWQ.js";
 import "./chunk-PEH54LYC.js";
 export {
   GraphStore,

package/dist/install-YVMVCFQW.js

@@ -0,0 +1,121 @@
+// src/update/install.ts
+import { execFileSync, spawnSync } from "child_process";
+import { existsSync } from "fs";
+import { dirname } from "path";
+import { fileURLToPath } from "url";
+var PACKAGE_NAME = "engramx";
+function detectPackageManager() {
+  let installPath = null;
+  try {
+    installPath = dirname(fileURLToPath(import.meta.url));
+  } catch {
+    installPath = null;
+  }
+  if (!installPath) {
+    return { manager: null, installPath: null, reason: "none" };
+  }
+  const lower = installPath.toLowerCase();
+  if (lower.includes("/pnpm/") || lower.includes("\\pnpm\\")) {
+    return { manager: "pnpm", installPath, reason: "pnpm-path-marker" };
+  }
+  if (lower.includes("/.yarn/") || lower.includes("\\.yarn\\")) {
+    return { manager: "yarn", installPath, reason: "yarn-path-marker" };
+  }
+  if (lower.includes("/bun/") || lower.includes("\\bun\\")) {
+    return { manager: "bun", installPath, reason: "bun-path-marker" };
+  }
+  return { manager: "npm", installPath, reason: "npm-fallback" };
+}
+function upgradeCommand(manager, channel = "latest") {
+  const target = `${PACKAGE_NAME}@${channel}`;
+  switch (manager) {
+    case "npm":
+      return { cmd: "npm", args: ["install", "-g", target] };
+    case "pnpm":
+      return { cmd: "pnpm", args: ["add", "-g", target] };
+    case "yarn":
+      return { cmd: "yarn", args: ["global", "add", target] };
+    case "bun":
+      return { cmd: "bun", args: ["add", "-g", target] };
+  }
+}
+function managerOnPath(manager) {
+  try {
+    const r = spawnSync(manager, ["--version"], {
+      encoding: "utf-8",
+      timeout: 2e3
+    });
+    return r.status === 0;
+  } catch {
+    return false;
+  }
+}
+function runUpgrade(opts = {}) {
+  const channel = opts.channel ?? "latest";
+  const detected = opts.manager !== void 0 ? { manager: opts.manager, installPath: null, reason: "override" } : detectPackageManager();
+  if (detected.manager === null) {
+    return {
+      ok: false,
+      message: "Could not detect how engram was installed. Run your package manager's upgrade manually.",
+      executed: null,
+      stderrTail: null
+    };
+  }
+  if (!managerOnPath(detected.manager)) {
+    return {
+      ok: false,
+      message: `${detected.manager} not found on PATH. Install it or use a different package manager.`,
+      executed: null,
+      stderrTail: null
+    };
+  }
+  const { cmd, args } = upgradeCommand(detected.manager, channel);
+  const executed = `${cmd} ${args.join(" ")}`;
+  if (opts.dryRun) {
+    return {
+      ok: true,
+      message: `Would run: ${executed}`,
+      executed,
+      stderrTail: null
+    };
+  }
+  try {
+    execFileSync(cmd, args, {
+      stdio: "inherit",
+      timeout: 12e4
+    });
+    return {
+      ok: true,
+      message: `Upgrade complete via ${detected.manager}.`,
+      executed,
+      stderrTail: null
+    };
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : String(err);
+    const tail = msg.split("\n").slice(-5).join("\n");
+    return {
+      ok: false,
+      message: `Upgrade failed via ${detected.manager}. Try manually: ${executed}`,
+      executed,
+      stderrTail: tail
+    };
+  }
+}
+function manualCommand(channel = "latest") {
+  return `npm install -g ${PACKAGE_NAME}@${channel}`;
+}
+function safeEnvironment() {
+  if (existsSync("/opt/homebrew/bin/engram") || existsSync("/usr/local/Homebrew/bin/engram")) {
+  }
+  return { ok: true };
+}
+var PACKAGE = PACKAGE_NAME;
+export {
+  PACKAGE,
+  detectPackageManager,
+  managerOnPath,
+  manualCommand,
+  runUpgrade,
+  safeEnvironment,
+  upgradeCommand
+};

package/dist/notify-5POGKMRX.js

@@ -0,0 +1,36 @@
+import {
+  cachePath,
+  isNewer,
+  optedOut
+} from "./chunk-RM2TBOVW.js";
+
+// src/update/notify.ts
+import chalk from "chalk";
+import { existsSync, readFileSync } from "fs";
+var printedThisProcess = false;
+function maybePrintUpdateHint(currentVersion) {
+  if (printedThisProcess) return null;
+  if (optedOut()) return null;
+  const path = cachePath();
+  if (!existsSync(path)) return null;
+  let latest = null;
+  try {
+    const parsed = JSON.parse(readFileSync(path, "utf-8"));
+    if (typeof parsed?.latest === "string") latest = parsed.latest;
+  } catch {
+    return null;
+  }
+  if (!latest) return null;
+  if (!isNewer(latest, currentVersion)) return null;
+  const hint = chalk.dim("\u{1F4A1} ") + chalk.yellow(`engram v${latest}`) + chalk.dim(" is available \u2014 run ") + chalk.white("engram update") + chalk.dim(` (you're on v${currentVersion})`);
+  process.stderr.write(hint + "\n");
+  printedThisProcess = true;
+  return hint;
+}
+function _resetPrintedFlag() {
+  printedThisProcess = false;
+}
+export {
+  _resetPrintedFlag,
+  maybePrintUpdateHint
+};

package/dist/report-C3GTM3HY.js

@@ -0,0 +1,12 @@
+import {
+  buildReport,
+  exportReport,
+  formatReport
+} from "./chunk-XVYE4OX2.js";
+import "./chunk-RM2TBOVW.js";
+import "./chunk-G4U3QOOW.js";
+export {
+  buildReport,
+  exportReport,
+  formatReport
+};

package/dist/serve.js

@@ -2,13 +2,14 @@
 import {
   MAX_MISTAKE_LABEL_CHARS,
   benchmark,
+  formatThousands,
   godNodes,
   mistakes,
   path,
   query,
   stats,
   truncateGraphemeSafe
-} from "./chunk-SJT7VS2G.js";
+} from "./chunk-ZVWRIVWQ.js";
 import "./chunk-PEH54LYC.js";
 
 // src/serve.ts
@@ -111,8 +112,8 @@ AMBIGUOUS: ${s.ambiguousPct}%`;
     case "benchmark": {
       const b = await benchmark(PROJECT_ROOT);
       return [
-        `Full corpus: ~${b.naiveFullCorpus.toLocaleString()} tokens`,
-        `Avg graph query: ~${b.avgQueryTokens.toLocaleString()} tokens`,
+        `Full corpus: ~${formatThousands(b.naiveFullCorpus)} tokens`,
+        `Avg graph query: ~${formatThousands(b.avgQueryTokens)} tokens`,
         `Reduction vs full corpus: ${b.reductionVsFull}x`,
         `Reduction vs relevant files: ${b.reductionVsRelevant}x`,
         "",

package/dist/{server-KUG7U6SG.js → server-A6MUVKQK.js}

@@ -10,9 +10,11 @@ import {
   safeEqual
 } from "./chunk-N6PPKOPK.js";
 import {
-  getComponentStatus,
   summarizeHookLog
-} from "./chunk-533LR4I7.js";
+} from "./chunk-XFE6ZANP.js";
+import {
+  getComponentStatus
+} from "./chunk-G4U3QOOW.js";
 import {
   readHookLog
 } from "./chunk-KL6NSPVA.js";
@@ -21,7 +23,7 @@ import {
   learn,
   query,
   stats
-} from "./chunk-SJT7VS2G.js";
+} from "./chunk-ZVWRIVWQ.js";
 import "./chunk-PEH54LYC.js";
 
 // src/server/http.ts

package/dist/{windsurf-rules-C7SVDHBL.js → windsurf-rules-RWPKBHRD.js}

@@ -7,7 +7,7 @@ function buildSection(heading, lines) {
   return [`## ${heading}`, "", ...lines, ""].join("\n");
 }
 async function generateWindsurfRules(projectRoot) {
-  const { getStore } = await import("./core-6IY5L6II.js");
+  const { getStore } = await import("./core-TSXA5XZH.js");
   const store = await getStore(projectRoot);
   try {
     const allNodes = store.getAllNodes();

package/dist/wizard-AOXWMSXW.js

@@ -0,0 +1,274 @@
+import {
+  buildReport,
+  formatReport
+} from "./chunk-XVYE4OX2.js";
+import "./chunk-RM2TBOVW.js";
+import {
+  installEngramHooks
+} from "./chunk-SMU4WR3D.js";
+import "./chunk-G4U3QOOW.js";
+import {
+  init
+} from "./chunk-ZVWRIVWQ.js";
+import "./chunk-PEH54LYC.js";
+
+// src/setup/wizard.ts
+import chalk from "chalk";
+import readline from "readline/promises";
+import { existsSync as existsSync2, readFileSync as readFileSync2, writeFileSync, mkdirSync } from "fs";
+import { dirname, join as join2, resolve as pathResolve } from "path";
+import { homedir as homedir2 } from "os";
+
+// src/setup/detect.ts
+import { existsSync, readFileSync } from "fs";
+import { join } from "path";
+import { homedir } from "os";
+function detectClaudeCode(projectRoot) {
+  const settingsCandidates = [
+    join(projectRoot, ".claude", "settings.local.json"),
+    join(projectRoot, ".claude", "settings.json"),
+    join(homedir(), ".claude", "settings.json")
+  ];
+  const settingsPresent = settingsCandidates.some(existsSync);
+  const claudeCliPresent = existsSync(join(homedir(), ".claude")) || existsSync("/usr/local/bin/claude") || existsSync(join(homedir(), ".local/bin/claude"));
+  const installed = settingsPresent || claudeCliPresent;
+  let configured = false;
+  try {
+    configured = settingsCandidates.filter(existsSync).some((p) => readFileSync(p, "utf-8").includes("engram intercept"));
+  } catch {
+    configured = false;
+  }
+  return {
+    name: "Claude Code",
+    installed,
+    configured,
+    status: !installed ? "not detected" : configured ? "Sentinel hook installed" : "detected \u2014 hook not yet installed"
+  };
+}
+function detectCursor(projectRoot) {
+  const cursorConfigs = [
+    join(homedir(), "Library/Application Support/Cursor"),
+    join(homedir(), ".config/Cursor"),
+    join(homedir(), "AppData/Roaming/Cursor")
+  ];
+  const installed = cursorConfigs.some(existsSync);
+  const configured = existsSync(
+    join(projectRoot, ".cursor", "rules", "engram-context.mdc")
+  );
+  return {
+    name: "Cursor",
+    installed,
+    configured,
+    status: !installed ? "not detected" : configured ? "MDC adapter present" : "detected \u2014 run `engram gen-mdc`"
+  };
+}
+function detectWindsurf(projectRoot) {
+  const configured = existsSync(join(projectRoot, ".windsurfrules"));
+  return {
+    name: "Windsurf",
+    installed: configured,
+    configured,
+    status: configured ? ".windsurfrules present" : "run `engram gen-windsurfrules` to add"
+  };
+}
+function detectContinue() {
+  const path = join(homedir(), ".continue", "config.json");
+  const installed = existsSync(path);
+  let configured = false;
+  if (installed) {
+    try {
+      configured = readFileSync(path, "utf-8").includes("engram");
+    } catch {
+      configured = false;
+    }
+  }
+  return {
+    name: "Continue.dev",
+    installed,
+    configured,
+    status: !installed ? "not detected" : configured ? "engram configured" : "detected \u2014 add engram MCP server to config"
+  };
+}
+function detectAider(projectRoot) {
+  const configured = existsSync(join(projectRoot, ".aider-context.md"));
+  const installed = configured || existsSync(join(homedir(), ".aider"));
+  return {
+    name: "Aider",
+    installed,
+    configured,
+    status: !installed ? "not detected" : configured ? ".aider-context.md present" : "detected \u2014 run `engram gen-aider`"
+  };
+}
+function detectAllIdes(projectRoot) {
+  return [
+    detectClaudeCode(projectRoot),
+    detectCursor(projectRoot),
+    detectWindsurf(projectRoot),
+    detectContinue(),
+    detectAider(projectRoot)
+  ];
+}
+
+// src/setup/wizard.ts
+async function ask(rl, question, fallback) {
+  const prompt = `${question} ${fallback ? "[Y/n]" : "[y/N]"} `;
+  const answer = (await rl.question(prompt)).trim().toLowerCase();
+  if (answer === "") return fallback;
+  return answer === "y" || answer === "yes";
+}
+function banner(line) {
+  console.log(chalk.bold(line));
+}
+function step(n, title) {
+  console.log("");
+  console.log(chalk.cyan(`\u2500\u2500 step ${n} \xB7 `) + chalk.bold(title));
+}
+function done(msg) {
+  console.log(chalk.green("  \u2713 ") + msg);
+}
+function skip(msg) {
+  console.log(chalk.dim("  \xB7 ") + chalk.dim(msg));
+}
+function warn(msg) {
+  console.log(chalk.yellow("  \u26A0 ") + msg);
+}
+async function ensureGraphInit(opts, rl) {
+  const root = pathResolve(opts.projectPath);
+  const dbPath = join2(root, ".engram", "graph.db");
+  if (existsSync2(dbPath)) {
+    skip("graph.db already exists at .engram/graph.db \u2014 skipping init");
+    return false;
+  }
+  if (opts.dryRun) {
+    skip("[dry-run] would run `engram init`");
+    return false;
+  }
+  const go = opts.yes || rl === null || await ask(rl, "Index this repository now?", true);
+  if (!go) {
+    skip("skipped by user");
+    return false;
+  }
+  console.log(chalk.dim("  \u2192 running engram init..."));
+  const result = await init(root);
+  done(
+    `${result.nodes} nodes, ${result.edges} edges from ${result.fileCount} files (${result.timeMs}ms)`
+  );
+  return true;
+}
+async function ensureHookInstalled(opts, rl) {
+  const root = pathResolve(opts.projectPath);
+  const scope = opts.settingsScope ?? "local";
+  const settingsPath = scope === "user" ? join2(homedir2(), ".claude", "settings.json") : scope === "project" ? join2(root, ".claude", "settings.json") : join2(root, ".claude", "settings.local.json");
+  const existing = existsSync2(settingsPath) ? readFileSync2(settingsPath, "utf-8") : "";
+  if (existing.includes("engram intercept")) {
+    skip(`Sentinel hook already in ${scope}-scope settings`);
+    return false;
+  }
+  if (opts.dryRun) {
+    skip(`[dry-run] would install Sentinel hook (${scope} scope)`);
+    return false;
+  }
+  const go = opts.yes || rl === null || await ask(rl, `Install Sentinel hook in ${scope} scope?`, true);
+  if (!go) {
+    skip("skipped by user");
+    return false;
+  }
+  let settings = {};
+  if (existing) {
+    try {
+      settings = JSON.parse(existing);
+    } catch {
+      warn(`settings file at ${settingsPath} is not valid JSON \u2014 aborting`);
+      return false;
+    }
+  }
+  const result = installEngramHooks(settings);
+  mkdirSync(dirname(settingsPath), { recursive: true });
+  writeFileSync(settingsPath, JSON.stringify(result.updated, null, 2) + "\n", "utf-8");
+  done(`Sentinel hook installed (${scope} scope)`);
+  return true;
+}
+async function offerIdeAdapters(opts, rl) {
+  const root = pathResolve(opts.projectPath);
+  const detected = detectAllIdes(root);
+  const installedIdes = detected.filter((d) => d.installed);
+  if (installedIdes.length === 0) {
+    skip("no IDEs detected beyond Claude Code");
+    return [];
+  }
+  console.log(chalk.dim("  Detected:"));
+  for (const d of installedIdes) {
+    console.log(
+      chalk.dim(`    \xB7 ${d.name.padEnd(14)} \u2014 ${d.status}`)
+    );
+  }
+  if (opts.dryRun) {
+    skip("[dry-run] adapters left alone");
+    return [];
+  }
+  const unconfigured = installedIdes.filter((d) => !d.configured);
+  if (unconfigured.length === 0) {
+    done("all detected IDEs already have engram adapters");
+    return [];
+  }
+  const suggest = {
+    Cursor: "engram gen-mdc",
+    Windsurf: "engram gen-windsurfrules",
+    Aider: "engram gen-aider"
+  };
+  const suggested = [];
+  for (const ide of unconfigured) {
+    const cmd = suggest[ide.name];
+    if (cmd) suggested.push({ name: ide.name, cmd });
+  }
+  if (suggested.length === 0) {
+    const claudeCode = unconfigured.find((d) => d.name === "Claude Code");
+    if (claudeCode) {
+      skip("Claude Code hook declined or missing \u2014 re-run `engram install-hook`");
+    } else {
+      done("no additional adapters needed");
+    }
+    return [];
+  }
+  console.log("");
+  console.log(chalk.dim("  Next steps for detected IDEs:"));
+  const run = [];
+  for (const s of suggested) {
+    console.log(chalk.white(`    $ ${s.cmd}`));
+    run.push(s.name);
+  }
+  return run;
+}
+async function runSetup(opts) {
+  const root = pathResolve(opts.projectPath);
+  banner(`
+\u26A1 engram setup \u2014 ${root}`);
+  console.log(
+    chalk.dim(
+      `   Running ${opts.yes ? "non-interactively" : "interactively"}${opts.dryRun ? " (dry-run)" : ""}
+`
+    )
+  );
+  const rl = opts.yes || opts.dryRun ? null : readline.createInterface({ input: process.stdin, output: process.stdout });
+  let initRan = false;
+  let hookInstalled = false;
+  let ideAdapters = [];
+  try {
+    step(1, "graph");
+    initRan = await ensureGraphInit(opts, rl);
+    step(2, "hook");
+    hookInstalled = await ensureHookInstalled(opts, rl);
+    step(3, "adapters");
+    ideAdapters = await offerIdeAdapters(opts, rl);
+    step(4, "verify");
+    const report = buildReport(root, opts.engramVersion);
+    console.log(formatReport(report, false));
+    const exitCode = report.overallSeverity === "ok" ? 0 : report.overallSeverity === "warn" ? 1 : 2;
+    return { initRan, hookInstalled, ideAdaptersRun: ideAdapters, exitCode };
+  } finally {
+    rl?.close();
+  }
+}
+export {
+  runSetup
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "engramx",
-  "version": "2.0.2",
+  "version": "2.1.0",
   "description": "The context spine for AI coding agents. 8 providers + pluggable context sources, 3-layer memory cache, web dashboard, multi-IDE support (Claude Code, Cursor, Continue, Zed, Aider, Windsurf, Neovim, Emacs). 88.1% measured session-level token savings. Local SQLite, zero native deps, zero cloud.",
   "repository": {
     "type": "git",