engramx 2.0.2 → 3.0.0

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

@@ -11,8 +11,8 @@ import {
   path,
   query,
   stats
-} from "./chunk-SJT7VS2G.js";
-import "./chunk-PEH54LYC.js";
+} from "./chunk-B4UOE64J.js";
+import "./chunk-645NBY6L.js";
 export {
   benchmark,
   computeKeywordIDF,

package/dist/{cursor-mdc-GJ7E5LDD.js → cursor-mdc-EEO7PYZ3.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-77F2BVYV.js");
   const store = await getStore(projectPath);
   try {
     const allNodes = store.getAllNodes();

package/dist/{exporter-GWU2GF23.js → exporter-ZYJ4WM2F.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-77F2BVYV.js");
   const store = await getStore(projectRoot);
   try {
     const allNodes = store.getAllNodes();

package/dist/{importer-V62NGZRK.js → importer-4UWQDH4W.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-77F2BVYV.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-VLTWBTQ7.js";
 import {
   GraphStore,
   SUPPORTED_EXTENSIONS,
@@ -23,8 +23,8 @@ import {
   sliceGraphemeSafe,
   stats,
   truncateGraphemeSafe
-} from "./chunk-SJT7VS2G.js";
-import "./chunk-PEH54LYC.js";
+} from "./chunk-B4UOE64J.js";
+import "./chunk-645NBY6L.js";
 export {
   GraphStore,
   SUPPORTED_EXTENSIONS,

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/mcp-client-ROOJF76V.js

@@ -0,0 +1,9 @@
+import {
+  __internalsForTesting,
+  createMcpProvider
+} from "./chunk-73IBCRFI.js";
+import "./chunk-ZUC6OXSL.js";
+export {
+  __internalsForTesting,
+  createMcpProvider
+};

package/dist/mcp-config-QD4NPVXB.js

@@ -0,0 +1,12 @@
+import {
+  applyArgTemplate,
+  getMcpConfigPath,
+  loadMcpConfigs,
+  validateProviderConfig
+} from "./chunk-ZUC6OXSL.js";
+export {
+  applyArgTemplate,
+  getMcpConfigPath,
+  loadMcpConfigs,
+  validateProviderConfig
+};

package/dist/{migrate-UKCO6BUU.js → migrate-KJ5K5NWO.js}

@@ -3,7 +3,7 @@ import {
   getSchemaVersion,
   rollback,
   runMigrations
-} from "./chunk-PEH54LYC.js";
+} from "./chunk-645NBY6L.js";
 export {
   CURRENT_SCHEMA_VERSION,
   getSchemaVersion,

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/{plugin-loader-STTGYIL5.js → plugin-loader-SQQB6V74.js}

@@ -1,3 +1,10 @@
+import {
+  createMcpProvider
+} from "./chunk-73IBCRFI.js";
+import {
+  validateProviderConfig
+} from "./chunk-ZUC6OXSL.js";
+
 // src/providers/plugin-loader.ts
 import { existsSync, readdirSync, mkdirSync } from "fs";
 import { join } from "path";
@@ -23,34 +30,73 @@ function validatePlugin(mod) {
     return { plugin: null, reason: "default export is not an object" };
   }
   const p = candidate;
-  const required = [
-    "name",
-    "label",
-    "tier",
-    "tokenBudget",
-    "timeoutMs",
-    "version",
-    "resolve",
-    "isAvailable"
-  ];
-  for (const field of required) {
-    if (p[field] === void 0 || p[field] === null) {
-      return { plugin: null, reason: `missing required field: ${field}` };
-    }
+  if (typeof p.name !== "string" || p.name.length === 0) {
+    return { plugin: null, reason: "name must be a non-empty string" };
   }
-  if (typeof p.resolve !== "function") {
-    return { plugin: null, reason: "resolve must be a function" };
+  if (typeof p.label !== "string" || p.label.length === 0) {
+    return { plugin: null, reason: `[${p.name}] label must be a non-empty string` };
   }
-  if (typeof p.isAvailable !== "function") {
-    return { plugin: null, reason: "isAvailable must be a function" };
+  if (typeof p.version !== "string" || p.version.length === 0) {
+    return { plugin: null, reason: `[${p.name}] version must be a non-empty string` };
   }
-  if (p.tier !== 1 && p.tier !== 2) {
-    return { plugin: null, reason: `tier must be 1 or 2 (got ${String(p.tier)})` };
+  const hasMcpConfig = p.mcpConfig !== void 0 && p.mcpConfig !== null;
+  const hasResolve = typeof p.resolve === "function";
+  if (!hasMcpConfig && !hasResolve) {
+    return {
+      plugin: null,
+      reason: `[${p.name}] plugin needs either a resolve() function or an mcpConfig declaration`
+    };
   }
-  if (typeof p.name !== "string" || p.name.length === 0) {
-    return { plugin: null, reason: "name must be a non-empty string" };
+  if (hasResolve) {
+    const classicRequired = [
+      "tier",
+      "tokenBudget",
+      "timeoutMs",
+      "isAvailable"
+    ];
+    for (const field of classicRequired) {
+      if (p[field] === void 0 || p[field] === null) {
+        return { plugin: null, reason: `[${p.name}] missing required field: ${field}` };
+      }
+    }
+    if (typeof p.isAvailable !== "function") {
+      return { plugin: null, reason: `[${p.name}] isAvailable must be a function` };
+    }
+    if (p.tier !== 1 && p.tier !== 2) {
+      return { plugin: null, reason: `[${p.name}] tier must be 1 or 2 (got ${String(p.tier)})` };
+    }
+    return { plugin: candidate, reason: "" };
+  }
+  const rawConfig = p.mcpConfig;
+  const normalizedConfig = {
+    name: p.name,
+    label: p.label,
+    ...rawConfig
+  };
+  const validation = validateProviderConfig(normalizedConfig);
+  if (!validation.ok) {
+    return {
+      plugin: null,
+      reason: `[${p.name}] invalid mcpConfig: ${validation.reason}`
+    };
   }
-  return { plugin: candidate, reason: "" };
+  const mcpProvider = createMcpProvider(
+    validation.value
+  );
+  const merged = {
+    name: p.name,
+    label: p.label,
+    version: p.version,
+    description: p.description,
+    author: p.author,
+    mcpConfig: p.mcpConfig,
+    tier: p.tier ?? mcpProvider.tier,
+    tokenBudget: p.tokenBudget ?? mcpProvider.tokenBudget,
+    timeoutMs: p.timeoutMs ?? mcpProvider.timeoutMs,
+    resolve: mcpProvider.resolve.bind(mcpProvider),
+    isAvailable: mcpProvider.isAvailable.bind(mcpProvider)
+  };
+  return { plugin: merged, reason: "" };
 }
 async function loadPlugins(dir) {
   const pluginsDir = dir ?? getPluginsDir();

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/resolver-H7GXVP73.js

@@ -0,0 +1,21 @@
+import {
+  _resetAvailabilityCache,
+  _resetMcpProvidersCache,
+  boostByMistakes,
+  enforcePerProviderBudget,
+  resolveRichPacket,
+  resolveRichPacketStreaming,
+  warmAllProviders
+} from "./chunk-RJC6RNXJ.js";
+import "./chunk-22INHMKB.js";
+import "./chunk-B4UOE64J.js";
+import "./chunk-645NBY6L.js";
+export {
+  _resetAvailabilityCache,
+  _resetMcpProvidersCache,
+  boostByMistakes,
+  enforcePerProviderBudget,
+  resolveRichPacket,
+  resolveRichPacketStreaming,
+  warmAllProviders
+};

package/dist/serve.js

@@ -2,14 +2,15 @@
 import {
   MAX_MISTAKE_LABEL_CHARS,
   benchmark,
+  formatThousands,
   godNodes,
   mistakes,
   path,
   query,
   stats,
   truncateGraphemeSafe
-} from "./chunk-SJT7VS2G.js";
-import "./chunk-PEH54LYC.js";
+} from "./chunk-B4UOE64J.js";
+import "./chunk-645NBY6L.js";
 
 // src/serve.ts
 function clampInt(value, defaultValue, min, max) {
@@ -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-2ZQKXJ5M.js}

@@ -10,19 +10,21 @@ import {
   safeEqual
 } from "./chunk-N6PPKOPK.js";
 import {
-  getComponentStatus,
   summarizeHookLog
-} from "./chunk-533LR4I7.js";
+} from "./chunk-FKY6HIT2.js";
 import {
   readHookLog
 } from "./chunk-KL6NSPVA.js";
+import {
+  getComponentStatus
+} from "./chunk-G4U3QOOW.js";
 import {
   getStore,
   learn,
   query,
   stats
-} from "./chunk-SJT7VS2G.js";
-import "./chunk-PEH54LYC.js";
+} from "./chunk-B4UOE64J.js";
+import "./chunk-645NBY6L.js";
 
 // src/server/http.ts
 import { createServer } from "http";
@@ -1091,6 +1093,72 @@ async function handleQuery(req, res, projectRoot) {
     json(res, 500, { error: "Query failed", detail: String(err) });
   }
 }
+async function handleContextStream(req, res, projectRoot) {
+  const url = parseUrl(req);
+  const filePath = url.searchParams.get("file");
+  if (!filePath) {
+    json(res, 400, { error: "Missing required query parameter 'file'" });
+    return;
+  }
+  const lastEventIdHeader = req.headers["last-event-id"];
+  const resumeAfter = (() => {
+    if (typeof lastEventIdHeader !== "string") return -1;
+    const n = parseInt(lastEventIdHeader, 10);
+    return isNaN(n) ? -1 : n;
+  })();
+  res.writeHead(200, {
+    "Content-Type": "text/event-stream",
+    "Cache-Control": "no-cache, no-transform",
+    Connection: "keep-alive",
+    "X-Accel-Buffering": "no",
+    ...corsHeaders(req)
+  });
+  if (typeof res.flushHeaders === "function") res.flushHeaders();
+  const context = {
+    filePath,
+    projectRoot,
+    nodeIds: [],
+    imports: [],
+    hasTests: false,
+    churnRate: 0
+  };
+  const { resolveRichPacketStreaming } = await import("./resolver-H7GXVP73.js");
+  let eventId = 0;
+  let disconnected = false;
+  req.on("close", () => {
+    disconnected = true;
+  });
+  try {
+    for await (const event of resolveRichPacketStreaming(
+      filePath,
+      context
+    )) {
+      if (disconnected) break;
+      if (eventId <= resumeAfter) {
+        eventId++;
+        continue;
+      }
+      const frame = `id: ${eventId}
+event: ${event.type}
+data: ${JSON.stringify(
+        event.type === "provider" ? event.result : { providerCount: event.providerCount, durationMs: event.durationMs }
+      )}
+
+`;
+      try {
+        res.write(frame);
+      } catch {
+        return;
+      }
+      eventId++;
+    }
+  } finally {
+    try {
+      res.end();
+    } catch {
+    }
+  }
+}
 async function handleStats(_req, res, projectRoot) {
   try {
     const result = await stats(projectRoot);
@@ -1403,6 +1471,8 @@ function createHttpServer(projectRoot, port) {
           await handleGraphGodNodes(req, res, projectRoot);
         } else if (req.method === "GET" && path === "/api/sse") {
           handleSSE(req, res, projectRoot);
+        } else if (req.method === "GET" && path === "/context/stream") {
+          await handleContextStream(req, res, projectRoot);
         } else if (req.method === "GET" && (path === "/ui" || path === "/ui/")) {
           res.writeHead(200, {
             "Content-Type": "text/html; charset=utf-8",

package/dist/{windsurf-rules-C7SVDHBL.js → windsurf-rules-XF7MYF6J.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-77F2BVYV.js");
   const store = await getStore(projectRoot);
   try {
     const allNodes = store.getAllNodes();