engramx 2.0.2 → 3.0.0

package/dist/chunk-RM2TBOVW.js

@@ -0,0 +1,121 @@
+// src/update/check.ts
+import { existsSync, readFileSync, writeFileSync, mkdirSync } from "fs";
+import { homedir } from "os";
+import { dirname, join } from "path";
+var REGISTRY_URL = "https://registry.npmjs.org/engramx/latest";
+var CHECK_INTERVAL_MS = 7 * 24 * 60 * 60 * 1e3;
+var FETCH_TIMEOUT_MS = 1500;
+function cachePath() {
+  return join(homedir(), ".engram", "last-update-check");
+}
+function readCache() {
+  const path = cachePath();
+  if (!existsSync(path)) return null;
+  try {
+    const parsed = JSON.parse(readFileSync(path, "utf-8"));
+    if (typeof parsed?.latest === "string" && typeof parsed?.checkedAt === "number") {
+      return parsed;
+    }
+    return null;
+  } catch {
+    return null;
+  }
+}
+function writeCache(entry) {
+  try {
+    const path = cachePath();
+    mkdirSync(dirname(path), { recursive: true });
+    writeFileSync(path, JSON.stringify(entry), "utf-8");
+  } catch {
+  }
+}
+function isNewer(a, b) {
+  const parse = (v) => {
+    const m = /^v?(\d+)\.(\d+)\.(\d+)(?:-([0-9A-Za-z.-]+))?/.exec(v.trim());
+    if (!m) return null;
+    return {
+      major: Number(m[1]),
+      minor: Number(m[2]),
+      patch: Number(m[3]),
+      pre: m[4] ?? null
+    };
+  };
+  const pa = parse(a);
+  const pb = parse(b);
+  if (!pa || !pb) return false;
+  if (pa.major !== pb.major) return pa.major > pb.major;
+  if (pa.minor !== pb.minor) return pa.minor > pb.minor;
+  if (pa.patch !== pb.patch) return pa.patch > pb.patch;
+  if (pa.pre === null && pb.pre !== null) return true;
+  if (pa.pre !== null && pb.pre === null) return false;
+  if (pa.pre === null && pb.pre === null) return false;
+  return (pa.pre ?? "") > (pb.pre ?? "");
+}
+function optedOut() {
+  if (process.env.ENGRAM_NO_UPDATE_CHECK === "1") return true;
+  if (process.env.CI) return true;
+  return false;
+}
+async function fetchLatestFromRegistry() {
+  const controller = new AbortController();
+  const timer = setTimeout(() => controller.abort(), FETCH_TIMEOUT_MS);
+  try {
+    const res = await fetch(REGISTRY_URL, {
+      signal: controller.signal,
+      headers: { accept: "application/json" }
+    });
+    if (!res.ok) return null;
+    const body = await res.json();
+    if (typeof body?.version !== "string") return null;
+    return body.version;
+  } catch {
+    return null;
+  } finally {
+    clearTimeout(timer);
+  }
+}
+async function checkForUpdate(currentVersion, opts = {}) {
+  const base = {
+    skipped: false,
+    current: currentVersion,
+    latest: null,
+    updateAvailable: false,
+    checkedAt: null,
+    fromCache: false
+  };
+  if (!opts.force && optedOut()) {
+    return { ...base, skipped: true };
+  }
+  if (!opts.force) {
+    const cached = readCache();
+    if (cached && Date.now() - cached.checkedAt < CHECK_INTERVAL_MS) {
+      return {
+        ...base,
+        latest: cached.latest,
+        updateAvailable: isNewer(cached.latest, currentVersion),
+        checkedAt: cached.checkedAt,
+        fromCache: true
+      };
+    }
+  }
+  const latest = await fetchLatestFromRegistry();
+  if (!latest) {
+    return { ...base, skipped: !opts.force };
+  }
+  const now = Date.now();
+  writeCache({ latest, checkedAt: now });
+  return {
+    ...base,
+    latest,
+    updateAvailable: isNewer(latest, currentVersion),
+    checkedAt: now,
+    fromCache: false
+  };
+}
+
+export {
+  cachePath,
+  isNewer,
+  optedOut,
+  checkForUpdate
+};

package/dist/chunk-SMU4WR3D.js

@@ -0,0 +1,187 @@
+// src/intercept/installer.ts
+var ENGRAM_HOOK_EVENTS = [
+  "PreToolUse",
+  "PostToolUse",
+  "SessionStart",
+  "UserPromptSubmit",
+  "PreCompact",
+  "CwdChanged"
+];
+var ENGRAM_PRETOOL_MATCHER = "Read|Edit|Write|Bash";
+var DEFAULT_ENGRAM_COMMAND = "engram intercept";
+var ENGRAM_REINDEX_HOOK_MATCHER = "Edit|Write|MultiEdit";
+var DEFAULT_ENGRAM_REINDEX_HOOK_COMMAND = "engram reindex-hook";
+var DEFAULT_HOOK_TIMEOUT_SEC = 5;
+var DEFAULT_STATUSLINE_COMMAND = "engram hud-label";
+function buildEngramHookEntries(command = DEFAULT_ENGRAM_COMMAND, timeout = DEFAULT_HOOK_TIMEOUT_SEC) {
+  const baseCmd = {
+    type: "command",
+    command,
+    timeout
+  };
+  return {
+    PreToolUse: {
+      matcher: ENGRAM_PRETOOL_MATCHER,
+      hooks: [baseCmd]
+    },
+    PostToolUse: {
+      // Match all tools — PostToolUse is an observer for any completion.
+      matcher: ".*",
+      hooks: [baseCmd]
+    },
+    SessionStart: {
+      // No matcher — SessionStart has no tool name.
+      hooks: [baseCmd]
+    },
+    UserPromptSubmit: {
+      // No matcher — UserPromptSubmit has no tool name.
+      hooks: [baseCmd]
+    },
+    PreCompact: {
+      // No matcher — PreCompact has no tool name.
+      hooks: [baseCmd]
+    },
+    CwdChanged: {
+      // No matcher — CwdChanged has no tool name.
+      hooks: [baseCmd]
+    }
+  };
+}
+function buildReindexHookEntry(command = DEFAULT_ENGRAM_REINDEX_HOOK_COMMAND, timeout = DEFAULT_HOOK_TIMEOUT_SEC) {
+  return {
+    matcher: ENGRAM_REINDEX_HOOK_MATCHER,
+    hooks: [{ type: "command", command, timeout }]
+  };
+}
+function isEngramHookEntry(entry) {
+  if (entry === null || typeof entry !== "object") return false;
+  const e = entry;
+  if (!Array.isArray(e.hooks)) return false;
+  for (const h of e.hooks) {
+    if (h === null || typeof h !== "object") continue;
+    const cmd = h.command;
+    if (typeof cmd !== "string") continue;
+    if (cmd.includes("engram intercept") || cmd.includes("engram reindex-hook")) {
+      return true;
+    }
+  }
+  return false;
+}
+function installEngramHooks(settings, command = DEFAULT_ENGRAM_COMMAND, options = {}) {
+  const entries = buildEngramHookEntries(command);
+  const added = [];
+  const alreadyPresent = [];
+  const hooksClone = {};
+  const existingHooks = settings.hooks ?? {};
+  for (const [key, value] of Object.entries(existingHooks)) {
+    if (Array.isArray(value)) {
+      hooksClone[key] = value.map((entry) => ({ ...entry }));
+    }
+  }
+  for (const event of ENGRAM_HOOK_EVENTS) {
+    const eventArr = hooksClone[event] ?? [];
+    const hasIntercept = eventArr.some(
+      (e) => entryContainsCommand(e, "engram intercept")
+    );
+    if (hasIntercept) {
+      alreadyPresent.push(event);
+      hooksClone[event] = eventArr;
+      continue;
+    }
+    hooksClone[event] = [...eventArr, entries[event]];
+    added.push(event);
+  }
+  let autoReindexAdded = false;
+  if (options.autoReindex) {
+    const postToolArr = hooksClone.PostToolUse ?? [];
+    const hasReindexHook = postToolArr.some(
+      (e) => entryContainsCommand(e, "engram reindex-hook")
+    );
+    if (!hasReindexHook) {
+      hooksClone.PostToolUse = [...postToolArr, buildReindexHookEntry()];
+      autoReindexAdded = true;
+    }
+  }
+  const hasStatusLine = settings.statusLine && typeof settings.statusLine === "object" && typeof settings.statusLine.command === "string" && settings.statusLine.command.length > 0;
+  const statusLineAdded = !hasStatusLine;
+  const statusLine = hasStatusLine ? settings.statusLine : { type: "command", command: DEFAULT_STATUSLINE_COMMAND };
+  return {
+    updated: { ...settings, hooks: hooksClone, statusLine },
+    added,
+    alreadyPresent,
+    statusLineAdded,
+    autoReindexAdded
+  };
+}
+function entryContainsCommand(entry, substring) {
+  if (!Array.isArray(entry.hooks)) return false;
+  for (const h of entry.hooks) {
+    if (h === null || typeof h !== "object") continue;
+    const cmd = h.command;
+    if (typeof cmd === "string" && cmd.includes(substring)) return true;
+  }
+  return false;
+}
+function uninstallEngramHooks(settings) {
+  const removed = [];
+  const existingHooks = settings.hooks ?? {};
+  const hooksClone = {};
+  for (const [event, arr] of Object.entries(existingHooks)) {
+    if (!Array.isArray(arr)) continue;
+    const filtered = arr.filter((entry) => !isEngramHookEntry(entry));
+    if (filtered.length !== arr.length && isKnownEngramEvent(event)) {
+      removed.push(event);
+    }
+    if (filtered.length > 0) {
+      hooksClone[event] = filtered;
+    }
+  }
+  const updatedSettings = { ...settings };
+  if (Object.keys(hooksClone).length === 0) {
+    delete updatedSettings.hooks;
+  } else {
+    updatedSettings.hooks = hooksClone;
+  }
+  const statusLineRemoved = typeof updatedSettings.statusLine?.command === "string" && updatedSettings.statusLine.command.includes("engram hud-label");
+  if (statusLineRemoved) {
+    delete updatedSettings.statusLine;
+  }
+  return { updated: updatedSettings, removed, statusLineRemoved };
+}
+function isKnownEngramEvent(event) {
+  return ENGRAM_HOOK_EVENTS.includes(event);
+}
+function formatInstallDiff(before, after) {
+  const lines = [];
+  const beforeHooks = before.hooks ?? {};
+  const afterHooks = after.hooks ?? {};
+  for (const event of ENGRAM_HOOK_EVENTS) {
+    const beforeArr = beforeHooks[event] ?? [];
+    const afterArr = afterHooks[event] ?? [];
+    if (beforeArr.length === afterArr.length) continue;
+    lines.push(`+ ${event}: ${beforeArr.length} \u2192 ${afterArr.length} entries`);
+    const added = afterArr.filter((entry) => isEngramHookEntry(entry));
+    const beforeHasEngram = beforeArr.some((entry) => isEngramHookEntry(entry));
+    if (!beforeHasEngram && added.length > 0) {
+      for (const entry of added) {
+        const matcher = entry.matcher ? ` matcher=${JSON.stringify(entry.matcher)}` : "";
+        const cmds = entry.hooks.map((h) => h.command).join(", ");
+        lines.push(`    + {${matcher} command="${cmds}"}`);
+      }
+    }
+  }
+  const hadStatusLine = before.statusLine?.command;
+  const hasStatusLineNow = after.statusLine?.command;
+  if (!hadStatusLine && hasStatusLineNow?.includes("engram hud-label")) {
+    lines.push(`+ statusLine: engram hud-label (HUD enabled)`);
+  } else if (hadStatusLine?.includes("engram hud-label") && !hasStatusLineNow) {
+    lines.push(`- statusLine: engram hud-label (HUD removed)`);
+  }
+  return lines.length > 0 ? lines.join("\n") : "(no changes)";
+}
+
+export {
+  installEngramHooks,
+  uninstallEngramHooks,
+  formatInstallDiff
+};

package/dist/{chunk-C6GBUOAL.js → chunk-VLTWBTQ7.js}

@@ -310,7 +310,7 @@ function writeToFile(filePath, summary) {
   writeFileSync2(filePath, newContent);
 }
 async function autogen(projectRoot, target, task) {
-  const { getStore } = await import("./core-6IY5L6II.js");
+  const { getStore } = await import("./core-77F2BVYV.js");
   const store = await getStore(projectRoot);
   try {
     let view = VIEWS.general;
@@ -326,26 +326,25 @@ async function autogen(projectRoot, target, task) {
     }
     const summary = generateSummary(store, view);
     const stats = store.getStats();
-    let targetFile;
+    const targetFiles = [];
     if (target === "claude") {
-      targetFile = join2(projectRoot, "CLAUDE.md");
+      targetFiles.push(join2(projectRoot, "CLAUDE.md"));
     } else if (target === "cursor") {
-      targetFile = join2(projectRoot, ".cursorrules");
+      targetFiles.push(join2(projectRoot, ".cursorrules"));
     } else if (target === "agents") {
-      targetFile = join2(projectRoot, "AGENTS.md");
+      targetFiles.push(join2(projectRoot, "AGENTS.md"));
     } else {
-      if (existsSync2(join2(projectRoot, "CLAUDE.md"))) {
-        targetFile = join2(projectRoot, "CLAUDE.md");
-      } else if (existsSync2(join2(projectRoot, ".cursorrules"))) {
-        targetFile = join2(projectRoot, ".cursorrules");
-      } else if (existsSync2(join2(projectRoot, "AGENTS.md"))) {
-        targetFile = join2(projectRoot, "AGENTS.md");
-      } else {
-        targetFile = join2(projectRoot, "CLAUDE.md");
+      targetFiles.push(join2(projectRoot, "CLAUDE.md"));
+      targetFiles.push(join2(projectRoot, "AGENTS.md"));
+      const cursorRules = join2(projectRoot, ".cursorrules");
+      if (existsSync2(cursorRules)) {
+        targetFiles.push(cursorRules);
       }
     }
-    writeToFile(targetFile, summary);
-    return { file: targetFile, nodesIncluded: stats.nodes, view: view.name };
+    for (const f of targetFiles) {
+      writeToFile(f, summary);
+    }
+    return { files: targetFiles, nodesIncluded: stats.nodes, view: view.name };
   } finally {
     store.close();
   }

package/dist/chunk-XVYE4OX2.js

@@ -0,0 +1,232 @@
+import {
+  cachePath,
+  isNewer
+} from "./chunk-RM2TBOVW.js";
+import {
+  refreshComponentStatus
+} from "./chunk-G4U3QOOW.js";
+
+// src/doctor/report.ts
+import chalk from "chalk";
+import { existsSync, readFileSync, statSync } from "fs";
+import { join } from "path";
+import { homedir, platform, release } from "os";
+function checkGraphDb(projectRoot) {
+  const path = join(projectRoot, ".engram", "graph.db");
+  if (!existsSync(path)) {
+    return {
+      name: "graph",
+      severity: "fail",
+      detail: "No graph at .engram/graph.db",
+      remediation: "Run `engram init` (or `engram setup` for the wizard)."
+    };
+  }
+  try {
+    const size = statSync(path).size;
+    const sizeMb = (size / 1024 / 1024).toFixed(2);
+    return {
+      name: "graph",
+      severity: "ok",
+      detail: `.engram/graph.db present (${sizeMb} MB)`
+    };
+  } catch {
+    return {
+      name: "graph",
+      severity: "warn",
+      detail: "graph.db exists but stat() failed",
+      remediation: "Check file permissions on .engram/graph.db"
+    };
+  }
+}
+function checkHook(projectRoot) {
+  const candidates = [
+    join(projectRoot, ".claude", "settings.local.json"),
+    join(projectRoot, ".claude", "settings.json"),
+    join(homedir(), ".claude", "settings.json")
+  ];
+  for (const path of candidates) {
+    if (!existsSync(path)) continue;
+    try {
+      const content = readFileSync(path, "utf-8");
+      if (content.includes("engram intercept")) {
+        return {
+          name: "hook",
+          severity: "ok",
+          detail: `Sentinel hook active (via ${path.replace(homedir(), "~")})`
+        };
+      }
+    } catch {
+    }
+  }
+  return {
+    name: "hook",
+    severity: "warn",
+    detail: "Sentinel hook not found in any .claude/settings*.json",
+    remediation: "Run `engram install-hook` to enable automatic Read interception."
+  };
+}
+function componentToCheck(c) {
+  if (c.available) {
+    return {
+      name: c.name,
+      severity: "ok",
+      detail: `${c.name.toUpperCase()} provider reachable`
+    };
+  }
+  const remediationByName = {
+    http: "Run `engram server --http` to start the local API.",
+    lsp: "LSP is best-effort \u2014 install a language server (typescript-language-server, pyright, rust-analyzer).",
+    ast: "Tree-sitter grammars missing. Reinstall engram: `engram update` or `npm install -g engramx@latest`."
+  };
+  return {
+    name: c.name,
+    severity: c.name === "ast" ? "fail" : "warn",
+    detail: `${c.name.toUpperCase()} provider unavailable`,
+    remediation: remediationByName[c.name]
+  };
+}
+function checkVersion(engramVersion) {
+  try {
+    const path = cachePath();
+    if (!existsSync(path)) {
+      return {
+        name: "version",
+        severity: "ok",
+        detail: `engram v${engramVersion} (no update check cached yet)`
+      };
+    }
+    const cached = JSON.parse(readFileSync(path, "utf-8"));
+    if (typeof cached?.latest === "string" && cached.latest !== engramVersion && isNewer(cached.latest, engramVersion)) {
+      return {
+        name: "version",
+        severity: "warn",
+        detail: `engram v${engramVersion} \u2014 v${cached.latest} is available`,
+        remediation: "Run `engram update` to upgrade."
+      };
+    }
+    return {
+      name: "version",
+      severity: "ok",
+      detail: `engram v${engramVersion} (latest)`
+    };
+  } catch {
+    return {
+      name: "version",
+      severity: "ok",
+      detail: `engram v${engramVersion}`
+    };
+  }
+}
+function checkIdes(ideCount) {
+  if (ideCount === 0) {
+    return {
+      name: "ides",
+      severity: "warn",
+      detail: "No IDE adapters detected",
+      remediation: "Run `engram gen-mdc` (Cursor), `gen-windsurfrules` (Windsurf), or `gen-aider` (Aider) to add IDE adapters."
+    };
+  }
+  return {
+    name: "ides",
+    severity: "ok",
+    detail: `${ideCount} IDE adapter${ideCount > 1 ? "s" : ""} configured`
+  };
+}
+function aggregate(checks) {
+  if (checks.some((c) => c.severity === "fail")) return "fail";
+  if (checks.some((c) => c.severity === "warn")) return "warn";
+  return "ok";
+}
+function buildReport(projectRoot, engramVersion) {
+  const components = refreshComponentStatus(projectRoot);
+  const checks = [
+    checkVersion(engramVersion),
+    checkGraphDb(projectRoot),
+    checkHook(projectRoot),
+    ...components.components.map(componentToCheck),
+    checkIdes(components.ideCount)
+  ];
+  return {
+    projectRoot,
+    engramVersion,
+    nodeVersion: process.version,
+    os: `${platform()} ${release()}`,
+    checks,
+    overallSeverity: aggregate(checks),
+    generatedAt: Date.now()
+  };
+}
+function icon(sev) {
+  switch (sev) {
+    case "ok":
+      return chalk.green("\u2713");
+    case "warn":
+      return chalk.yellow("\u26A0");
+    case "fail":
+      return chalk.red("\u2717");
+  }
+}
+function formatReport(report, verbose) {
+  const lines = [];
+  lines.push("");
+  lines.push(chalk.bold(`\u{1FA7A} engram doctor \u2014 ${report.projectRoot}`));
+  lines.push(
+    chalk.dim(
+      `   engram v${report.engramVersion} \xB7 Node ${report.nodeVersion} \xB7 ${report.os}`
+    )
+  );
+  lines.push("");
+  for (const c of report.checks) {
+    lines.push(`  ${icon(c.severity)} ${chalk.bold(c.name.padEnd(8))} ${c.detail}`);
+    if (verbose && c.remediation && c.severity !== "ok") {
+      lines.push(`      ${chalk.dim("\u2192 " + c.remediation)}`);
+    }
+  }
+  lines.push("");
+  switch (report.overallSeverity) {
+    case "ok":
+      lines.push(chalk.green("  All systems green."));
+      break;
+    case "warn":
+      lines.push(
+        chalk.yellow(
+          "  Working, with warnings. Run `engram doctor --verbose` for remediation."
+        )
+      );
+      break;
+    case "fail":
+      lines.push(
+        chalk.red(
+          "  Critical components missing. Run `engram doctor --verbose` for fixes."
+        )
+      );
+      break;
+  }
+  lines.push("");
+  return lines.join("\n");
+}
+function exportReport(report) {
+  return JSON.stringify(
+    {
+      engramVersion: report.engramVersion,
+      nodeVersion: report.nodeVersion,
+      os: report.os,
+      overallSeverity: report.overallSeverity,
+      checks: report.checks.map((c) => ({
+        name: c.name,
+        severity: c.severity,
+        detail: c.detail
+      })),
+      generatedAt: new Date(report.generatedAt).toISOString()
+      // NOTE: projectRoot intentionally omitted — can contain usernames.
+    },
+    null,
+    2
+  );
+}
+
+export {
+  buildReport,
+  formatReport,
+  exportReport
+};