engramx 0.5.2 → 1.0.0

package/dist/cli.js

@@ -1,10 +1,15 @@
 #!/usr/bin/env node
+import {
+  logHookEvent,
+  readConfig,
+  readHookLog
+} from "./chunk-CEAANHHX.js";
 import {
   autogen,
   install,
   status,
   uninstall
-} from "./chunk-LH2ZID5Z.js";
+} from "./chunk-QOG4K427.js";
 import {
   benchmark,
   computeKeywordIDF,
@@ -21,21 +26,22 @@ import {
   renderFileStructure,
   stats,
   toPosixPath
-} from "./chunk-V5VQQ3SF.js";
+} from "./chunk-6SFMVYUN.js";
+import "./chunk-SBHGK5WA.js";
 
 // src/cli.ts
 import { Command } from "commander";
 import chalk2 from "chalk";
 import {
-  existsSync as existsSync8,
-  readFileSync as readFileSync5,
-  writeFileSync as writeFileSync2,
+  existsSync as existsSync10,
+  readFileSync as readFileSync6,
+  writeFileSync as writeFileSync3,
   mkdirSync,
   unlinkSync,
   copyFileSync,
-  renameSync as renameSync3
+  renameSync as renameSync2
 } from "fs";
-import { dirname as dirname3, join as join8, resolve as pathResolve } from "path";
+import { dirname as dirname4, join as join10, resolve as pathResolve } from "path";
 import { homedir } from "os";
 
 // src/intercept/safety.ts
@@ -342,15 +348,253 @@ function buildSessionContextResponse(eventName, additionalContext) {
 
 // src/providers/types.ts
 var PROVIDER_PRIORITY = [
+  "engram:ast",
   "engram:structure",
   "engram:mistakes",
   "mempalace",
   "context7",
   "engram:git",
-  "obsidian"
+  "obsidian",
+  "engram:lsp"
 ];
 var DEFAULT_CACHE_TTL_SEC = 3600;
 
+// src/providers/ast.ts
+import { readFileSync } from "fs";
+
+// src/providers/grammar-loader.ts
+import { existsSync as existsSync3 } from "fs";
+import { join as join3, dirname as dirname2 } from "path";
+import { createRequire } from "module";
+import { fileURLToPath } from "url";
+var require2 = createRequire(import.meta.url);
+var parserCache = /* @__PURE__ */ new Map();
+var tsParserInit = false;
+var EXT_TO_LANG = {
+  ts: "typescript",
+  tsx: "tsx",
+  js: "javascript",
+  jsx: "javascript",
+  mjs: "javascript",
+  cjs: "javascript",
+  py: "python",
+  go: "go",
+  rs: "rust",
+  rb: "ruby",
+  java: "java",
+  c: "c",
+  cpp: "cpp",
+  h: "c",
+  hpp: "cpp",
+  php: "php"
+};
+var LANG_TO_PKG = {
+  typescript: "tree-sitter-typescript",
+  tsx: "tree-sitter-typescript",
+  javascript: "tree-sitter-javascript",
+  python: "tree-sitter-python",
+  go: "tree-sitter-go",
+  rust: "tree-sitter-rust"
+};
+function getSupportedLang(filePath) {
+  const ext = filePath.split(".").pop()?.toLowerCase();
+  return ext ? EXT_TO_LANG[ext] ?? null : null;
+}
+function findGrammarWasm(lang) {
+  const pkg = LANG_TO_PKG[lang];
+  if (!pkg) return null;
+  const wasmName = lang === "tsx" ? "tree-sitter-tsx.wasm" : `tree-sitter-${lang}.wasm`;
+  const candidates = [];
+  try {
+    const here = dirname2(fileURLToPath(import.meta.url));
+    candidates.push(join3(here, "..", "..", "node_modules", pkg, wasmName));
+    candidates.push(join3(here, "..", "grammars", wasmName));
+  } catch {
+  }
+  try {
+    const pkgMain = require2.resolve(`${pkg}/package.json`);
+    const pkgDir = dirname2(pkgMain);
+    candidates.push(join3(pkgDir, wasmName));
+  } catch {
+  }
+  return candidates.find((c) => existsSync3(c)) ?? null;
+}
+async function getParser(lang) {
+  const cached = parserCache.get(lang);
+  if (cached) return cached;
+  try {
+    const { Parser, Language } = await import("web-tree-sitter");
+    if (!tsParserInit) {
+      await Parser.init();
+      tsParserInit = true;
+    }
+    const wasmPath = findGrammarWasm(lang);
+    if (!wasmPath) return null;
+    const language = await Language.load(wasmPath);
+    const parser = new Parser();
+    parser.setLanguage(language);
+    parserCache.set(lang, parser);
+    return parser;
+  } catch {
+    return null;
+  }
+}
+
+// src/providers/ast.ts
+function extractParams(node) {
+  const paramsNode = node.childForFieldName("parameters") ?? node.childForFieldName("formal_parameters");
+  if (!paramsNode) return "";
+  return paramsNode.text.replace(/\n/g, " ").replace(/\s+/g, " ").slice(0, 80).trim();
+}
+function extractSymbols(rootNode) {
+  const symbols = [];
+  function visit(node) {
+    switch (node.type) {
+      // ── Functions ───────────────────────────────────────────────
+      case "function_declaration":
+      case "function_definition": {
+        const nameNode = node.childForFieldName("name");
+        if (nameNode) {
+          symbols.push({
+            name: nameNode.text,
+            kind: "function",
+            line: node.startPosition.row + 1,
+            params: extractParams(node)
+          });
+        }
+        break;
+      }
+      // ── Classes ─────────────────────────────────────────────────
+      case "class_declaration":
+      case "class_definition": {
+        const nameNode = node.childForFieldName("name");
+        if (nameNode) {
+          symbols.push({
+            name: nameNode.text,
+            kind: "class",
+            line: node.startPosition.row + 1
+          });
+        }
+        break;
+      }
+      // ── Methods ─────────────────────────────────────────────────
+      case "method_definition":
+      case "method_declaration": {
+        const nameNode = node.childForFieldName("name");
+        if (nameNode) {
+          symbols.push({
+            name: nameNode.text,
+            kind: "method",
+            line: node.startPosition.row + 1,
+            params: extractParams(node)
+          });
+        }
+        break;
+      }
+      // ── TypeScript interfaces ────────────────────────────────────
+      case "interface_declaration": {
+        const nameNode = node.childForFieldName("name");
+        if (nameNode) {
+          symbols.push({
+            name: nameNode.text,
+            kind: "interface",
+            line: node.startPosition.row + 1
+          });
+        }
+        break;
+      }
+      // ── TypeScript type aliases ──────────────────────────────────
+      case "type_alias_declaration": {
+        const nameNode = node.childForFieldName("name");
+        if (nameNode) {
+          symbols.push({
+            name: nameNode.text,
+            kind: "type",
+            line: node.startPosition.row + 1
+          });
+        }
+        break;
+      }
+      // ── Exported variable declarations (incl. arrow functions) ──
+      case "lexical_declaration":
+      case "variable_declaration": {
+        for (let i = 0; i < node.childCount; i++) {
+          const child = node.child(i);
+          if (!child || child.type !== "variable_declarator") continue;
+          const nameNode = child.childForFieldName("name");
+          const valueNode = child.childForFieldName("value");
+          if (!nameNode) continue;
+          const isArrow = valueNode?.type === "arrow_function" || valueNode?.type === "function";
+          symbols.push({
+            name: nameNode.text,
+            kind: isArrow ? "function" : "variable",
+            line: node.startPosition.row + 1,
+            params: isArrow && valueNode ? extractParams(valueNode) : void 0
+          });
+        }
+        break;
+      }
+      default:
+        break;
+    }
+    for (let i = 0; i < node.childCount; i++) {
+      const child = node.child(i);
+      if (child) visit(child);
+    }
+  }
+  visit(rootNode);
+  return symbols;
+}
+function formatSymbols(symbols, tokenBudget) {
+  const lines = symbols.map((s) => {
+    const params = s.params !== void 0 ? `(${s.params})` : "";
+    return `${s.kind.toUpperCase()} ${s.name}${params} L${s.line}`;
+  });
+  const charBudget = tokenBudget * 4;
+  let text = lines.join("\n");
+  if (text.length > charBudget) {
+    text = text.slice(0, charBudget).trimEnd() + "\n... (truncated)";
+  }
+  return text;
+}
+var astProvider = {
+  name: "engram:ast",
+  label: "AST STRUCTURE",
+  tier: 1,
+  tokenBudget: 300,
+  timeoutMs: 200,
+  async resolve(filePath, _context) {
+    const lang = getSupportedLang(filePath);
+    if (!lang) return null;
+    const parser = await getParser(lang);
+    if (!parser) return null;
+    try {
+      const source = readFileSync(filePath, "utf-8");
+      const tree = parser.parse(source);
+      if (!tree) return null;
+      const symbols = extractSymbols(tree.rootNode);
+      if (symbols.length === 0) return null;
+      return {
+        provider: "engram:ast",
+        content: formatSymbols(symbols, this.tokenBudget),
+        confidence: 1,
+        cached: false
+      };
+    } catch {
+      return null;
+    }
+  },
+  async isAvailable() {
+    try {
+      const { Parser } = await import("web-tree-sitter");
+      await Parser.init();
+      return true;
+    } catch {
+      return false;
+    }
+  }
+};
+
 // src/providers/engram-structure.ts
 var structureProvider = {
   name: "engram:structure",
@@ -935,16 +1179,161 @@ async function fetchWithTimeout(url, timeoutMs) {
   }
 }
 
+// src/providers/lsp-connection.ts
+import { connect } from "net";
+import { existsSync as existsSync4 } from "fs";
+import { tmpdir } from "os";
+import { join as join4 } from "path";
+function candidateSockets() {
+  const uid = process.getuid?.() ?? 0;
+  const tmp = tmpdir();
+  return [
+    // TypeScript language server (used by VS Code)
+    join4(tmp, `tsserver-${uid}.sock`),
+    // Generic LSP socket (some editors, e.g. Helix)
+    join4(tmp, "lsp-server.sock"),
+    // TypeScript language server alternate path
+    join4(tmp, "typescript-language-server.sock"),
+    // Pyright (Python)
+    join4(tmp, `pyright-${uid}.sock`),
+    // rust-analyzer
+    join4(tmp, "rust-analyzer.sock")
+  ];
+}
+var LspConnection = class _LspConnection {
+  socket = null;
+  _requestId = 0;
+  /**
+   * Attempt to connect to any currently-running LSP server socket.
+   * Returns null — not throws — if no socket is found or connection fails.
+   * Timeout per candidate: 500ms.
+   */
+  static async tryConnect() {
+    const candidates = candidateSockets().filter((p) => existsSync4(p));
+    if (candidates.length === 0) return null;
+    for (const path2 of candidates) {
+      try {
+        const conn = new _LspConnection();
+        await conn._connect(path2);
+        return conn;
+      } catch {
+        continue;
+      }
+    }
+    return null;
+  }
+  /** Internal: open a socket to the given path with a 500ms timeout. */
+  _connect(socketPath) {
+    return new Promise((resolve7, reject) => {
+      const socket = connect(socketPath);
+      const timeout = setTimeout(() => {
+        socket.destroy();
+        reject(new Error("LSP connect timeout"));
+      }, 500);
+      socket.on("connect", () => {
+        clearTimeout(timeout);
+        this.socket = socket;
+        resolve7();
+      });
+      socket.on("error", (err) => {
+        clearTimeout(timeout);
+        reject(err);
+      });
+    });
+  }
+  /**
+   * Request hover info for a position.
+   *
+   * Stub: returns null. A full implementation would send a JSON-RPC
+   * textDocument/hover request and parse the response. Left as a stub
+   * because the response requires a request/response correlation loop
+   * over a streaming socket — non-trivial, and out of scope for v0.5.x.
+   * The provider benefits from the availability check alone.
+   */
+  async hover(_filePath, _line, _character) {
+    if (!this.socket) return null;
+    return null;
+  }
+  /**
+   * Fetch diagnostics for a file.
+   *
+   * Stub: returns []. A full implementation would use the
+   * textDocument/diagnostic pull request (LSP 3.17+) or subscribe to
+   * publishDiagnostics push notifications. Deferred to a future sprint.
+   */
+  async getDiagnostics(_filePath) {
+    if (!this.socket) return [];
+    return [];
+  }
+  /** Whether this connection has a live socket. */
+  get connected() {
+    return this.socket !== null && !this.socket.destroyed;
+  }
+  /** Close and destroy the socket. Safe to call multiple times. */
+  close() {
+    this.socket?.destroy();
+    this.socket = null;
+  }
+};
+
+// src/providers/lsp.ts
+var cachedConnection = void 0;
+async function getConnection() {
+  if (cachedConnection instanceof LspConnection) {
+    if (cachedConnection.connected) return cachedConnection;
+    cachedConnection.close();
+    cachedConnection = void 0;
+  }
+  if (cachedConnection === null) return null;
+  cachedConnection = await LspConnection.tryConnect();
+  return cachedConnection;
+}
+var lspProvider = {
+  name: "engram:lsp",
+  label: "LSP CONTEXT",
+  tier: 1,
+  tokenBudget: 100,
+  timeoutMs: 100,
+  async resolve(filePath, _context) {
+    try {
+      const conn = await getConnection();
+      if (!conn) return null;
+      const hover = await conn.hover(filePath, 0, 0);
+      if (!hover?.contents) return null;
+      const content = typeof hover.contents === "string" ? hover.contents : JSON.stringify(hover.contents);
+      const charBudget = this.tokenBudget * 4;
+      const truncated = content.length > charBudget ? content.slice(0, charBudget) + "..." : content;
+      return {
+        provider: "engram:lsp",
+        content: truncated,
+        confidence: 0.95,
+        cached: false
+      };
+    } catch {
+      return null;
+    }
+  },
+  async isAvailable() {
+    try {
+      const conn = await getConnection();
+      return conn !== null;
+    } catch {
+      return false;
+    }
+  }
+};
+
 // src/providers/resolver.ts
 var ALL_PROVIDERS = [
+  astProvider,
   structureProvider,
   mistakesProvider,
   gitProvider,
   mempalaceProvider,
   context7Provider,
-  obsidianProvider
+  obsidianProvider,
+  lspProvider
 ];
-var TOTAL_TOKEN_BUDGET = 600;
 function estimateTokens(text) {
   return Math.ceil(text.length / 4);
 }
@@ -966,16 +1355,20 @@ async function resolveRichPacket(filePath, context, enabledProviders) {
     }
   }
   if (results.length === 0) return null;
-  const sorted = results.sort((a, b) => {
+  const hasAst = results.some((r) => r.provider === "engram:ast");
+  const deduped = hasAst ? results.filter((r) => r.provider !== "engram:structure") : results;
+  const sorted = deduped.sort((a, b) => {
     const aIdx = PROVIDER_PRIORITY.indexOf(a.provider);
     const bIdx = PROVIDER_PRIORITY.indexOf(b.provider);
     return (aIdx === -1 ? 99 : aIdx) - (bIdx === -1 ? 99 : bIdx);
   });
+  const config = readConfig(context.projectRoot);
+  const budget = config.totalTokenBudget;
   const sections = [];
   let totalTokens = 0;
   for (const result of sorted) {
     const sectionTokens = estimateTokens(result.content);
-    if (totalTokens + sectionTokens > TOTAL_TOKEN_BUDGET) {
+    if (totalTokens + sectionTokens > budget) {
       break;
     }
     const provider = ALL_PROVIDERS.find((p) => p.name === result.provider);
@@ -1012,7 +1405,7 @@ async function warmAllProviders(projectRoot, enabledProviders) {
       try {
         const result = await withTimeout2(p.warmup(projectRoot), 5e3);
         if (result && result.entries.length > 0) {
-          const { getStore: getStore2 } = await import("./core-VUVXLXZN.js");
+          const { getStore: getStore2 } = await import("./core-77MHT3QV.js");
           const store = await getStore2(projectRoot);
           try {
             store.warmCache(
@@ -1249,10 +1642,10 @@ async function handleBash(payload) {
 }
 
 // src/intercept/handlers/session-start.ts
-import { existsSync as existsSync3, readFileSync } from "fs";
+import { existsSync as existsSync5, readFileSync as readFileSync2 } from "fs";
 import { execFile as execFile3 } from "child_process";
 import { promisify } from "util";
-import { basename, dirname as dirname2, join as join3, resolve as resolve2 } from "path";
+import { basename, dirname as dirname3, join as join5, resolve as resolve2 } from "path";
 var execFileAsync = promisify(execFile3);
 var MAX_GOD_NODES = 10;
 var MAX_LANDMINES_IN_BRIEF = 3;
@@ -1260,15 +1653,15 @@ function readGitBranch(projectRoot) {
   try {
     let current = resolve2(projectRoot);
     for (let depth = 0; depth < 10; depth++) {
-      const headPath = join3(current, ".git", "HEAD");
-      if (existsSync3(headPath)) {
-        const content = readFileSync(headPath, "utf-8").trim();
+      const headPath = join5(current, ".git", "HEAD");
+      if (existsSync5(headPath)) {
+        const content = readFileSync2(headPath, "utf-8").trim();
         const refMatch = content.match(/^ref:\s+refs\/heads\/(.+)$/);
         if (refMatch) return refMatch[1];
         if (/^[0-9a-f]{7,40}$/i.test(content)) return "detached";
         return null;
       }
-      const parent = dirname2(current);
+      const parent = dirname3(current);
       if (parent === current) return null;
       current = parent;
     }
@@ -1547,61 +1940,6 @@ ${result.text}`;
   return buildSessionContextResponse("UserPromptSubmit", text);
 }
 
-// src/intelligence/hook-log.ts
-import {
-  appendFileSync,
-  existsSync as existsSync4,
-  renameSync,
-  statSync as statSync2,
-  readFileSync as readFileSync2
-} from "fs";
-import { join as join4 } from "path";
-var HOOK_LOG_MAX_BYTES = 10 * 1024 * 1024;
-var LOG_FILENAME = "hook-log.jsonl";
-var LOG_ROTATED_FILENAME = "hook-log.jsonl.1";
-function logHookEvent(projectRoot, entry) {
-  if (!projectRoot) return;
-  try {
-    const logPath = join4(projectRoot, ".engram", LOG_FILENAME);
-    rotateIfNeeded(projectRoot);
-    const line = JSON.stringify({
-      ts: (/* @__PURE__ */ new Date()).toISOString(),
-      ...entry
-    }) + "\n";
-    appendFileSync(logPath, line);
-  } catch {
-  }
-}
-function rotateIfNeeded(projectRoot) {
-  try {
-    const logPath = join4(projectRoot, ".engram", LOG_FILENAME);
-    if (!existsSync4(logPath)) return;
-    const size = statSync2(logPath).size;
-    if (size < HOOK_LOG_MAX_BYTES) return;
-    const rotatedPath = join4(projectRoot, ".engram", LOG_ROTATED_FILENAME);
-    renameSync(logPath, rotatedPath);
-  } catch {
-  }
-}
-function readHookLog(projectRoot) {
-  try {
-    const logPath = join4(projectRoot, ".engram", LOG_FILENAME);
-    if (!existsSync4(logPath)) return [];
-    const raw = readFileSync2(logPath, "utf-8");
-    const entries = [];
-    for (const line of raw.split("\n")) {
-      if (!line.trim()) continue;
-      try {
-        entries.push(JSON.parse(line));
-      } catch {
-      }
-    }
-    return entries;
-  } catch {
-    return [];
-  }
-}
-
 // src/intercept/handlers/post-tool.ts
 function extractFilePath(toolName, toolInput) {
   if (!toolInput) return void 0;
@@ -1872,7 +2210,7 @@ function extractPreToolDecision(result) {
 }
 
 // src/watcher.ts
-import { watch, existsSync as existsSync5, statSync as statSync3 } from "fs";
+import { watch, existsSync as existsSync6, statSync as statSync2 } from "fs";
 import { resolve as resolve5, relative as relative3, extname } from "path";
 var WATCHABLE_EXTENSIONS = /* @__PURE__ */ new Set([
   ".ts",
@@ -1908,9 +2246,9 @@ function shouldIgnore(relPath) {
 async function reindexFile(absPath, projectRoot) {
   const ext = extname(absPath).toLowerCase();
   if (!WATCHABLE_EXTENSIONS.has(ext)) return 0;
-  if (!existsSync5(absPath)) return 0;
+  if (!existsSync6(absPath)) return 0;
   try {
-    if (statSync3(absPath).isDirectory()) return 0;
+    if (statSync2(absPath).isDirectory()) return 0;
   } catch {
     return 0;
   }
@@ -1931,7 +2269,7 @@ async function reindexFile(absPath, projectRoot) {
 function watchProject(projectRoot, options = {}) {
   const root = resolve5(projectRoot);
   const controller = new AbortController();
-  if (!existsSync5(getDbPath(root))) {
+  if (!existsSync6(getDbPath(root))) {
     throw new Error(
       `engram: no graph found at ${root}. Run 'engram init' first.`
     );
@@ -1973,8 +2311,8 @@ function watchProject(projectRoot, options = {}) {
 
 // src/dashboard.ts
 import chalk from "chalk";
-import { existsSync as existsSync6, statSync as statSync4 } from "fs";
-import { join as join6, resolve as resolve6, basename as basename4 } from "path";
+import { existsSync as existsSync7, statSync as statSync3 } from "fs";
+import { join as join7, resolve as resolve6, basename as basename4 } from "path";
 
 // src/intercept/stats.ts
 var ESTIMATED_TOKENS_PER_READ_DENY = 1200;
@@ -2188,9 +2526,9 @@ function startDashboard(projectRoot, options = {}) {
   const tick = () => {
     if (controller.signal.aborted) return;
     try {
-      const logPath = join6(root, ".engram", "hook-log.jsonl");
-      if (existsSync6(logPath)) {
-        const currentSize = statSync4(logPath).size;
+      const logPath = join7(root, ".engram", "hook-log.jsonl");
+      if (existsSync7(logPath)) {
+        const currentSize = statSync3(logPath).size;
         if (currentSize !== lastSize) {
           cachedEntries = readHookLog(root);
           lastSize = currentSize;
@@ -2397,15 +2735,123 @@ function formatInstallDiff(before, after) {
   return lines.length > 0 ? lines.join("\n") : "(no changes)";
 }
 
+// src/intercept/component-status.ts
+import { existsSync as existsSync8, readFileSync as readFileSync4, writeFileSync } from "fs";
+import { join as join8 } from "path";
+function statusPath(projectRoot) {
+  return join8(projectRoot, ".engram", "component-status.json");
+}
+function readCachedStatus(projectRoot) {
+  const path2 = statusPath(projectRoot);
+  if (!existsSync8(path2)) return null;
+  try {
+    const raw = JSON.parse(readFileSync4(path2, "utf-8"));
+    if (Date.now() - raw.generatedAt > 3e4) return null;
+    return raw;
+  } catch {
+    return null;
+  }
+}
+function checkHttp(projectRoot) {
+  return existsSync8(join8(projectRoot, ".engram", "http-server.pid"));
+}
+function checkLsp(projectRoot) {
+  if (existsSync8(join8(projectRoot, ".engram", "lsp-available"))) return true;
+  const candidates = [
+    "/tmp/tsserver.sock",
+    "/tmp/typescript-language-server.sock"
+  ];
+  return candidates.some((c) => existsSync8(c));
+}
+function checkAst(projectRoot) {
+  const grammarsDir = join8(projectRoot, "node_modules", "web-tree-sitter");
+  return existsSync8(grammarsDir);
+}
+function countIdeAdapters(projectRoot) {
+  let count = 0;
+  if (existsSync8(join8(projectRoot, ".cursor", "rules", "engram-context.mdc"))) {
+    count += 1;
+  }
+  const continueConfig = join8(
+    process.env.HOME ?? "",
+    ".continue",
+    "config.json"
+  );
+  if (existsSync8(continueConfig)) {
+    try {
+      const cfg = readFileSync4(continueConfig, "utf-8");
+      if (cfg.includes("engram")) count += 1;
+    } catch {
+    }
+  }
+  const zedSettings = join8(
+    process.env.HOME ?? "",
+    ".config",
+    "zed",
+    "settings.json"
+  );
+  if (existsSync8(zedSettings)) {
+    try {
+      const cfg = readFileSync4(zedSettings, "utf-8");
+      if (cfg.includes("engram")) count += 1;
+    } catch {
+    }
+  }
+  const claudeSettings = join8(projectRoot, ".claude", "settings.local.json");
+  if (existsSync8(claudeSettings)) {
+    try {
+      const cfg = readFileSync4(claudeSettings, "utf-8");
+      if (cfg.includes("engram")) count += 1;
+    } catch {
+    }
+  }
+  return count;
+}
+function refreshComponentStatus(projectRoot) {
+  const now = Date.now();
+  const components = [
+    { name: "http", available: checkHttp(projectRoot), checkedAt: now },
+    { name: "lsp", available: checkLsp(projectRoot), checkedAt: now },
+    { name: "ast", available: checkAst(projectRoot), checkedAt: now }
+  ];
+  const ideCount = countIdeAdapters(projectRoot);
+  const report = {
+    components,
+    ideCount,
+    generatedAt: now
+  };
+  try {
+    writeFileSync(statusPath(projectRoot), JSON.stringify(report), "utf-8");
+  } catch {
+  }
+  return report;
+}
+function getComponentStatus(projectRoot) {
+  const cached = readCachedStatus(projectRoot);
+  if (cached) return cached;
+  return refreshComponentStatus(projectRoot);
+}
+function formatHudStatus(report) {
+  const parts = [];
+  for (const c of report.components) {
+    const icon = c.available ? "\u2713" : "\u2717";
+    parts.push(`${c.name.toUpperCase()} ${icon}`);
+  }
+  if (report.ideCount > 0) {
+    parts.push(`${report.ideCount} IDE${report.ideCount > 1 ? "s" : ""}`);
+  }
+  return parts.join(" | ");
+}
+
 // src/intercept/memory-md.ts
 import {
-  existsSync as existsSync7,
-  readFileSync as readFileSync4,
-  writeFileSync,
-  renameSync as renameSync2,
-  statSync as statSync5
+  existsSync as existsSync9,
+  readFileSync as readFileSync5,
+  writeFileSync as writeFileSync2,
+  renameSync,
+  statSync as statSync4
 } from "fs";
-import { join as join7 } from "path";
+import { join as join9 } from "path";
 var ENGRAM_MARKER_START = "<!-- engram:structural-facts:start -->";
 var ENGRAM_MARKER_END = "<!-- engram:structural-facts:end -->";
 var MAX_MEMORY_FILE_BYTES = 1e6;
@@ -2476,20 +2922,20 @@ function writeEngramSectionToMemoryMd(projectRoot, engramSection) {
   if (engramSection.length > MAX_ENGRAM_SECTION_BYTES) {
     return false;
   }
-  const memoryPath = join7(projectRoot, "MEMORY.md");
+  const memoryPath = join9(projectRoot, "MEMORY.md");
   try {
     let existing = "";
-    if (existsSync7(memoryPath)) {
-      const st = statSync5(memoryPath);
+    if (existsSync9(memoryPath)) {
+      const st = statSync4(memoryPath);
       if (st.size > MAX_MEMORY_FILE_BYTES) {
         return false;
       }
-      existing = readFileSync4(memoryPath, "utf-8");
+      existing = readFileSync5(memoryPath, "utf-8");
     }
     const updated = upsertEngramSection(existing, engramSection);
     const tmpPath = memoryPath + ".engram-tmp";
-    writeFileSync(tmpPath, updated);
-    renameSync2(tmpPath, memoryPath);
+    writeFileSync2(tmpPath, updated);
+    renameSync(tmpPath, memoryPath);
     return true;
   } catch {
     return false;
@@ -2498,9 +2944,9 @@ function writeEngramSectionToMemoryMd(projectRoot, engramSection) {
 
 // src/cli.ts
 import { basename as basename5 } from "path";
-import { createRequire } from "module";
-var require2 = createRequire(import.meta.url);
-var { version: PKG_VERSION } = require2("../package.json");
+import { createRequire as createRequire2 } from "module";
+var require3 = createRequire2(import.meta.url);
+var { version: PKG_VERSION } = require3("../package.json");
 var program = new Command();
 program.name("engram").description(
   "Context as infra for AI coding tools \u2014 hook-based Read/Edit interception + structural graph summaries"
@@ -2508,7 +2954,7 @@ program.name("engram").description(
 program.command("init").description("Scan codebase and build knowledge graph (zero LLM cost)").argument("[path]", "Project directory", ".").option(
   "--with-skills [dir]",
   "Also index Claude Code skills from ~/.claude/skills/ or a given path"
-).action(async (projectPath, opts) => {
+).option("--from-ccs", "Import .context/index.md (CCS) into graph after init").action(async (projectPath, opts) => {
   console.log(chalk2.dim("\u{1F50D} Scanning codebase..."));
   const result = await init(projectPath, {
     withSkills: opts.withSkills
@@ -2537,9 +2983,9 @@ program.command("init").description("Scan codebase and build knowledge graph (ze
   console.log(chalk2.green("\n\u2705 Ready. Your AI now has persistent memory."));
   console.log(chalk2.dim("   Graph stored in .engram/graph.db"));
   const resolvedProject = pathResolve(projectPath);
-  const localSettings = join8(resolvedProject, ".claude", "settings.local.json");
-  const projectSettings = join8(resolvedProject, ".claude", "settings.json");
-  const hasHooks = existsSync8(localSettings) && readFileSync5(localSettings, "utf-8").includes("engram intercept") || existsSync8(projectSettings) && readFileSync5(projectSettings, "utf-8").includes("engram intercept");
+  const localSettings = join10(resolvedProject, ".claude", "settings.local.json");
+  const projectSettings = join10(resolvedProject, ".claude", "settings.json");
+  const hasHooks = existsSync10(localSettings) && readFileSync6(localSettings, "utf-8").includes("engram intercept") || existsSync10(projectSettings) && readFileSync6(projectSettings, "utf-8").includes("engram intercept");
   if (!hasHooks) {
     console.log(
       chalk2.yellow("\n\u{1F4A1} Next step: ") + chalk2.white("engram install-hook") + chalk2.dim(
@@ -2552,6 +2998,20 @@ program.command("init").description("Scan codebase and build knowledge graph (ze
       )
     );
   }
+  if (opts.fromCcs) {
+    const { importCcs } = await import("./importer-MCNFMV5O.js");
+    const resolvedProjectPath = pathResolve(projectPath);
+    const ccsResult = await importCcs(resolvedProjectPath);
+    if (ccsResult.nodesCreated > 0) {
+      console.log(
+        chalk2.cyan(
+          `   ${ccsResult.nodesCreated} nodes imported from .context/index.md`
+        )
+      );
+    } else {
+      console.log(chalk2.dim("   --from-ccs: no .context/index.md found, skipping"));
+    }
+  }
 });
 program.command("watch").description("Watch project for file changes and re-index incrementally").argument("[path]", "Project directory", ".").action(async (projectPath) => {
   const resolvedPath = pathResolve(projectPath);
@@ -2581,8 +3041,8 @@ program.command("watch").description("Watch project for file changes and re-inde
 });
 program.command("dashboard").alias("hud").description("Live terminal dashboard showing hook activity and token savings").argument("[path]", "Project directory", ".").action(async (projectPath) => {
   const resolvedPath = pathResolve(projectPath);
-  const dbPath = join8(resolvedPath, ".engram", "graph.db");
-  if (!existsSync8(dbPath)) {
+  const dbPath = join10(resolvedPath, ".engram", "graph.db");
+  if (!existsSync10(dbPath)) {
     console.error(
       chalk2.red("No engram graph found at ") + chalk2.white(resolvedPath)
     );
@@ -2602,11 +3062,11 @@ program.command("hud-label").description("Output JSON label for Claude HUD --ext
   let resolvedPath = pathResolve(projectPath);
   let found = false;
   for (let depth = 0; depth < 20; depth++) {
-    if (existsSync8(join8(resolvedPath, ".engram", "graph.db"))) {
+    if (existsSync10(join10(resolvedPath, ".engram", "graph.db"))) {
       found = true;
       break;
     }
-    const parent = dirname3(resolvedPath);
+    const parent = dirname4(resolvedPath);
     if (parent === resolvedPath) break;
     resolvedPath = parent;
   }
@@ -2614,8 +3074,8 @@ program.command("hud-label").description("Output JSON label for Claude HUD --ext
     console.log('{"label":""}');
     return;
   }
-  const logPath = join8(resolvedPath, ".engram", "hook-log.jsonl");
-  if (!existsSync8(logPath)) {
+  const logPath = join10(resolvedPath, ".engram", "hook-log.jsonl");
+  if (!existsSync10(logPath)) {
     console.log('{"label":"\u26A1engram \u2591\u2591\u2591\u2591\u2591\u2591\u2591\u2591\u2591\u2591 ready"}');
     return;
   }
@@ -2639,7 +3099,10 @@ program.command("hud-label").description("Output JSON label for Claude HUD --ext
     if (filled > barWidth) filled = barWidth;
     if (denied > 0 && filled === 0) filled = 1;
     const bar2 = "\u25B0".repeat(filled) + "\u25B1".repeat(barWidth - filled);
-    console.log(JSON.stringify({ label: `\u26A1engram ${formatted} saved ${bar2} ${hitRate}%` }));
+    const status2 = getComponentStatus(resolvedPath);
+    const statusSuffix = formatHudStatus(status2);
+    const label = statusSuffix ? `\u26A1engram ${formatted} saved ${bar2} ${hitRate}% | ${statusSuffix}` : `\u26A1engram ${formatted} saved ${bar2} ${hitRate}%`;
+    console.log(JSON.stringify({ label }));
   } catch {
     console.log('{"label":"\u26A1engram"}');
   }
@@ -2765,15 +3228,66 @@ program.command("gen").description("Generate CLAUDE.md / .cursorrules section fr
     );
   }
 );
+program.command("gen-mdc").description("Generate .cursor/rules/engram-context.mdc from knowledge graph").option("-p, --project <path>", "Project directory", ".").option("--watch", "Regenerate on graph changes").action(async (opts) => {
+  const { generateCursorMdc } = await import("./cursor-mdc-HWVUZUZH.js");
+  const result = await generateCursorMdc(opts.project);
+  console.log(
+    chalk2.green(
+      `\u2705 Generated ${result.filePath} (${result.sections} sections, ${result.nodes} nodes)`
+    )
+  );
+  if (opts.watch) {
+    watchProject(pathResolve(opts.project), {
+      onReindex: async () => {
+        const r = await generateCursorMdc(opts.project);
+        console.log(chalk2.dim(`  \u21BB Regenerated MDC (${r.nodes} nodes)`));
+      },
+      onError: (err) => console.error(chalk2.red(err.message)),
+      onReady: () => console.log(chalk2.dim("  Watching for changes..."))
+    });
+    await new Promise(() => {
+    });
+  }
+});
+program.command("gen-ccs").description("Export knowledge graph as .context/index.md (CCS format)").option("-p, --project <path>", "Project directory", ".").action(async (opts) => {
+  const { exportCcs } = await import("./exporter-A3VSLS4U.js");
+  const result = await exportCcs(pathResolve(opts.project));
+  console.log(
+    chalk2.green(
+      `\u2705 Generated ${result.filePath} (${result.sectionsWritten} sections, ${result.nodesExported} nodes)`
+    )
+  );
+});
+program.command("gen-aider").description("Generate .aider-context.md from knowledge graph").option("-p, --project <path>", "Project directory", ".").option("--watch", "Regenerate on graph changes").action(async (opts) => {
+  const { generateAiderContext } = await import("./aider-context-TNGSXMVY.js");
+  const result = await generateAiderContext(pathResolve(opts.project));
+  console.log(
+    chalk2.green(
+      `\u2705 Generated ${result.filePath} (${result.sections} sections, ${result.nodes} nodes)`
+    )
+  );
+  if (opts.watch) {
+    watchProject(pathResolve(opts.project), {
+      onReindex: async () => {
+        const r = await generateAiderContext(opts.project);
+        console.log(chalk2.dim(`  \u21BB Regenerated .aider-context.md (${r.nodes} nodes)`));
+      },
+      onError: (err) => console.error(chalk2.red(err.message)),
+      onReady: () => console.log(chalk2.dim("  Watching for changes..."))
+    });
+    await new Promise(() => {
+    });
+  }
+});
 function resolveSettingsPath(scope, projectPath) {
   const absProject = pathResolve(projectPath);
   switch (scope) {
     case "local":
-      return join8(absProject, ".claude", "settings.local.json");
+      return join10(absProject, ".claude", "settings.local.json");
     case "project":
-      return join8(absProject, ".claude", "settings.json");
+      return join10(absProject, ".claude", "settings.json");
     case "user":
-      return join8(homedir(), ".claude", "settings.json");
+      return join10(homedir(), ".claude", "settings.json");
     default:
       return null;
   }
@@ -2867,9 +3381,9 @@ program.command("install-hook").description("Install engram hook entries into Cl
       process.exit(1);
     }
     let existing = {};
-    if (existsSync8(settingsPath)) {
+    if (existsSync10(settingsPath)) {
       try {
-        const raw = readFileSync5(settingsPath, "utf-8");
+        const raw = readFileSync6(settingsPath, "utf-8");
         existing = raw.trim() ? JSON.parse(raw) : {};
       } catch (err) {
         console.error(
@@ -2914,18 +3428,18 @@ program.command("install-hook").description("Install engram hook entries into Cl
       return;
     }
     try {
-      mkdirSync(dirname3(settingsPath), { recursive: true });
-      if (existsSync8(settingsPath)) {
+      mkdirSync(dirname4(settingsPath), { recursive: true });
+      if (existsSync10(settingsPath)) {
         const backupPath = `${settingsPath}.engram-backup-${(/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-")}.bak`;
         copyFileSync(settingsPath, backupPath);
         console.log(chalk2.dim(`   Backup: ${backupPath}`));
       }
       const tmpPath = settingsPath + ".engram-tmp";
-      writeFileSync2(
+      writeFileSync3(
         tmpPath,
         JSON.stringify(result.updated, null, 2) + "\n"
       );
-      renameSync3(tmpPath, settingsPath);
+      renameSync2(tmpPath, settingsPath);
     } catch (err) {
       console.error(
         chalk2.red(`
@@ -2966,7 +3480,7 @@ program.command("uninstall-hook").description("Remove engram hook entries from C
     console.error(chalk2.red(`Unknown scope: ${opts.scope}`));
     process.exit(1);
   }
-  if (!existsSync8(settingsPath)) {
+  if (!existsSync10(settingsPath)) {
     console.log(
       chalk2.yellow(`No settings file at ${settingsPath} \u2014 nothing to remove.`)
     );
@@ -2974,7 +3488,7 @@ program.command("uninstall-hook").description("Remove engram hook entries from C
   }
   let existing;
   try {
-    const raw = readFileSync5(settingsPath, "utf-8");
+    const raw = readFileSync6(settingsPath, "utf-8");
     existing = raw.trim() ? JSON.parse(raw) : {};
   } catch (err) {
     console.error(
@@ -2994,8 +3508,8 @@ program.command("uninstall-hook").description("Remove engram hook entries from C
     const backupPath = `${settingsPath}.engram-backup-${(/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-")}.bak`;
     copyFileSync(settingsPath, backupPath);
     const tmpPath = settingsPath + ".engram-tmp";
-    writeFileSync2(tmpPath, JSON.stringify(result.updated, null, 2) + "\n");
-    renameSync3(tmpPath, settingsPath);
+    writeFileSync3(tmpPath, JSON.stringify(result.updated, null, 2) + "\n");
+    renameSync2(tmpPath, settingsPath);
     if (result.removed.length > 0) {
       console.log(
         chalk2.green(
@@ -3089,9 +3603,9 @@ program.command("hook-disable").description("Disable engram hooks via kill switc
     console.error(chalk2.dim("Run 'engram init' first."));
     process.exit(1);
   }
-  const flagPath = join8(projectRoot, ".engram", "hook-disabled");
+  const flagPath = join10(projectRoot, ".engram", "hook-disabled");
   try {
-    writeFileSync2(flagPath, (/* @__PURE__ */ new Date()).toISOString());
+    writeFileSync3(flagPath, (/* @__PURE__ */ new Date()).toISOString());
     console.log(
       chalk2.green(`\u2705 engram hooks disabled for ${projectRoot}`)
     );
@@ -3113,8 +3627,8 @@ program.command("hook-enable").description("Re-enable engram hooks (remove kill
     console.error(chalk2.red(`Not an engram project: ${absProject}`));
     process.exit(1);
   }
-  const flagPath = join8(projectRoot, ".engram", "hook-disabled");
-  if (!existsSync8(flagPath)) {
+  const flagPath = join10(projectRoot, ".engram", "hook-disabled");
+  if (!existsSync10(flagPath)) {
     console.log(
       chalk2.yellow(`engram hooks already enabled for ${projectRoot}`)
     );
@@ -3156,9 +3670,9 @@ program.command("memory-sync").description(
     }
     let branch = null;
     try {
-      const headPath = join8(projectRoot, ".git", "HEAD");
-      if (existsSync8(headPath)) {
-        const content = readFileSync5(headPath, "utf-8").trim();
+      const headPath = join10(projectRoot, ".git", "HEAD");
+      if (existsSync10(headPath)) {
+        const content = readFileSync6(headPath, "utf-8").trim();
         const m = content.match(/^ref:\s+refs\/heads\/(.+)$/);
         if (m) branch = m[1];
       }
@@ -3184,7 +3698,7 @@ program.command("memory-sync").description(
 \u{1F4DD} engram memory-sync`)
     );
     console.log(
-      chalk2.dim(`   Target: ${join8(projectRoot, "MEMORY.md")}`)
+      chalk2.dim(`   Target: ${join10(projectRoot, "MEMORY.md")}`)
     );
     if (opts.dryRun) {
       console.log(chalk2.cyan("\n   Section to write (dry-run):\n"));
@@ -3218,4 +3732,107 @@ program.command("memory-sync").description(
     );
   }
 );
+program.command("stress-test").description("Run stress tests: memory, concurrency, large-graph, hook-log replay").option("--reads <n>", "Rapid-reads test: call resolveRichPacket N times", parseInt).option("--providers", "Concurrency test: 50 parallel resolveRichPacket calls").option("--large-graph", "Large-graph test: insert N synthetic nodes and query").option("--nodes <n>", "Node count for --large-graph (default 1000)", parseInt).option("--replay <path>", "Hook-log replay: path to hook-log.jsonl").option("--limit <n>", "Entry limit for --replay (default 500)", parseInt).action(async (opts) => {
+  const { execFileSync: execFileSync2 } = await import("child_process");
+  const args = ["bench/stress-test.ts"];
+  if (opts.reads) args.push("--reads", String(opts.reads));
+  if (opts.providers) args.push("--providers");
+  if (opts.largeGraph) args.push("--large-graph");
+  if (opts.nodes) args.push("--nodes", String(opts.nodes));
+  if (opts.replay) args.push("--replay", opts.replay);
+  if (opts.limit) args.push("--limit", String(opts.limit));
+  try {
+    execFileSync2("npx", ["tsx", ...args], { stdio: "inherit", cwd: join10(dirname4(import.meta.url.replace("file://", "")), "..") });
+  } catch {
+    process.exit(1);
+  }
+});
+program.command("server").description("Start engram HTTP REST server (binds to 127.0.0.1 only)").option("--http", "Enable HTTP server (default)").option("--port <port>", "HTTP port", "7337").option("-p, --project <path>", "Project directory", ".").action(async (opts) => {
+  const { startHttpServer } = await import("./server-I3C74ZLB.js");
+  await startHttpServer(pathResolve(opts.project), parseInt(opts.port, 10));
+});
+program.command("context-server").description("Start Zed-compatible context server (JSON-RPC over stdio)").action(async () => {
+  const { execFileSync: execFileSync2 } = await import("child_process");
+  try {
+    execFileSync2("npx", ["tsx", "adapters/zed/index.ts"], {
+      stdio: "inherit",
+      cwd: join10(dirname4(import.meta.url.replace("file://", "")), "..")
+    });
+  } catch {
+    process.exit(1);
+  }
+});
+program.command("tune").description("Analyze hook-log and propose provider config changes").option("-p, --project <path>", "Project directory", ".").option("--dry-run", "Show proposed changes without applying (default)").option("--apply", "Apply proposed changes to .engram/config.json").action(async (opts) => {
+  const { analyzeTuning, applyTuning } = await import("./tuner-2LVIEE5V.js");
+  const proposal = analyzeTuning(pathResolve(opts.project));
+  if (proposal.changes.length === 0) {
+    console.log(
+      chalk2.dim(
+        `Analyzed ${proposal.entriesAnalyzed} entries (${proposal.daysSpanned} days) \u2014 no changes suggested.`
+      )
+    );
+    return;
+  }
+  console.log(
+    chalk2.bold(
+      `Analyzing ${proposal.entriesAnalyzed} hook-log entries from last ${proposal.daysSpanned} days...
+`
+    )
+  );
+  console.log(chalk2.bold("Proposed changes:"));
+  for (const c of proposal.changes) {
+    console.log(
+      `  ${c.field}: ${chalk2.red(String(c.current))} \u2192 ${chalk2.green(String(c.proposed))} \u2014 ${chalk2.dim(c.reason)}`
+    );
+  }
+  if (opts.apply) {
+    applyTuning(pathResolve(opts.project), proposal);
+    console.log(chalk2.green("\n\u2705 Changes applied to .engram/config.json"));
+  } else {
+    console.log(chalk2.dim("\nRun with --apply to write these changes."));
+  }
+});
+var dbCmd = program.command("db").description("Database management");
+dbCmd.command("status").description("Show schema version and migration status").option("-p, --project <path>", "Project directory", ".").action(async (opts) => {
+  const { getStore: getStore2 } = await import("./core-77MHT3QV.js");
+  const { CURRENT_SCHEMA_VERSION, getSchemaVersion } = await import("./migrate-5ZJWF2HD.js");
+  const store = await getStore2(pathResolve(opts.project));
+  try {
+    const version = getSchemaVersion(store.db);
+    const pending = CURRENT_SCHEMA_VERSION - version;
+    console.log(`Schema version: ${version} (current: ${CURRENT_SCHEMA_VERSION})`);
+    if (pending > 0) {
+      console.log(chalk2.yellow(`${pending} pending migration(s). Run 'engram db migrate' to update.`));
+    } else {
+      console.log(chalk2.green("Up to date."));
+    }
+  } finally {
+    store.close();
+  }
+});
+dbCmd.command("migrate").description("Run pending schema migrations").option("-p, --project <path>", "Project directory", ".").action(async (opts) => {
+  const { getStore: getStore2 } = await import("./core-77MHT3QV.js");
+  const { runMigrations } = await import("./migrate-5ZJWF2HD.js");
+  const store = await getStore2(pathResolve(opts.project));
+  try {
+    const dbPath = join10(pathResolve(opts.project), ".engram", "graph.db");
+    const result = runMigrations(
+      store.db,
+      dbPath
+    );
+    store.save();
+    if (result.migrationsRun === 0) {
+      console.log(chalk2.green("Already up to date."));
+    } else {
+      console.log(
+        chalk2.green(`Migrated v${result.fromVersion} \u2192 v${result.toVersion} (${result.migrationsRun} migrations)`)
+      );
+      if (result.backedUp) {
+        console.log(chalk2.dim("Backup created."));
+      }
+    }
+  } finally {
+    store.close();
+  }
+});
 program.parse();