engramx 0.1.0

package/dist/chunk-WJUA4VZ7.js

@@ -0,0 +1,247 @@
+// src/hooks.ts
+import { existsSync, readFileSync, writeFileSync, chmodSync, unlinkSync } from "fs";
+import { join } from "path";
+var HOOK_START = "# engram-hook-start";
+var HOOK_END = "# engram-hook-end";
+var POST_COMMIT_SCRIPT = `
+${HOOK_START}
+# Auto-rebuild engram graph after commit (AST only, no LLM needed)
+ENGRAM_BIN=$(command -v engram 2>/dev/null)
+if [ -z "$ENGRAM_BIN" ]; then
+  ENGRAM_BIN=$(npm root -g 2>/dev/null)/engram/dist/cli.js
+fi
+
+if [ -d ".engram" ] && [ -f "$ENGRAM_BIN" ]; then
+  node "$ENGRAM_BIN" init . --quiet 2>/dev/null &
+fi
+${HOOK_END}
+`;
+var POST_CHECKOUT_SCRIPT = `
+${HOOK_START}
+# Auto-rebuild engram graph on branch switch
+PREV_HEAD=$1
+NEW_HEAD=$2
+BRANCH_SWITCH=$3
+
+if [ "$BRANCH_SWITCH" != "1" ]; then
+  exit 0
+fi
+
+ENGRAM_BIN=$(command -v engram 2>/dev/null)
+if [ -z "$ENGRAM_BIN" ]; then
+  ENGRAM_BIN=$(npm root -g 2>/dev/null)/engram/dist/cli.js
+fi
+
+if [ -d ".engram" ] && [ -f "$ENGRAM_BIN" ]; then
+  echo "[engram] Branch switched \u2014 rebuilding graph..."
+  node "$ENGRAM_BIN" init . --quiet 2>/dev/null &
+fi
+${HOOK_END}
+`;
+function findGitRoot(from) {
+  let current = from;
+  while (current !== "/") {
+    if (existsSync(join(current, ".git"))) return current;
+    current = join(current, "..");
+  }
+  return null;
+}
+function installHook(hooksDir, name, script) {
+  const hookPath = join(hooksDir, name);
+  if (existsSync(hookPath)) {
+    const content = readFileSync(hookPath, "utf-8");
+    if (content.includes(HOOK_START)) {
+      return `${name}: already installed`;
+    }
+    writeFileSync(hookPath, content.trimEnd() + "\n\n" + script);
+    return `${name}: appended to existing hook`;
+  }
+  writeFileSync(hookPath, "#!/bin/bash\n" + script);
+  chmodSync(hookPath, 493);
+  return `${name}: installed`;
+}
+function uninstallHook(hooksDir, name) {
+  const hookPath = join(hooksDir, name);
+  if (!existsSync(hookPath)) return `${name}: not installed`;
+  const content = readFileSync(hookPath, "utf-8");
+  if (!content.includes(HOOK_START)) return `${name}: engram hook not found`;
+  const cleaned = content.replace(new RegExp(`\\n?${HOOK_START}[\\s\\S]*?${HOOK_END}\\n?`, "g"), "").trim();
+  if (!cleaned || cleaned === "#!/bin/bash") {
+    unlinkSync(hookPath);
+    return `${name}: removed`;
+  }
+  writeFileSync(hookPath, cleaned + "\n");
+  return `${name}: engram section removed (other hooks preserved)`;
+}
+function install(projectRoot) {
+  const gitRoot = findGitRoot(projectRoot);
+  if (!gitRoot) return "Error: not a git repository";
+  const hooksDir = join(gitRoot, ".git", "hooks");
+  const results = [
+    installHook(hooksDir, "post-commit", POST_COMMIT_SCRIPT),
+    installHook(hooksDir, "post-checkout", POST_CHECKOUT_SCRIPT)
+  ];
+  return results.join("\n");
+}
+function uninstall(projectRoot) {
+  const gitRoot = findGitRoot(projectRoot);
+  if (!gitRoot) return "Error: not a git repository";
+  const hooksDir = join(gitRoot, ".git", "hooks");
+  const results = [
+    uninstallHook(hooksDir, "post-commit"),
+    uninstallHook(hooksDir, "post-checkout")
+  ];
+  return results.join("\n");
+}
+function status(projectRoot) {
+  const gitRoot = findGitRoot(projectRoot);
+  if (!gitRoot) return "Not a git repository";
+  const hooksDir = join(gitRoot, ".git", "hooks");
+  const check = (name) => {
+    const p = join(hooksDir, name);
+    if (!existsSync(p)) return "not installed";
+    return readFileSync(p, "utf-8").includes(HOOK_START) ? "installed" : "not installed";
+  };
+  return `post-commit: ${check("post-commit")}
+post-checkout: ${check("post-checkout")}`;
+}
+
+// src/autogen.ts
+import { existsSync as existsSync2, readFileSync as readFileSync2, writeFileSync as writeFileSync2 } from "fs";
+import { join as join2 } from "path";
+var AUTOGEN_START = "<!-- engram:start -->";
+var AUTOGEN_END = "<!-- engram:end -->";
+function generateSummary(store) {
+  const stats = store.getStats();
+  const gods = store.getGodNodes(8);
+  const allNodes = store.getAllNodes();
+  const allEdges = store.getAllEdges();
+  const filesByDir = /* @__PURE__ */ new Map();
+  for (const node of allNodes) {
+    if (node.kind === "file" && node.sourceFile) {
+      const dir = node.sourceFile.split("/").slice(0, -1).join("/") || ".";
+      if (!filesByDir.has(dir)) filesByDir.set(dir, []);
+      filesByDir.get(dir).push(node.label);
+    }
+  }
+  const kindCounts = /* @__PURE__ */ new Map();
+  for (const node of allNodes) {
+    kindCounts.set(node.kind, (kindCounts.get(node.kind) ?? 0) + 1);
+  }
+  const importEdges = allEdges.filter((e) => e.relation === "imports");
+  const mostImported = /* @__PURE__ */ new Map();
+  for (const edge of importEdges) {
+    mostImported.set(edge.target, (mostImported.get(edge.target) ?? 0) + 1);
+  }
+  const topImported = [...mostImported.entries()].sort((a, b) => b[1] - a[1]).slice(0, 5);
+  const lines = [
+    AUTOGEN_START,
+    "## Codebase Structure (auto-generated by engram)",
+    "",
+    `**Graph:** ${stats.nodes} nodes, ${stats.edges} edges | ${stats.extractedPct}% extracted, ${stats.inferredPct}% inferred`,
+    ""
+  ];
+  if (gods.length > 0) {
+    lines.push("**Core entities:**");
+    for (const g of gods) {
+      lines.push(`- \`${g.node.label}\` (${g.node.kind}, ${g.degree} connections) \u2014 ${g.node.sourceFile}`);
+    }
+    lines.push("");
+  }
+  if (filesByDir.size > 0) {
+    lines.push("**Structure:**");
+    for (const [dir, files] of [...filesByDir.entries()].sort()) {
+      lines.push(`- \`${dir}/\` \u2014 ${files.join(", ")}`);
+    }
+    lines.push("");
+  }
+  if (topImported.length > 0) {
+    lines.push("**Key dependencies (most imported):**");
+    for (const [target, count] of topImported) {
+      const node = store.getNode(target);
+      lines.push(`- \`${node?.label ?? target}\` (imported by ${count} files)`);
+    }
+    lines.push("");
+  }
+  const decisions = allNodes.filter((n) => n.kind === "decision");
+  const patterns = allNodes.filter((n) => n.kind === "pattern");
+  const mistakes = allNodes.filter((n) => n.kind === "mistake");
+  if (decisions.length > 0) {
+    lines.push("**Decisions:**");
+    for (const d of decisions.slice(0, 5)) {
+      lines.push(`- ${d.label}`);
+    }
+    lines.push("");
+  }
+  if (patterns.length > 0) {
+    lines.push("**Patterns:**");
+    for (const p of patterns.slice(0, 5)) {
+      lines.push(`- ${p.label}`);
+    }
+    lines.push("");
+  }
+  if (mistakes.length > 0) {
+    lines.push("**Known issues:**");
+    for (const m of mistakes.slice(0, 3)) {
+      lines.push(`- ${m.label}`);
+    }
+    lines.push("");
+  }
+  lines.push(
+    '**Tip:** Run `engram query "your question"` for structural context instead of reading files.',
+    AUTOGEN_END
+  );
+  return lines.join("\n");
+}
+function writeToFile(filePath, summary) {
+  let content = "";
+  if (existsSync2(filePath)) {
+    content = readFileSync2(filePath, "utf-8");
+  }
+  if (content.includes(AUTOGEN_START)) {
+    content = content.replace(
+      new RegExp(`${AUTOGEN_START}[\\s\\S]*?${AUTOGEN_END}`, "g"),
+      summary
+    );
+  } else {
+    content = content.trimEnd() + "\n\n" + summary + "\n";
+  }
+  writeFileSync2(filePath, content);
+}
+async function autogen(projectRoot, target) {
+  const { getStore } = await import("./core-M5N34VUU.js");
+  const store = await getStore(projectRoot);
+  try {
+    const summary = generateSummary(store);
+    const stats = store.getStats();
+    let targetFile;
+    if (target === "claude") {
+      targetFile = join2(projectRoot, "CLAUDE.md");
+    } else if (target === "cursor") {
+      targetFile = join2(projectRoot, ".cursorrules");
+    } else if (target === "agents") {
+      targetFile = join2(projectRoot, "AGENTS.md");
+    } else {
+      if (existsSync2(join2(projectRoot, "CLAUDE.md"))) {
+        targetFile = join2(projectRoot, "CLAUDE.md");
+      } else if (existsSync2(join2(projectRoot, ".cursorrules"))) {
+        targetFile = join2(projectRoot, ".cursorrules");
+      } else if (existsSync2(join2(projectRoot, "AGENTS.md"))) {
+        targetFile = join2(projectRoot, "AGENTS.md");
+      } else {
+        targetFile = join2(projectRoot, "CLAUDE.md");
+      }
+    }
+    writeToFile(targetFile, summary);
+    return { file: targetFile, nodesIncluded: stats.nodes };
+  } finally {
+    store.close();
+  }
+}
+
+export {
+  install,
+  uninstall,
+  status,
+  autogen
+};

package/dist/cli.js

@@ -0,0 +1,129 @@
+#!/usr/bin/env node
+import {
+  autogen,
+  install,
+  status,
+  uninstall
+} from "./chunk-WJUA4VZ7.js";
+import {
+  benchmark,
+  godNodes,
+  init,
+  learn,
+  path,
+  query,
+  stats
+} from "./chunk-44GN6IRQ.js";
+
+// src/cli.ts
+import { Command } from "commander";
+import chalk from "chalk";
+var program = new Command();
+program.name("engram").description("AI coding memory that learns from every session").version("0.1.0");
+program.command("init").description("Scan codebase and build knowledge graph (zero LLM cost)").argument("[path]", "Project directory", ".").action(async (projectPath) => {
+  console.log(chalk.dim("\u{1F50D} Scanning codebase..."));
+  const result = await init(projectPath);
+  console.log(
+    chalk.green("\u{1F333} AST extraction complete") + chalk.dim(` (${result.timeMs}ms, 0 tokens used)`)
+  );
+  console.log(
+    `   ${chalk.bold(String(result.nodes))} nodes, ${chalk.bold(String(result.edges))} edges from ${chalk.bold(String(result.fileCount))} files (${result.totalLines.toLocaleString()} lines)`
+  );
+  const bench = await benchmark(projectPath);
+  if (bench.naiveFullCorpus > 0 && bench.reductionVsRelevant > 1) {
+    console.log(
+      chalk.cyan(`
+\u{1F4CA} Token savings: ${chalk.bold(bench.reductionVsRelevant + "x")} fewer tokens vs relevant files (${bench.reductionVsFull}x vs full corpus)`)
+    );
+    console.log(
+      chalk.dim(`   Full corpus: ~${bench.naiveFullCorpus.toLocaleString()} tokens | Graph query: ~${bench.avgQueryTokens.toLocaleString()} tokens`)
+    );
+  }
+  console.log(chalk.green("\n\u2705 Ready. Your AI now has persistent memory."));
+  console.log(chalk.dim("   Graph stored in .engram/graph.db"));
+});
+program.command("query").description("Query the knowledge graph").argument("<question>", "Natural language question or keywords").option("--dfs", "Use DFS traversal", false).option("-d, --depth <n>", "Traversal depth", "3").option("-b, --budget <n>", "Token budget", "2000").option("-p, --project <path>", "Project directory", ".").action(async (question, opts) => {
+  const result = await query(opts.project, question, {
+    mode: opts.dfs ? "dfs" : "bfs",
+    depth: Number(opts.depth),
+    tokenBudget: Number(opts.budget)
+  });
+  if (result.nodesFound === 0) {
+    console.log(chalk.yellow("No matching nodes found."));
+    return;
+  }
+  console.log(chalk.dim(`Found ${result.nodesFound} nodes (~${result.estimatedTokens} tokens)
+`));
+  console.log(result.text);
+});
+program.command("path").description("Find shortest path between two concepts").argument("<source>", "Source concept").argument("<target>", "Target concept").option("-p, --project <path>", "Project directory", ".").action(async (source, target, opts) => {
+  const result = await path(opts.project, source, target);
+  console.log(result.text);
+});
+program.command("gods").description("Show most connected entities (god nodes)").option("-n, --top <n>", "Number of nodes", "10").option("-p, --project <path>", "Project directory", ".").action(async (opts) => {
+  const gods = await godNodes(opts.project, Number(opts.top));
+  if (gods.length === 0) {
+    console.log(chalk.yellow("No nodes found. Run `engram init` first."));
+    return;
+  }
+  console.log(chalk.bold("God nodes (most connected):\n"));
+  for (let i = 0; i < gods.length; i++) {
+    const g = gods[i];
+    console.log(
+      `  ${chalk.dim(String(i + 1) + ".")} ${chalk.bold(g.label)} ${chalk.dim(`[${g.kind}]`)} \u2014 ${g.degree} edges ${chalk.dim(g.sourceFile)}`
+    );
+  }
+});
+program.command("stats").description("Show knowledge graph statistics and token savings").option("-p, --project <path>", "Project directory", ".").action(async (opts) => {
+  const s = await stats(opts.project);
+  const bench = await benchmark(opts.project);
+  console.log(chalk.bold("\n\u{1F4CA} engram stats\n"));
+  console.log(`  Nodes:       ${chalk.bold(String(s.nodes))}`);
+  console.log(`  Edges:       ${chalk.bold(String(s.edges))}`);
+  console.log(
+    `  Confidence:  ${chalk.green(s.extractedPct + "% EXTRACTED")} \xB7 ${chalk.yellow(s.inferredPct + "% INFERRED")} \xB7 ${chalk.red(s.ambiguousPct + "% AMBIGUOUS")}`
+  );
+  if (s.lastMined > 0) {
+    const ago = Math.round((Date.now() - s.lastMined) / 6e4);
+    console.log(`  Last mined:  ${ago < 60 ? ago + "m ago" : Math.round(ago / 60) + "h ago"}`);
+  }
+  if (bench.naiveFullCorpus > 0) {
+    console.log(`
+  ${chalk.cyan("Token savings:")}`);
+    console.log(`    Full corpus:   ~${bench.naiveFullCorpus.toLocaleString()} tokens`);
+    console.log(`    Avg query:     ~${bench.avgQueryTokens.toLocaleString()} tokens`);
+    console.log(`    vs relevant:   ${chalk.bold.cyan(bench.reductionVsRelevant + "x")} fewer tokens`);
+    console.log(`    vs full:       ${chalk.bold.cyan(bench.reductionVsFull + "x")} fewer tokens`);
+  }
+  console.log();
+});
+program.command("learn").description("Teach engram a decision, pattern, or lesson").argument("<text>", "What to remember (e.g., 'We chose JWT over sessions for horizontal scaling')").option("-p, --project <path>", "Project directory", ".").action(async (text, opts) => {
+  const result = await learn(opts.project, text);
+  if (result.nodesAdded > 0) {
+    console.log(chalk.green(`\u{1F9E0} Learned ${result.nodesAdded} new insight(s).`));
+  } else {
+    console.log(chalk.yellow("No patterns extracted. Try a more specific statement."));
+  }
+});
+program.command("bench").description("Run token reduction benchmark").option("-p, --project <path>", "Project directory", ".").action(async (opts) => {
+  const result = await benchmark(opts.project);
+  console.log(chalk.bold("\n\u26A1 engram token reduction benchmark\n"));
+  console.log(`  Full corpus:     ~${result.naiveFullCorpus.toLocaleString()} tokens`);
+  console.log(`  Avg graph query: ~${result.avgQueryTokens.toLocaleString()} tokens`);
+  console.log(`  vs relevant:     ${chalk.bold.green(result.reductionVsRelevant + "x")} fewer tokens`);
+  console.log(`  vs full corpus:  ${chalk.bold.green(result.reductionVsFull + "x")} fewer tokens
+`);
+  for (const pq of result.perQuestion) {
+    console.log(`  ${chalk.dim(`[${pq.reductionRelevant}x relevant / ${pq.reductionFull}x full]`)} ${pq.question}`);
+  }
+  console.log();
+});
+var hooks = program.command("hooks").description("Manage git hooks");
+hooks.command("install").description("Install post-commit and post-checkout hooks").argument("[path]", "Project directory", ".").action((p) => console.log(install(p)));
+hooks.command("uninstall").description("Remove engram git hooks").argument("[path]", "Project directory", ".").action((p) => console.log(uninstall(p)));
+hooks.command("status").description("Check if hooks are installed").argument("[path]", "Project directory", ".").action((p) => console.log(status(p)));
+program.command("gen").description("Generate CLAUDE.md / .cursorrules section from graph").option("-p, --project <path>", "Project directory", ".").option("-t, --target <type>", "Target file: claude, cursor, agents").action(async (opts) => {
+  const result = await autogen(opts.project, opts.target);
+  console.log(chalk.green(`\u2705 Updated ${result.file} (${result.nodesIncluded} nodes)`));
+});
+program.parse();

package/dist/core-M5N34VUU.js

@@ -0,0 +1,22 @@
+import {
+  benchmark,
+  getDbPath,
+  getStore,
+  godNodes,
+  init,
+  learn,
+  path,
+  query,
+  stats
+} from "./chunk-44GN6IRQ.js";
+export {
+  benchmark,
+  getDbPath,
+  getStore,
+  godNodes,
+  init,
+  learn,
+  path,
+  query,
+  stats
+};

package/dist/index.js

@@ -0,0 +1,38 @@
+import {
+  autogen,
+  install,
+  uninstall
+} from "./chunk-WJUA4VZ7.js";
+import {
+  GraphStore,
+  SUPPORTED_EXTENSIONS,
+  benchmark,
+  extractDirectory,
+  extractFile,
+  godNodes,
+  init,
+  learn,
+  path,
+  query,
+  queryGraph,
+  shortestPath,
+  stats
+} from "./chunk-44GN6IRQ.js";
+export {
+  GraphStore,
+  SUPPORTED_EXTENSIONS,
+  autogen,
+  benchmark,
+  extractDirectory,
+  extractFile,
+  godNodes,
+  init,
+  install as installHooks,
+  learn,
+  path,
+  query,
+  queryGraph,
+  shortestPath,
+  stats,
+  uninstall as uninstallHooks
+};

package/dist/serve.js

@@ -0,0 +1,137 @@
+#!/usr/bin/env node
+import {
+  benchmark,
+  godNodes,
+  path,
+  query,
+  stats
+} from "./chunk-44GN6IRQ.js";
+
+// src/serve.ts
+var PROJECT_ROOT = process.argv[2] || process.cwd();
+var TOOLS = [
+  {
+    name: "query_graph",
+    description: "Search the knowledge graph using natural language. Returns relevant code structure as compact context.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        question: { type: "string", description: "Natural language question or keywords" },
+        mode: { type: "string", enum: ["bfs", "dfs"], default: "bfs" },
+        depth: { type: "integer", default: 3, description: "Traversal depth (1-6)" },
+        token_budget: { type: "integer", default: 2e3, description: "Max output tokens" }
+      },
+      required: ["question"]
+    }
+  },
+  {
+    name: "god_nodes",
+    description: "Return the most connected entities \u2014 the core abstractions of the codebase.",
+    inputSchema: { type: "object", properties: { top_n: { type: "integer", default: 10 } } }
+  },
+  {
+    name: "graph_stats",
+    description: "Return summary: node/edge counts, confidence breakdown, token savings.",
+    inputSchema: { type: "object", properties: {} }
+  },
+  {
+    name: "shortest_path",
+    description: "Find the shortest path between two concepts in the graph.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        source: { type: "string", description: "Source concept" },
+        target: { type: "string", description: "Target concept" }
+      },
+      required: ["source", "target"]
+    }
+  },
+  {
+    name: "benchmark",
+    description: "Compare token cost of graph queries vs reading raw files.",
+    inputSchema: { type: "object", properties: {} }
+  }
+];
+async function handleToolCall(name, args) {
+  switch (name) {
+    case "query_graph": {
+      const result = await query(PROJECT_ROOT, args.question, {
+        mode: args.mode ?? "bfs",
+        depth: args.depth ?? 3,
+        tokenBudget: args.token_budget ?? 2e3
+      });
+      return `${result.nodesFound} nodes found (~${result.estimatedTokens} tokens)
+
+${result.text}`;
+    }
+    case "god_nodes": {
+      const gods = await godNodes(PROJECT_ROOT, args.top_n ?? 10);
+      return gods.map((g, i) => `${i + 1}. ${g.label} [${g.kind}] \u2014 ${g.degree} edges (${g.sourceFile})`).join("\n");
+    }
+    case "graph_stats": {
+      const s = await stats(PROJECT_ROOT);
+      return `Nodes: ${s.nodes}
+Edges: ${s.edges}
+EXTRACTED: ${s.extractedPct}%
+INFERRED: ${s.inferredPct}%
+AMBIGUOUS: ${s.ambiguousPct}%`;
+    }
+    case "shortest_path": {
+      const result = await path(PROJECT_ROOT, args.source, args.target);
+      return result.text;
+    }
+    case "benchmark": {
+      const b = await benchmark(PROJECT_ROOT);
+      return [
+        `Full corpus: ~${b.naiveFullCorpus.toLocaleString()} tokens`,
+        `Avg graph query: ~${b.avgQueryTokens.toLocaleString()} tokens`,
+        `Reduction vs full corpus: ${b.reductionVsFull}x`,
+        `Reduction vs relevant files: ${b.reductionVsRelevant}x`,
+        "",
+        ...b.perQuestion.map((pq) => `[${pq.reductionFull}x full / ${pq.reductionRelevant}x relevant] ${pq.question}`)
+      ].join("\n");
+    }
+    default:
+      return `Unknown tool: ${name}`;
+  }
+}
+var buffer = "";
+process.stdin.setEncoding("utf-8");
+process.stdin.on("data", (chunk) => {
+  buffer += chunk;
+  const lines = buffer.split("\n");
+  buffer = lines.pop() ?? "";
+  for (const line of lines) {
+    if (!line.trim()) continue;
+    try {
+      const req = JSON.parse(line);
+      handleRequest(req).then((res) => {
+        process.stdout.write(JSON.stringify(res) + "\n");
+      });
+    } catch {
+    }
+  }
+});
+async function handleRequest(req) {
+  switch (req.method) {
+    case "initialize":
+      return {
+        jsonrpc: "2.0",
+        id: req.id,
+        result: {
+          protocolVersion: "2024-11-05",
+          capabilities: { tools: {} },
+          serverInfo: { name: "engram", version: "0.1.0" }
+        }
+      };
+    case "tools/list":
+      return { jsonrpc: "2.0", id: req.id, result: { tools: TOOLS } };
+    case "tools/call": {
+      const params = req.params;
+      const text = await handleToolCall(params.name, params.arguments ?? {});
+      return { jsonrpc: "2.0", id: req.id, result: { content: [{ type: "text", text }] } };
+    }
+    default:
+      return { jsonrpc: "2.0", id: req.id, error: { code: -32601, message: `Unknown method: ${req.method}` } };
+  }
+}

package/package.json

@@ -0,0 +1,52 @@
+{
+  "name": "engramx",
+  "version": "0.1.0",
+  "description": "AI coding memory that learns from every session — persistent, structural, universal",
+  "type": "module",
+  "bin": {
+    "engram": "dist/cli.js",
+    "engram-serve": "dist/serve.js"
+  },
+  "main": "./dist/index.js",
+  "scripts": {
+    "build": "tsup",
+    "dev": "tsup --watch",
+    "test": "vitest",
+    "lint": "tsc --noEmit",
+    "prepublishOnly": "npm run build"
+  },
+  "keywords": [
+    "ai",
+    "coding",
+    "memory",
+    "context",
+    "tree-sitter",
+    "knowledge-graph",
+    "mcp",
+    "claude",
+    "cursor",
+    "token-savings"
+  ],
+  "author": "Nicholas Ashkar",
+  "license": "Apache-2.0",
+  "engines": {
+    "node": ">=20"
+  },
+  "files": [
+    "dist",
+    "LICENSE",
+    "README.md"
+  ],
+  "dependencies": {
+    "chalk": "^5.6.2",
+    "commander": "^14.0.3",
+    "graphology": "^0.26.0",
+    "sql.js": "^1.14.1"
+  },
+  "devDependencies": {
+    "@types/node": "^25.5.2",
+    "tsup": "^8.5.1",
+    "typescript": "^6.0.2",
+    "vitest": "^4.1.4"
+  }
+}