engramx 2.0.2 → 3.0.0

package/dist/chunk-RJC6RNXJ.js

@@ -0,0 +1,1405 @@
+import {
+  readConfig
+} from "./chunk-22INHMKB.js";
+import {
+  getStore,
+  renderFileStructure
+} from "./chunk-B4UOE64J.js";
+
+// src/providers/types.ts
+var PROVIDER_PRIORITY = [
+  "engram:ast",
+  "engram:structure",
+  "engram:mistakes",
+  // anthropic:memory sits between mistakes and mempalace — it's cheap
+  // (tier 1, single local file read), strictly relevant when present,
+  // and complements mistakes (mistakes = 'this broke'; anthropic:memory
+  // = 'here's what we learned about this area'). Placing it above
+  // mempalace keeps Claude Code users' own curated memory first.
+  "anthropic:memory",
+  "mempalace",
+  "context7",
+  "engram:git",
+  "obsidian",
+  "engram:lsp"
+];
+var DEFAULT_CACHE_TTL_SEC = 3600;
+
+// src/providers/ast.ts
+import { readFileSync } from "fs";
+
+// src/providers/grammar-loader.ts
+import { existsSync } from "fs";
+import { join, dirname } 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 = dirname(fileURLToPath(import.meta.url));
+    candidates.push(join(here, "..", "grammars", wasmName));
+    candidates.push(join(here, "grammars", wasmName));
+  } catch {
+  }
+  try {
+    const here = dirname(fileURLToPath(import.meta.url));
+    candidates.push(join(here, "..", "..", "node_modules", pkg, wasmName));
+  } catch {
+  }
+  try {
+    const pkgMain = require2.resolve(`${pkg}/package.json`);
+    const pkgDir = dirname(pkgMain);
+    candidates.push(join(pkgDir, wasmName));
+  } catch {
+  }
+  return candidates.find((c) => existsSync(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",
+  label: "STRUCTURE",
+  tier: 1,
+  tokenBudget: 250,
+  timeoutMs: 500,
+  async resolve(filePath, context) {
+    try {
+      const store = await getStore(context.projectRoot);
+      try {
+        const result = renderFileStructure(store, filePath);
+        if (!result || result.nodeCount === 0) return null;
+        return {
+          provider: "engram:structure",
+          content: result.text,
+          confidence: result.avgConfidence,
+          cached: false
+        };
+      } finally {
+        store.close();
+      }
+    } catch {
+      return null;
+    }
+  },
+  async isAvailable() {
+    return true;
+  }
+};
+
+// src/providers/engram-mistakes.ts
+var mistakesProvider = {
+  name: "engram:mistakes",
+  label: "KNOWN ISSUES",
+  tier: 1,
+  tokenBudget: 50,
+  timeoutMs: 200,
+  async resolve(filePath, context) {
+    try {
+      const store = await getStore(context.projectRoot);
+      try {
+        const now = Date.now();
+        const allMistakes = store.getNodesByFile(filePath).filter((n) => n.kind === "mistake").filter((n) => n.validUntil === void 0 || n.validUntil > now);
+        if (allMistakes.length === 0) return null;
+        const lines = allMistakes.slice(0, 5).map((m) => `  ! ${m.label} (flagged ${formatAge(m.lastVerified)})`).join("\n");
+        return {
+          provider: "engram:mistakes",
+          content: lines,
+          confidence: 0.95,
+          cached: false
+        };
+      } finally {
+        store.close();
+      }
+    } catch {
+      return null;
+    }
+  },
+  async isAvailable() {
+    return true;
+  }
+};
+function formatAge(timestampMs) {
+  if (timestampMs === 0) return "unknown";
+  const days = Math.floor((Date.now() - timestampMs) / (1e3 * 60 * 60 * 24));
+  if (days === 0) return "today";
+  if (days === 1) return "yesterday";
+  if (days < 30) return `${days}d ago`;
+  return `${Math.floor(days / 30)}mo ago`;
+}
+
+// src/providers/engram-git.ts
+import { execFileSync } from "child_process";
+var gitProvider = {
+  name: "engram:git",
+  label: "CHANGES",
+  tier: 1,
+  tokenBudget: 50,
+  timeoutMs: 200,
+  async resolve(filePath, context) {
+    try {
+      const cwd = context.projectRoot;
+      const lastLog = git(
+        ["log", "-1", "--format=%ar|%an|%s", "--", filePath],
+        cwd
+      );
+      if (!lastLog) return null;
+      const [timeAgo, author, message] = lastLog.split("|", 3);
+      const recentCount = git(
+        [
+          "rev-list",
+          "--count",
+          "--since=30.days",
+          "HEAD",
+          "--",
+          filePath
+        ],
+        cwd
+      );
+      const churnNote = context.churnRate > 0.3 ? "high churn" : context.churnRate > 0.1 ? "moderate" : "stable";
+      const parts = [
+        `  Last modified: ${timeAgo} by ${author} (${truncate(message, 50)})`,
+        `  Churn: ${context.churnRate.toFixed(2)} (${churnNote}) | ${recentCount || "0"} changes in 30d`
+      ];
+      return {
+        provider: "engram:git",
+        content: parts.join("\n"),
+        confidence: 0.9,
+        cached: false
+      };
+    } catch {
+      return null;
+    }
+  },
+  async isAvailable() {
+    try {
+      execFileSync("git", ["--version"], {
+        encoding: "utf-8",
+        timeout: 2e3
+      });
+      return true;
+    } catch {
+      return false;
+    }
+  }
+};
+function git(args, cwd) {
+  try {
+    return execFileSync("git", args, {
+      cwd,
+      encoding: "utf-8",
+      timeout: 3e3,
+      maxBuffer: 1024 * 1024
+    }).trim();
+  } catch {
+    return "";
+  }
+}
+function truncate(s, max) {
+  return s.length <= max ? s : s.slice(0, max - 1) + "\u2026";
+}
+
+// src/providers/mempalace.ts
+import { execFile } from "child_process";
+var MAX_SEARCH_RESULTS = 3;
+var mempalaceProvider = {
+  name: "mempalace",
+  label: "DECISIONS",
+  tier: 2,
+  tokenBudget: 100,
+  timeoutMs: 200,
+  async resolve(filePath, context) {
+    try {
+      const store = await getStore(context.projectRoot);
+      try {
+        const cached = store.getCachedContextForProvider(
+          "mempalace",
+          filePath
+        );
+        if (cached) {
+          return {
+            provider: "mempalace",
+            content: cached.content,
+            confidence: 0.8,
+            cached: true
+          };
+        }
+      } finally {
+        store.close();
+      }
+      const query = buildQuery(filePath, context);
+      const raw = await searchMempalace(query);
+      if (!raw) return null;
+      const content = formatResults(raw);
+      if (!content) return null;
+      const store2 = await getStore(context.projectRoot);
+      try {
+        store2.setCachedContext(
+          "mempalace",
+          filePath,
+          content,
+          DEFAULT_CACHE_TTL_SEC,
+          query
+        );
+        store2.save();
+      } finally {
+        store2.close();
+      }
+      return {
+        provider: "mempalace",
+        content,
+        confidence: 0.8,
+        cached: false
+      };
+    } catch {
+      return null;
+    }
+  },
+  async warmup(projectRoot) {
+    const start = Date.now();
+    const entries = [];
+    try {
+      const store = await getStore(projectRoot);
+      let projectName;
+      try {
+        projectName = store.getStat("project_name") ?? projectRoot.split("/").pop() ?? "";
+      } finally {
+        store.close();
+      }
+      if (!projectName) {
+        return { provider: "mempalace", entries, durationMs: Date.now() - start };
+      }
+      const raw = await searchMempalace(
+        `${projectName} decisions architecture patterns`
+      );
+      if (!raw) {
+        return { provider: "mempalace", entries, durationMs: Date.now() - start };
+      }
+      const content = formatResults(raw);
+      if (content) {
+        entries.push({ filePath: "__project__", content });
+      }
+    } catch {
+    }
+    return { provider: "mempalace", entries, durationMs: Date.now() - start };
+  },
+  async isAvailable() {
+    try {
+      const result = await execFilePromise("mcp-mempalace", [
+        "mempalace-status"
+      ]);
+      return result.includes("palace") || result.includes("drawers");
+    } catch {
+      return false;
+    }
+  }
+};
+function buildQuery(filePath, context) {
+  const fileName = filePath.split("/").pop()?.replace(/\.\w+$/, "") ?? "";
+  const importTerms = context.imports.slice(0, 3).join(" ");
+  return `${fileName} ${importTerms}`.trim();
+}
+function searchMempalace(query) {
+  return new Promise((resolve) => {
+    const timeout = setTimeout(() => resolve(null), 3e3);
+    execFile(
+      "mcp-mempalace",
+      ["mempalace-search", "--query", query],
+      { encoding: "utf-8", timeout: 3e3, maxBuffer: 1024 * 1024 },
+      (err, stdout) => {
+        clearTimeout(timeout);
+        if (err || !stdout.trim()) {
+          resolve(null);
+          return;
+        }
+        resolve(stdout.trim());
+      }
+    );
+  });
+}
+function formatResults(raw) {
+  try {
+    const parsed = JSON.parse(raw);
+    const results = Array.isArray(parsed) ? parsed : parsed?.results ?? parsed?.drawers ?? [];
+    if (results.length === 0) return null;
+    const lines = results.slice(0, MAX_SEARCH_RESULTS).map((r) => {
+      const content = r.content ?? r.text ?? r.summary ?? "";
+      const truncated = content.split(/\s+/).slice(0, 30).join(" ");
+      return `  - ${truncated}`;
+    }).filter((l) => l.length > 4);
+    return lines.length > 0 ? lines.join("\n") : null;
+  } catch {
+    const lines = raw.split("\n").filter((l) => l.trim()).slice(0, MAX_SEARCH_RESULTS).map((l) => `  - ${l.trim().slice(0, 120)}`);
+    return lines.length > 0 ? lines.join("\n") : null;
+  }
+}
+function execFilePromise(cmd, args) {
+  return new Promise((resolve, reject) => {
+    execFile(
+      cmd,
+      args,
+      { encoding: "utf-8", timeout: 3e3 },
+      (err, stdout) => {
+        if (err) reject(err);
+        else resolve(stdout.trim());
+      }
+    );
+  });
+}
+
+// src/providers/context7.ts
+import { execFile as execFile2 } from "child_process";
+var LIBRARY_CACHE_TTL = 4 * 3600;
+var context7Provider = {
+  name: "context7",
+  label: "LIBRARY",
+  tier: 2,
+  tokenBudget: 100,
+  timeoutMs: 200,
+  async resolve(filePath, context) {
+    if (context.imports.length === 0) return null;
+    try {
+      const store = await getStore(context.projectRoot);
+      try {
+        const cached = store.getCachedContextForProvider("context7", filePath);
+        if (cached) {
+          return {
+            provider: "context7",
+            content: cached.content,
+            confidence: 0.85,
+            cached: true
+          };
+        }
+      } finally {
+        store.close();
+      }
+      const primaryImport = context.imports[0];
+      const docs = await queryContext7(primaryImport);
+      if (!docs) return null;
+      const content = formatDocs(primaryImport, docs);
+      if (!content) return null;
+      const store2 = await getStore(context.projectRoot);
+      try {
+        store2.setCachedContext(
+          "context7",
+          filePath,
+          content,
+          LIBRARY_CACHE_TTL,
+          primaryImport
+        );
+        store2.save();
+      } finally {
+        store2.close();
+      }
+      return {
+        provider: "context7",
+        content,
+        confidence: 0.85,
+        cached: false
+      };
+    } catch {
+      return null;
+    }
+  },
+  async warmup(projectRoot) {
+    const start = Date.now();
+    const entries = [];
+    try {
+      const store = await getStore(projectRoot);
+      let importEdges;
+      try {
+        const allEdges = store.getAllEdges();
+        importEdges = allEdges.filter((e) => e.relation === "imports").map((e) => ({ source: e.sourceFile, target: e.target }));
+      } finally {
+        store.close();
+      }
+      const packages = [
+        ...new Set(
+          importEdges.map((e) => {
+            const parts = e.target.split("::");
+            return parts[parts.length - 1];
+          }).filter(isExternalPackage)
+        )
+      ].slice(0, 10);
+      for (const pkg of packages) {
+        const docs = await queryContext7(pkg);
+        if (docs) {
+          const content = formatDocs(pkg, docs);
+          if (content) {
+            const files = importEdges.filter((e) => e.target.includes(pkg)).map((e) => e.source);
+            for (const file of [...new Set(files)]) {
+              entries.push({ filePath: file, content });
+            }
+          }
+        }
+      }
+    } catch {
+    }
+    return { provider: "context7", entries, durationMs: Date.now() - start };
+  },
+  async isAvailable() {
+    try {
+      const result = await execFilePromise2("mcp-context7", ["--list"]);
+      return result.includes("resolve-library-id");
+    } catch {
+      return false;
+    }
+  }
+};
+function isExternalPackage(name) {
+  if (!name) return false;
+  if (name.startsWith(".") || name.startsWith("/")) return false;
+  if ([
+    "fs",
+    "path",
+    "os",
+    "url",
+    "http",
+    "https",
+    "crypto",
+    "stream",
+    "util",
+    "events",
+    "child_process",
+    "node:fs",
+    "node:path",
+    "node:os",
+    "node:url",
+    "node:http",
+    "node:https",
+    "node:crypto",
+    "node:stream",
+    "node:util",
+    "node:events",
+    "node:child_process"
+  ].includes(name))
+    return false;
+  return true;
+}
+function queryContext7(packageName) {
+  return new Promise((resolve) => {
+    const timeout = setTimeout(() => resolve(null), 5e3);
+    execFile2(
+      "mcp-context7",
+      [
+        "query-docs",
+        "--context7CompatibleLibraryID",
+        packageName,
+        "--topic",
+        "API reference quick start"
+      ],
+      { encoding: "utf-8", timeout: 5e3, maxBuffer: 2 * 1024 * 1024 },
+      (err, stdout) => {
+        clearTimeout(timeout);
+        if (err || !stdout.trim()) {
+          resolve(null);
+          return;
+        }
+        resolve(stdout.trim());
+      }
+    );
+  });
+}
+function formatDocs(pkg, raw) {
+  const truncated = raw.slice(0, 400);
+  const lines = truncated.split("\n").filter((l) => l.trim()).slice(0, 5).map((l) => `  ${l.trim()}`);
+  if (lines.length === 0) return null;
+  return `  ${pkg}:
+${lines.join("\n")}`;
+}
+function execFilePromise2(cmd, args) {
+  return new Promise((resolve, reject) => {
+    execFile2(
+      cmd,
+      args,
+      { encoding: "utf-8", timeout: 3e3 },
+      (err, stdout) => {
+        if (err) reject(err);
+        else resolve(stdout.trim());
+      }
+    );
+  });
+}
+
+// src/providers/obsidian.ts
+var OBSIDIAN_PORT = 27124;
+var OBSIDIAN_BASE = `http://127.0.0.1:${OBSIDIAN_PORT}`;
+var obsidianProvider = {
+  name: "obsidian",
+  label: "PROJECT NOTES",
+  tier: 2,
+  tokenBudget: 50,
+  timeoutMs: 200,
+  async resolve(filePath, context) {
+    try {
+      const store = await getStore(context.projectRoot);
+      try {
+        const cached = store.getCachedContextForProvider("obsidian", filePath);
+        if (cached) {
+          return {
+            provider: "obsidian",
+            content: cached.content,
+            confidence: 0.7,
+            cached: true
+          };
+        }
+      } finally {
+        store.close();
+      }
+      const projectName = context.projectRoot.split("/").pop() ?? "";
+      const fileName = filePath.split("/").pop()?.replace(/\.\w+$/, "") ?? "";
+      const query = `${projectName} ${fileName}`;
+      const results = await searchObsidian(query);
+      if (!results) return null;
+      const content = formatResults2(results);
+      if (!content) return null;
+      const store2 = await getStore(context.projectRoot);
+      try {
+        store2.setCachedContext(
+          "obsidian",
+          filePath,
+          content,
+          DEFAULT_CACHE_TTL_SEC,
+          query
+        );
+        store2.save();
+      } finally {
+        store2.close();
+      }
+      return {
+        provider: "obsidian",
+        content,
+        confidence: 0.7,
+        cached: false
+      };
+    } catch {
+      return null;
+    }
+  },
+  async warmup(projectRoot) {
+    const start = Date.now();
+    const entries = [];
+    try {
+      const projectName = projectRoot.split("/").pop() ?? "";
+      if (!projectName) {
+        return { provider: "obsidian", entries, durationMs: Date.now() - start };
+      }
+      const results = await searchObsidian(
+        `${projectName} architecture design decisions`
+      );
+      if (results) {
+        const content = formatResults2(results);
+        if (content) {
+          entries.push({ filePath: "__project__", content });
+        }
+      }
+    } catch {
+    }
+    return { provider: "obsidian", entries, durationMs: Date.now() - start };
+  },
+  async isAvailable() {
+    try {
+      const response = await fetchWithTimeout(
+        `${OBSIDIAN_BASE}/`,
+        1e3
+      );
+      return response.ok;
+    } catch {
+      return false;
+    }
+  }
+};
+async function searchObsidian(query) {
+  try {
+    const response = await fetchWithTimeout(
+      `${OBSIDIAN_BASE}/search/simple/?query=${encodeURIComponent(query)}`,
+      2e3
+    );
+    if (!response.ok) return null;
+    const data = await response.json();
+    if (!Array.isArray(data) || data.length === 0) return null;
+    return data.slice(0, 3);
+  } catch {
+    return null;
+  }
+}
+function formatResults2(results) {
+  if (results.length === 0) return null;
+  const lines = results.slice(0, 3).map((r) => {
+    const name = r.filename.replace(/\.md$/, "");
+    return `  Related: ${name}`;
+  });
+  return lines.join("\n");
+}
+async function fetchWithTimeout(url, timeoutMs) {
+  const controller = new AbortController();
+  const timer = setTimeout(() => controller.abort(), timeoutMs);
+  try {
+    return await fetch(url, { signal: controller.signal });
+  } finally {
+    clearTimeout(timer);
+  }
+}
+
+// src/providers/lsp-connection.ts
+import { connect } from "net";
+import { existsSync as existsSync2 } from "fs";
+import { tmpdir } from "os";
+import { join as join2 } from "path";
+function candidateSockets() {
+  const uid = process.getuid?.() ?? 0;
+  const tmp = tmpdir();
+  return [
+    // TypeScript language server (used by VS Code)
+    join2(tmp, `tsserver-${uid}.sock`),
+    // Generic LSP socket (some editors, e.g. Helix)
+    join2(tmp, "lsp-server.sock"),
+    // TypeScript language server alternate path
+    join2(tmp, "typescript-language-server.sock"),
+    // Pyright (Python)
+    join2(tmp, `pyright-${uid}.sock`),
+    // rust-analyzer
+    join2(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) => existsSync2(p));
+    if (candidates.length === 0) return null;
+    for (const path of candidates) {
+      try {
+        const conn = new _LspConnection();
+        await conn._connect(path);
+        return conn;
+      } catch {
+        continue;
+      }
+    }
+    return null;
+  }
+  /** Internal: open a socket to the given path with a 500ms timeout. */
+  _connect(socketPath) {
+    return new Promise((resolve, 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;
+        resolve();
+      });
+      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/anthropic-memory.ts
+import { existsSync as existsSync3, readFileSync as readFileSync2, statSync } from "fs";
+import { join as join3 } from "path";
+import { homedir } from "os";
+function encodeProjectPath(absPath) {
+  const posix = absPath.split(/[\\/]/).join("/");
+  const trimmed = posix.replace(/\/+$/, "");
+  return trimmed.replace(/\//g, "-");
+}
+function getMemoryIndexPath(projectRoot) {
+  const encoded = encodeProjectPath(projectRoot);
+  return join3(homedir(), ".claude", "projects", encoded, "memory", "MEMORY.md");
+}
+function parseMemoryIndex(content) {
+  const entries = [];
+  const lines = content.split("\n");
+  const bullet = /^-\s*\[([^\]]+)\]\(([^)]+)\)\s*(?:[—–-]\s*)?(.*)$/;
+  for (const raw of lines) {
+    const line = raw.trim();
+    if (line.length === 0) continue;
+    if (!line.startsWith("-")) continue;
+    const match = bullet.exec(line);
+    if (!match) continue;
+    const [, title, file, rest] = match;
+    entries.push({
+      title: title.trim(),
+      file: file.trim(),
+      description: (rest ?? "").trim()
+    });
+  }
+  return entries;
+}
+function scoreEntry(entry, ctx) {
+  const basename = ctx.filePath.split(/[\\/]/).pop()?.replace(/\.[^.]+$/, "") ?? "";
+  const segments = ctx.filePath.split(/[\\/]/).filter((s) => s.length > 2);
+  const t = entry.title.toLowerCase();
+  const d = entry.description.toLowerCase();
+  let score = 0;
+  if (basename.length > 2 && t.includes(basename.toLowerCase())) score += 3;
+  if (basename.length > 2 && d.includes(basename.toLowerCase())) score += 2;
+  for (const imp of ctx.imports) {
+    const lower = imp.toLowerCase();
+    if (lower.length < 3) continue;
+    if (t.includes(lower) || d.includes(lower)) {
+      score += 2;
+      break;
+    }
+  }
+  for (const seg of segments) {
+    const lower = seg.toLowerCase();
+    if (lower.length < 3) continue;
+    if (t.includes(lower) || d.includes(lower)) {
+      score += 1;
+      break;
+    }
+  }
+  return score;
+}
+var OVERRIDE_ENV = "ENGRAM_ANTHROPIC_MEMORY_PATH";
+var MAX_INDEX_BYTES = 1048576;
+var anthropicMemoryProvider = {
+  name: "anthropic:memory",
+  label: "ANTHROPIC MEMORY",
+  tier: 1,
+  tokenBudget: 120,
+  timeoutMs: 200,
+  async isAvailable() {
+    try {
+      const override = process.env[OVERRIDE_ENV];
+      if (override) return existsSync3(override);
+      return true;
+    } catch {
+      return false;
+    }
+  },
+  async resolve(filePath, context) {
+    try {
+      const path = process.env[OVERRIDE_ENV] || getMemoryIndexPath(context.projectRoot);
+      if (!existsSync3(path)) return null;
+      const size = statSync(path).size;
+      if (size === 0) return null;
+      if (size > MAX_INDEX_BYTES) return null;
+      const content = readFileSync2(path, "utf-8");
+      const entries = parseMemoryIndex(content);
+      if (entries.length === 0) return null;
+      const scored = entries.map((e) => ({
+        entry: e,
+        score: scoreEntry(e, { filePath, imports: context.imports })
+      })).filter((s) => s.score > 0).sort((a, b) => b.score - a.score);
+      if (scored.length === 0) return null;
+      const top = scored.slice(0, 3);
+      const lines = top.map((s) => {
+        const desc = s.entry.description ? ` \u2014 ${s.entry.description}` : "";
+        return `  \u2022 ${s.entry.title}${desc}`;
+      });
+      return {
+        provider: "anthropic:memory",
+        content: lines.join("\n"),
+        confidence: 0.85,
+        cached: false
+      };
+    } catch {
+      return null;
+    }
+  }
+};
+
+// src/providers/resolver.ts
+var BUILTIN_PROVIDERS = [
+  astProvider,
+  structureProvider,
+  mistakesProvider,
+  anthropicMemoryProvider,
+  gitProvider,
+  mempalaceProvider,
+  context7Provider,
+  obsidianProvider,
+  lspProvider
+];
+var BUILTIN_NAMES = new Set(BUILTIN_PROVIDERS.map((p) => p.name));
+var mcpProvidersCache = null;
+async function getMcpProviders() {
+  if (mcpProvidersCache) return mcpProvidersCache;
+  try {
+    const [{ loadMcpConfigs }, { createMcpProvider }] = await Promise.all([
+      import("./mcp-config-QD4NPVXB.js"),
+      import("./mcp-client-ROOJF76V.js")
+    ]);
+    const { configs, failed } = loadMcpConfigs();
+    if (failed.length > 0) {
+      for (const f of failed) {
+        process.stderr.write(
+          `[engram] mcp-providers.json entry ${f.index}: ${f.reason}
+`
+        );
+      }
+    }
+    mcpProvidersCache = configs.map(createMcpProvider);
+  } catch {
+    mcpProvidersCache = [];
+  }
+  return mcpProvidersCache;
+}
+function _resetMcpProvidersCache() {
+  mcpProvidersCache = null;
+}
+async function getAllProviders() {
+  const [{ getLoadedPlugins }, mcpProviders] = await Promise.all([
+    import("./plugin-loader-SQQB6V74.js"),
+    getMcpProviders()
+  ]);
+  const { loaded } = await getLoadedPlugins();
+  const safePlugins = loaded.filter((p) => !BUILTIN_NAMES.has(p.name));
+  const safeMcp = mcpProviders.filter((p) => !BUILTIN_NAMES.has(p.name));
+  return [...BUILTIN_PROVIDERS, ...safePlugins, ...safeMcp];
+}
+var ALL_PROVIDERS = BUILTIN_PROVIDERS;
+function estimateTokens(text) {
+  return Math.ceil(text.length / 4);
+}
+async function resolveRichPacket(filePath, context, enabledProviders) {
+  const start = Date.now();
+  let allProviders;
+  try {
+    allProviders = await getAllProviders();
+  } catch {
+    allProviders = BUILTIN_PROVIDERS;
+  }
+  const providers = allProviders.filter((p) => {
+    if (enabledProviders && !enabledProviders.includes(p.name)) return false;
+    return true;
+  });
+  const available = await filterAvailable(providers);
+  if (available.length === 0) return null;
+  const settled = await Promise.allSettled(
+    available.map((p) => resolveWithTimeout(p, filePath, context))
+  );
+  const results = [];
+  for (const outcome of settled) {
+    if (outcome.status === "fulfilled" && outcome.value) {
+      results.push(outcome.value);
+    }
+  }
+  if (results.length === 0) return null;
+  const hasAst = results.some((r) => r.provider === "engram:ast");
+  const deduped = hasAst ? results.filter((r) => r.provider !== "engram:structure") : results;
+  const budgetedResults = enforcePerProviderBudget(deduped, allProviders);
+  const boosted = boostByMistakes(budgetedResults);
+  const sorted = [...boosted].sort((a, b) => {
+    const aIdx = PROVIDER_PRIORITY.indexOf(a.provider);
+    const bIdx = PROVIDER_PRIORITY.indexOf(b.provider);
+    const pa = aIdx === -1 ? 99 : aIdx;
+    const pb = bIdx === -1 ? 99 : bIdx;
+    if (pa !== pb) return pa - pb;
+    return b.confidence - a.confidence;
+  });
+  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 > budget) {
+      break;
+    }
+    const provider = allProviders.find((p) => p.name === result.provider);
+    const label = provider?.label ?? result.provider.toUpperCase();
+    const cacheTag = result.cached ? ", cached" : "";
+    sections.push(`${label} (${result.provider}${cacheTag}):
+${result.content}`);
+    totalTokens += sectionTokens;
+  }
+  if (sections.length === 0) return null;
+  const providerNames = sorted.filter((_, i) => i < sections.length).map((r) => r.provider);
+  const isEnrichment = enabledProviders && !enabledProviders.includes("engram:structure");
+  const header = isEnrichment ? `[engram] Additional context (${providerNames.length} providers, ~${totalTokens} tokens)` : `[engram] Rich context for ${filePath} (${providerNames.length} providers, ~${totalTokens} tokens)`;
+  const text = `${header}
+
+${sections.join("\n\n")}`;
+  return {
+    text,
+    providerCount: providerNames.length,
+    providers: providerNames,
+    estimatedTokens: totalTokens + estimateTokens(header),
+    durationMs: Date.now() - start
+  };
+}
+async function* resolveRichPacketStreaming(filePath, context, enabledProviders) {
+  const start = Date.now();
+  let allProviders;
+  try {
+    allProviders = await getAllProviders();
+  } catch {
+    allProviders = BUILTIN_PROVIDERS;
+  }
+  const providers = allProviders.filter(
+    (p) => !enabledProviders || enabledProviders.includes(p.name)
+  );
+  const available = await filterAvailable(providers);
+  if (available.length === 0) {
+    yield { type: "done", providerCount: 0, durationMs: Date.now() - start };
+    return;
+  }
+  const queue = [];
+  let wake = null;
+  let remaining = available.length;
+  for (const p of available) {
+    resolveWithTimeout(p, filePath, context).then((r) => queue.push({ result: r, provider: p })).catch(() => queue.push({ result: null, provider: p })).finally(() => {
+      remaining--;
+      wake?.();
+      wake = null;
+    });
+  }
+  let yielded = 0;
+  while (remaining > 0 || queue.length > 0) {
+    while (queue.length > 0) {
+      const outcome = queue.shift();
+      if (outcome.result) {
+        yielded++;
+        yield { type: "provider", result: outcome.result };
+      }
+    }
+    if (remaining > 0) {
+      await new Promise((r) => {
+        wake = r;
+      });
+    }
+  }
+  yield {
+    type: "done",
+    providerCount: yielded,
+    durationMs: Date.now() - start
+  };
+}
+async function warmAllProviders(projectRoot, enabledProviders) {
+  const start = Date.now();
+  const warmed = [];
+  const tier2 = ALL_PROVIDERS.filter(
+    (p) => p.tier === 2 && p.warmup && (!enabledProviders || enabledProviders.includes(p.name))
+  );
+  const available = await filterAvailable(tier2);
+  const settled = await Promise.allSettled(
+    available.map(async (p) => {
+      try {
+        const result = await withTimeout(p.warmup(projectRoot), 5e3);
+        if (result && result.entries.length > 0) {
+          const { getStore: getStore2 } = await import("./core-77F2BVYV.js");
+          const store = await getStore2(projectRoot);
+          try {
+            store.warmCache(
+              result.provider,
+              [...result.entries],
+              result.provider === "context7" ? 4 * 3600 : 3600
+            );
+            store.save();
+          } finally {
+            store.close();
+          }
+          warmed.push(p.name);
+        }
+      } catch {
+      }
+    })
+  );
+  return { warmed, durationMs: Date.now() - start };
+}
+function enforcePerProviderBudget(results, providers) {
+  const out = [];
+  for (const r of results) {
+    const provider = providers.find((p) => p.name === r.provider);
+    const budget = provider?.tokenBudget ?? 200;
+    if (estimateTokens(r.content) <= budget) {
+      out.push(r);
+      continue;
+    }
+    const lines = r.content.split("\n");
+    const kept = [];
+    let used = 0;
+    for (const line of lines) {
+      const lineTokens = estimateTokens(line) + 1;
+      if (used + lineTokens > budget) break;
+      kept.push(line);
+      used += lineTokens;
+    }
+    const truncated = kept.length > 0 ? kept.join("\n") + "\n\u2026 [truncated]" : r.content.slice(0, budget * 4 - 20) + "\u2026 [truncated]";
+    out.push({ ...r, content: truncated });
+  }
+  return out;
+}
+function extractMistakeLabels(mistakesContent) {
+  const labels = [];
+  for (const line of mistakesContent.split("\n")) {
+    const match = line.match(/^\s*!\s+(.+?)\s+\(flagged/);
+    if (match && match[1]) {
+      labels.push(match[1].trim().toLowerCase());
+    }
+  }
+  return labels;
+}
+function boostByMistakes(results) {
+  const mistakesResult = results.find((r) => r.provider === "engram:mistakes");
+  if (!mistakesResult) return [...results];
+  const labels = extractMistakeLabels(mistakesResult.content);
+  if (labels.length === 0) return [...results];
+  return results.map((r) => {
+    if (r.provider === "engram:mistakes") return r;
+    const lower = r.content.toLowerCase();
+    const matched = labels.some((label) => lower.includes(label));
+    if (!matched) return r;
+    return {
+      ...r,
+      confidence: Math.min(1, r.confidence * 1.5)
+    };
+  });
+}
+var availabilityCache = /* @__PURE__ */ new Map();
+function _resetAvailabilityCache() {
+  availabilityCache.clear();
+}
+async function filterAvailable(providers) {
+  const checks = providers.map(async (p) => {
+    let available = availabilityCache.get(p.name);
+    if (available === void 0) {
+      try {
+        const timeout = p.tier === 1 ? 200 : 500;
+        available = await withTimeout(p.isAvailable(), timeout);
+      } catch {
+        available = false;
+      }
+      availabilityCache.set(p.name, available);
+    }
+    return { provider: p, available };
+  });
+  const settled = await Promise.all(checks);
+  return settled.filter((c) => c.available).map((c) => c.provider);
+}
+async function resolveWithTimeout(provider, filePath, context) {
+  try {
+    return await withTimeout(
+      provider.resolve(filePath, context),
+      provider.timeoutMs
+    );
+  } catch {
+    return null;
+  }
+}
+function withTimeout(promise, ms) {
+  return new Promise((resolve, reject) => {
+    const timer = setTimeout(() => reject(new Error("timeout")), ms);
+    promise.then((val) => {
+      clearTimeout(timer);
+      resolve(val);
+    }).catch((err) => {
+      clearTimeout(timer);
+      reject(err);
+    });
+  });
+}
+
+export {
+  _resetMcpProvidersCache,
+  resolveRichPacket,
+  resolveRichPacketStreaming,
+  warmAllProviders,
+  enforcePerProviderBudget,
+  boostByMistakes,
+  _resetAvailabilityCache
+};