engramx 0.5.3 → 1.0.1

package/dist/{core-UXIP2GDR.js → core-77MHT3QV.js}

@@ -11,7 +11,8 @@ import {
   path,
   query,
   stats
-} from "./chunk-IIFAAYDO.js";
+} from "./chunk-6SFMVYUN.js";
+import "./chunk-SBHGK5WA.js";
 export {
   benchmark,
   computeKeywordIDF,

package/dist/cursor-mdc-HWVUZUZH.js

@@ -0,0 +1,75 @@
+// src/generators/cursor-mdc.ts
+import { mkdirSync, writeFileSync } from "fs";
+import { join, dirname } from "path";
+var THIRTY_DAYS_MS = 30 * 24 * 60 * 60 * 1e3;
+function detectGlobs(fileNodes) {
+  const extCounts = /* @__PURE__ */ new Map();
+  for (const n of fileNodes) {
+    const match = n.sourceFile.match(/\.([^./]+)$/);
+    if (match) {
+      const ext = match[1];
+      extCounts.set(ext, (extCounts.get(ext) ?? 0) + 1);
+    }
+  }
+  const exts = [...extCounts.entries()].sort((a, b) => b[1] - a[1]).slice(0, 6).map(([ext]) => ext);
+  if (exts.length === 0) return ["src/**/*"];
+  return exts.map((ext) => `src/**/*.${ext}`);
+}
+function bullet(label) {
+  return `- ${label}`;
+}
+function buildFrontmatter(globs) {
+  const globList = globs.map((g) => `"${g}"`).join(", ");
+  return [
+    "---",
+    "description: engram-generated context spine \u2014 architecture, decisions, and known issues",
+    "alwaysApply: false",
+    `globs: [${globList}]`,
+    "---"
+  ].join("\n");
+}
+function buildSection(heading, bullets) {
+  if (bullets.length === 0) return "";
+  return [`## ${heading}`, "", ...bullets, ""].join("\n");
+}
+async function generateCursorMdc(projectPath) {
+  const { getStore } = await import("./core-77MHT3QV.js");
+  const store = await getStore(projectPath);
+  try {
+    const allNodes = store.getAllNodes();
+    const now = Date.now();
+    const cutoff = now - THIRTY_DAYS_MS;
+    const patternBullets = allNodes.filter(
+      (n) => n.kind === "pattern" && n.confidenceScore >= 0.8 && n.metadata.type !== "hot_file"
+    ).map((n) => bullet(n.label));
+    const decisionBullets = allNodes.filter((n) => n.kind === "decision" && n.lastVerified >= cutoff).sort((a, b) => b.lastVerified - a.lastVerified).map((n) => bullet(n.label));
+    const mistakeBullets = allNodes.filter((n) => n.kind === "mistake").sort((a, b) => b.queryCount - a.queryCount).slice(0, 5).map((n) => bullet(n.label));
+    const godNodes = store.getGodNodes(10);
+    const godBullets = godNodes.map(
+      ({ node, degree }) => `- \`${node.label}\` (${node.kind}, ${degree} connections) \u2014 ${node.sourceFile}`
+    );
+    const hotFileBullets = allNodes.filter(
+      (n) => n.kind === "pattern" && n.metadata.type === "hot_file"
+    ).map((n) => bullet(n.label));
+    const fileNodes = allNodes.filter((n) => n.kind === "file");
+    const globs = detectGlobs(fileNodes);
+    const sections = [
+      buildSection("Architecture Patterns", patternBullets),
+      buildSection("Active Decisions", decisionBullets),
+      buildSection("Known Landmines", mistakeBullets),
+      buildSection("Core Entities", godBullets),
+      buildSection("Hot Files", hotFileBullets)
+    ].filter((s) => s.length > 0);
+    const content = [buildFrontmatter(globs), "", ...sections].join("\n");
+    const outPath = join(projectPath, ".cursor", "rules", "engram-context.mdc");
+    mkdirSync(dirname(outPath), { recursive: true });
+    writeFileSync(outPath, content, "utf-8");
+    const nodeCount = patternBullets.length + decisionBullets.length + mistakeBullets.length + godBullets.length + hotFileBullets.length;
+    return { filePath: outPath, sections: sections.length, nodes: nodeCount };
+  } finally {
+    store.close();
+  }
+}
+export {
+  generateCursorMdc
+};

package/dist/exporter-A3VSLS4U.js

@@ -0,0 +1,47 @@
+// src/ccs/exporter.ts
+import { writeFileSync, mkdirSync } from "fs";
+import { join, dirname } from "path";
+var CCS_FILE = join(".context", "index.md");
+var HEADER = "# Project Context\n\n> Auto-generated by engram. See https://github.com/Agentic-Insights/codebase-context-spec\n";
+function bullet(label) {
+  return `- ${label}`;
+}
+function buildSection(heading, nodes) {
+  if (nodes.length === 0) return "";
+  const bullets = nodes.map((n) => bullet(n.label));
+  return [`## ${heading}`, "", ...bullets, ""].join("\n");
+}
+async function exportCcs(projectRoot) {
+  const { getStore } = await import("./core-77MHT3QV.js");
+  const store = await getStore(projectRoot);
+  try {
+    const allNodes = store.getAllNodes();
+    const patternNodes = allNodes.filter(
+      (n) => n.kind === "pattern" && n.confidenceScore >= 0.8 && n.metadata.type !== "hot_file"
+    ).sort((a, b) => b.queryCount - a.queryCount);
+    const decisionNodes = allNodes.filter((n) => n.kind === "decision").sort((a, b) => b.lastVerified - a.lastVerified);
+    const mistakeNodes = allNodes.filter((n) => n.kind === "mistake").sort((a, b) => b.queryCount - a.queryCount);
+    const conceptNodes = allNodes.filter((n) => n.kind === "concept" && n.queryCount > 0).sort((a, b) => b.queryCount - a.queryCount).slice(0, 10);
+    const sections = [
+      buildSection("Architecture Patterns", patternNodes),
+      buildSection("Decisions", decisionNodes),
+      buildSection("Known Issues", mistakeNodes),
+      buildSection("Key Concepts", conceptNodes)
+    ].filter((s) => s.length > 0);
+    const content = [HEADER, ...sections].join("\n");
+    const outPath = join(projectRoot, CCS_FILE);
+    mkdirSync(dirname(outPath), { recursive: true });
+    writeFileSync(outPath, content, "utf-8");
+    const nodesExported = patternNodes.length + decisionNodes.length + mistakeNodes.length + conceptNodes.length;
+    return {
+      filePath: outPath,
+      sectionsWritten: sections.length,
+      nodesExported
+    };
+  } finally {
+    store.close();
+  }
+}
+export {
+  exportCcs
+};

package/dist/importer-LU2YFZDY.js

@@ -0,0 +1,67 @@
+// src/ccs/importer.ts
+import { readFileSync, existsSync } from "fs";
+import { join } from "path";
+import { randomUUID } from "crypto";
+var CCS_SOURCE = "ccs:.context/index.md";
+var CCS_PATH = join(".context", "index.md");
+function headingToKind(heading) {
+  const lower = heading.toLowerCase();
+  if (lower.includes("decision")) return "decision";
+  if (lower.includes("issue") || lower.includes("problem") || lower.includes("known issue")) return "mistake";
+  if (lower.includes("architecture") || lower.includes("design") || lower.includes("convention") || lower.includes("pattern")) {
+    return "pattern";
+  }
+  return "concept";
+}
+function parseBullet(line) {
+  const trimmed = line.trimStart();
+  if (trimmed.startsWith("- ") || trimmed.startsWith("* ")) {
+    return trimmed.slice(2).trim();
+  }
+  return null;
+}
+async function importCcs(projectRoot) {
+  const filePath = join(projectRoot, CCS_PATH);
+  if (!existsSync(filePath)) {
+    return { nodesCreated: 0, sectionsFound: 0 };
+  }
+  const { getStore } = await import("./core-77MHT3QV.js");
+  const store = await getStore(projectRoot);
+  try {
+    const raw = readFileSync(filePath, "utf-8");
+    const lines = raw.replace(/\r\n/g, "\n").split("\n");
+    let sectionsFound = 0;
+    let nodesCreated = 0;
+    let currentKind = "concept";
+    for (const line of lines) {
+      const headingMatch = line.match(/^##\s+(.+)/);
+      if (headingMatch) {
+        currentKind = headingToKind(headingMatch[1]);
+        sectionsFound++;
+        continue;
+      }
+      const bulletText = parseBullet(line);
+      if (!bulletText) continue;
+      store.upsertNode({
+        id: randomUUID(),
+        label: bulletText,
+        kind: currentKind,
+        sourceFile: CCS_SOURCE,
+        sourceLocation: null,
+        confidence: "EXTRACTED",
+        confidenceScore: 0.9,
+        lastVerified: Date.now(),
+        queryCount: 0,
+        metadata: {}
+      });
+      nodesCreated++;
+    }
+    store.save();
+    return { nodesCreated, sectionsFound };
+  } finally {
+    store.close();
+  }
+}
+export {
+  importCcs
+};

package/dist/index.js

@@ -4,7 +4,7 @@ import {
   generateSummary,
   install,
   uninstall
-} from "./chunk-KEV4LNM6.js";
+} from "./chunk-QOG4K427.js";
 import {
   GraphStore,
   SUPPORTED_EXTENSIONS,
@@ -23,7 +23,8 @@ import {
   sliceGraphemeSafe,
   stats,
   truncateGraphemeSafe
-} from "./chunk-IIFAAYDO.js";
+} from "./chunk-6SFMVYUN.js";
+import "./chunk-SBHGK5WA.js";
 export {
   GraphStore,
   SUPPORTED_EXTENSIONS,

package/dist/migrate-5ZJWF2HD.js

@@ -0,0 +1,10 @@
+import {
+  CURRENT_SCHEMA_VERSION,
+  getSchemaVersion,
+  runMigrations
+} from "./chunk-SBHGK5WA.js";
+export {
+  CURRENT_SCHEMA_VERSION,
+  getSchemaVersion,
+  runMigrations
+};

package/dist/serve.js

@@ -8,7 +8,8 @@ import {
   query,
   stats,
   truncateGraphemeSafe
-} from "./chunk-IIFAAYDO.js";
+} from "./chunk-6SFMVYUN.js";
+import "./chunk-SBHGK5WA.js";
 
 // src/serve.ts
 function clampInt(value, defaultValue, min, max) {

package/dist/server-I3C74ZLB.js

@@ -0,0 +1,193 @@
+import {
+  learn,
+  query,
+  stats
+} from "./chunk-6SFMVYUN.js";
+import "./chunk-SBHGK5WA.js";
+
+// src/server/http.ts
+import { createServer } from "http";
+import { writeFileSync, unlinkSync, mkdirSync, existsSync } from "fs";
+import { join } from "path";
+import { createRequire } from "module";
+var require2 = createRequire(import.meta.url);
+var PKG_VERSION = (() => {
+  for (const p of ["../package.json", "../../package.json"]) {
+    try {
+      return require2(p).version;
+    } catch {
+    }
+  }
+  return "0.0.0";
+})();
+var PROVIDERS = [
+  "structure",
+  "mistakes",
+  "git",
+  "mempalace",
+  "context7",
+  "obsidian"
+];
+function parseUrl(req) {
+  return new URL(req.url ?? "/", `http://${req.headers.host ?? "localhost"}`);
+}
+async function readBody(req) {
+  const chunks = [];
+  for await (const chunk of req) chunks.push(chunk);
+  return Buffer.concat(chunks).toString("utf-8");
+}
+function json(res, status, data) {
+  res.writeHead(status, {
+    "Content-Type": "application/json",
+    "Access-Control-Allow-Origin": "*",
+    "Access-Control-Allow-Methods": "GET, POST, OPTIONS",
+    "Access-Control-Allow-Headers": "Authorization, Content-Type"
+  });
+  res.end(JSON.stringify(data));
+}
+function checkAuth(req, res) {
+  const token = process.env.ENGRAM_API_TOKEN;
+  if (!token) return true;
+  const header = req.headers.authorization ?? "";
+  if (header === `Bearer ${token}`) return true;
+  json(res, 401, { error: "Unauthorized" });
+  return false;
+}
+function handleHealth(_req, res, startedAt) {
+  json(res, 200, {
+    ok: true,
+    version: PKG_VERSION,
+    uptime: Math.floor((Date.now() - startedAt) / 1e3)
+  });
+}
+async function handleQuery(req, res, projectRoot) {
+  const url = parseUrl(req);
+  const q = url.searchParams.get("q");
+  if (!q) {
+    json(res, 400, { error: "Missing query parameter 'q'" });
+    return;
+  }
+  const budget = parseInt(url.searchParams.get("budget") ?? "2000", 10);
+  try {
+    const result = await query(projectRoot, q, { tokenBudget: isNaN(budget) ? 2e3 : budget });
+    json(res, 200, {
+      text: result.text,
+      estimatedTokens: result.estimatedTokens,
+      providers: [...PROVIDERS]
+    });
+  } catch (err) {
+    json(res, 500, { error: "Query failed", detail: String(err) });
+  }
+}
+async function handleStats(_req, res, projectRoot) {
+  try {
+    const result = await stats(projectRoot);
+    json(res, 200, result);
+  } catch (err) {
+    json(res, 500, { error: "Stats failed", detail: String(err) });
+  }
+}
+function handleProviders(_req, res) {
+  const list = PROVIDERS.map((name) => ({ name, available: true }));
+  json(res, 200, list);
+}
+async function handleLearn(req, res, projectRoot) {
+  let body;
+  try {
+    body = await readBody(req);
+  } catch {
+    json(res, 400, { error: "Failed to read request body" });
+    return;
+  }
+  let parsed;
+  try {
+    parsed = JSON.parse(body);
+  } catch {
+    json(res, 400, { error: "Invalid JSON body" });
+    return;
+  }
+  if (!parsed.content || typeof parsed.content !== "string") {
+    json(res, 400, { error: "Missing 'content' in request body" });
+    return;
+  }
+  try {
+    await learn(projectRoot, parsed.content, parsed.file ?? "http-api");
+    json(res, 201, { ok: true });
+  } catch (err) {
+    json(res, 500, { error: "Learn failed", detail: String(err) });
+  }
+}
+function writePid(projectRoot) {
+  const dir = join(projectRoot, ".engram");
+  if (!existsSync(dir)) mkdirSync(dir, { recursive: true });
+  writeFileSync(join(dir, "http-server.pid"), String(process.pid), "utf-8");
+}
+function removePid(projectRoot) {
+  try {
+    unlinkSync(join(projectRoot, ".engram", "http-server.pid"));
+  } catch {
+  }
+}
+function createHttpServer(projectRoot, port) {
+  return new Promise((resolve, reject) => {
+    const startedAt = Date.now();
+    const server = createServer(async (req, res) => {
+      if (req.method === "OPTIONS") {
+        res.writeHead(204, {
+          "Access-Control-Allow-Origin": "*",
+          "Access-Control-Allow-Methods": "GET, POST, OPTIONS",
+          "Access-Control-Allow-Headers": "Authorization, Content-Type"
+        });
+        res.end();
+        return;
+      }
+      if (!checkAuth(req, res)) return;
+      const url = parseUrl(req);
+      const path = url.pathname;
+      try {
+        if (req.method === "GET" && path === "/health") {
+          handleHealth(req, res, startedAt);
+        } else if (req.method === "GET" && path === "/query") {
+          await handleQuery(req, res, projectRoot);
+        } else if (req.method === "GET" && path === "/stats") {
+          await handleStats(req, res, projectRoot);
+        } else if (req.method === "GET" && path === "/providers") {
+          handleProviders(req, res);
+        } else if (req.method === "POST" && path === "/learn") {
+          await handleLearn(req, res, projectRoot);
+        } else {
+          json(res, 404, { error: "Not found" });
+        }
+      } catch (err) {
+        json(res, 500, { error: "Internal server error", detail: String(err) });
+      }
+    });
+    server.on("error", (err) => {
+      removePid(projectRoot);
+      reject(err);
+    });
+    server.listen(port, "127.0.0.1", () => {
+      writePid(projectRoot);
+      const cleanup = () => {
+        removePid(projectRoot);
+        server.close(() => process.exit(0));
+      };
+      process.on("SIGINT", cleanup);
+      process.on("SIGTERM", cleanup);
+      resolve();
+    });
+  });
+}
+
+// src/server/index.ts
+var DEFAULT_PORT = 7337;
+async function startHttpServer(projectRoot, port = DEFAULT_PORT) {
+  await createHttpServer(projectRoot, port);
+  process.stdout.write(
+    `engram HTTP server listening on http://127.0.0.1:${port}
+`
+  );
+}
+export {
+  startHttpServer
+};

package/dist/tuner-2LVIEE5V.js

@@ -0,0 +1,113 @@
+import {
+  readConfig,
+  readHookLog,
+  writeConfig
+} from "./chunk-CEAANHHX.js";
+
+// src/tuner/index.ts
+var MIN_CONFIDENCE_SAMPLES = 10;
+var CONFIDENCE_HYSTERESIS = 0.1;
+var ALWAYS_ON_MIN_EVENTS = 20;
+function analyzeTuning(projectRoot) {
+  const entries = readHookLog(projectRoot);
+  if (entries.length === 0) {
+    return { changes: [], entriesAnalyzed: 0, daysSpanned: 0 };
+  }
+  const config = readConfig(projectRoot);
+  const changes = [];
+  const deniedReads = entries.filter(
+    (e) => e.event === "PreToolUse" && e.decision === "deny"
+  );
+  const providerHits = /* @__PURE__ */ new Map();
+  const confidences = [];
+  for (const entry of deniedReads) {
+    const prov = entry.provider;
+    if (typeof prov === "string") {
+      providerHits.set(prov, (providerHits.get(prov) ?? 0) + 1);
+    }
+    if (typeof entry.confidence === "number") {
+      confidences.push(entry.confidence);
+    }
+  }
+  if (confidences.length >= MIN_CONFIDENCE_SAMPLES) {
+    const sorted = [...confidences].sort((a, b) => a - b);
+    const median = sorted[Math.floor(sorted.length / 2)];
+    if (median > config.confidenceThreshold + CONFIDENCE_HYSTERESIS) {
+      const proposed = Math.round(median * 100) / 100;
+      changes.push({
+        field: "confidenceThreshold",
+        current: config.confidenceThreshold,
+        proposed,
+        reason: `Median result confidence is ${median.toFixed(2)} \u2014 raising threshold reduces noise`
+      });
+    }
+  }
+  if (deniedReads.length >= ALWAYS_ON_MIN_EVENTS) {
+    const knownProviders = ["engram:structure", "engram:mistakes", "engram:git", "mempalace", "context7", "obsidian"];
+    for (const pName of knownProviders) {
+      const hits = providerHits.get(pName) ?? 0;
+      const override = config.providers[pName];
+      const alreadyDisabled = override?.enabled === false;
+      if (hits === 0 && !alreadyDisabled) {
+        changes.push({
+          field: `providers.${pName}.enabled`,
+          current: true,
+          proposed: false,
+          reason: `Provider "${pName}" has 0 hits across ${deniedReads.length} intercepted reads \u2014 disabling saves latency`
+        });
+      }
+    }
+  }
+  if (deniedReads.length >= ALWAYS_ON_MIN_EVENTS) {
+    for (const [pName, hits] of providerHits) {
+      const hitRate = hits / deniedReads.length;
+      if (hitRate >= 0.9) {
+        const currentBudget = config.providers[pName]?.tokenBudget ?? 200;
+        const proposed = Math.round(currentBudget * 1.2);
+        if (proposed !== currentBudget) {
+          changes.push({
+            field: `providers.${pName}.tokenBudget`,
+            current: currentBudget,
+            proposed,
+            reason: `Provider "${pName}" contributes on ${Math.round(hitRate * 100)}% of reads \u2014 increasing budget allows richer output`
+          });
+        }
+      }
+    }
+  }
+  const timestamps = entries.map((e) => e.ts).filter((ts) => typeof ts === "string").map((ts) => new Date(ts).getTime()).filter((t) => !isNaN(t));
+  const daysSpanned = timestamps.length >= 2 ? Math.ceil(
+    (Math.max(...timestamps) - Math.min(...timestamps)) / (24 * 3600 * 1e3)
+  ) : 0;
+  return { changes, entriesAnalyzed: entries.length, daysSpanned };
+}
+function applyTuning(projectRoot, proposal) {
+  const config = readConfig(projectRoot);
+  let updated = { ...config };
+  for (const change of proposal.changes) {
+    if (change.field === "confidenceThreshold") {
+      updated = { ...updated, confidenceThreshold: change.proposed };
+    } else if (change.field === "totalTokenBudget") {
+      updated = { ...updated, totalTokenBudget: change.proposed };
+    } else if (change.field.startsWith("providers.")) {
+      const parts = change.field.split(".");
+      const providerName = parts[1];
+      const key = parts[2];
+      if (providerName && key) {
+        const existing = updated.providers[providerName] ?? {};
+        updated = {
+          ...updated,
+          providers: {
+            ...updated.providers,
+            [providerName]: { ...existing, [key]: change.proposed }
+          }
+        };
+      }
+    }
+  }
+  writeConfig(projectRoot, updated);
+}
+export {
+  analyzeTuning,
+  applyTuning
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "engramx",
-  "version": "0.5.3",
+  "version": "1.0.1",
   "description": "The context spine for AI coding agents. 6 providers assembled into rich context packets per Read interception. Up to 90% session-level token savings. Local SQLite, zero native deps, zero cloud.",
   "repository": {
     "type": "git",
@@ -22,7 +22,9 @@
     "dev": "tsup --watch",
     "test": "vitest",
     "lint": "tsc --noEmit",
-    "prepublishOnly": "npm run build"
+    "prepublishOnly": "npm run build",
+    "bench": "tsx bench/runner.ts",
+    "stress": "tsx bench/stress-test.ts"
   },
   "keywords": [
     "structural-code-graph",
@@ -55,7 +57,13 @@
   "dependencies": {
     "chalk": "^5.6.2",
     "commander": "^14.0.3",
-"sql.js": "^1.14.1"
+    "sql.js": "^1.14.1",
+    "tree-sitter-go": "^0.25.0",
+    "tree-sitter-javascript": "^0.25.0",
+    "tree-sitter-python": "^0.25.0",
+    "tree-sitter-rust": "^0.24.0",
+    "tree-sitter-typescript": "^0.23.2",
+    "web-tree-sitter": "^0.26.8"
   },
   "devDependencies": {
     "@types/node": "^25.5.2",