@dreamtree-org/graphify 1.0.0 → 1.1.2

package/dist/cli/index.cjs

@@ -127,7 +127,36 @@ function validateUrl(url) {
   }
   return parsed.toString();
 }
-function validateGraphPath(path11, base) {
+function validateDsn(dsn) {
+  let parsed;
+  try {
+    parsed = new URL(dsn);
+  } catch {
+    throw new Error("Invalid DSN \u2014 expected mysql://user:pass@host:port/database");
+  }
+  if (parsed.protocol !== "mysql:") {
+    throw new Error(`DSN scheme not supported: "${parsed.protocol}" (only mysql: is supported)`);
+  }
+  const database = decodeURIComponent(parsed.pathname.replace(/^\//, ""));
+  if (!database || database.includes("/")) {
+    throw new Error("DSN must name exactly one database, e.g. mysql://localhost:3306/mydb");
+  }
+  if (!parsed.hostname) {
+    throw new Error("DSN must include a host, e.g. mysql://localhost:3306/mydb");
+  }
+  const port = parsed.port ? Number(parsed.port) : DEFAULT_MYSQL_PORT;
+  return {
+    safeDisplay: `mysql://${parsed.hostname}:${port}/${database}`,
+    connection: {
+      host: parsed.hostname,
+      port,
+      user: decodeURIComponent(parsed.username) || "root",
+      password: decodeURIComponent(parsed.password),
+      database
+    }
+  };
+}
+function validateGraphPath(path18, base) {
   const baseDir = base ?? nodePath.join(process.cwd(), "graphify-out");
   let resolvedBase;
   try {
@@ -135,7 +164,7 @@ function validateGraphPath(path11, base) {
   } catch {
     throw new Error(`Base directory does not exist: ${baseDir}`);
   }
-  const candidate = nodePath.isAbsolute(path11) ? path11 : nodePath.join(resolvedBase, path11);
+  const candidate = nodePath.isAbsolute(path18) ? path18 : nodePath.join(resolvedBase, path18);
   const resolvedCandidate = nodePath.resolve(candidate);
   let realCandidate = resolvedCandidate;
   try {
@@ -145,7 +174,7 @@ function validateGraphPath(path11, base) {
   const relative4 = nodePath.relative(resolvedBase, realCandidate);
   const escapes = relative4 === ".." || relative4.startsWith(`..${nodePath.sep}`) || nodePath.isAbsolute(relative4);
   if (escapes) {
-    throw new Error(`Path escapes graphify-out/: ${path11}`);
+    throw new Error(`Path escapes graphify-out/: ${path18}`);
   }
   return realCandidate;
 }
@@ -157,7 +186,7 @@ function sanitizeLabel(text) {
 function escapeHtml(text) {
   return text.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;").replace(/'/g, "&#39;");
 }
-var import_node_crypto2, dns, http, https, fs, net, nodePath, ALLOWED_SCHEMES, MAX_FETCH_BYTES, MAX_TEXT_BYTES, MAX_LABEL_LEN, BLOCKED_HOSTNAMES, BLOCKED_IPV4_CIDRS;
+var import_node_crypto2, dns, http, https, fs, net, nodePath, ALLOWED_SCHEMES, MAX_FETCH_BYTES, MAX_TEXT_BYTES, MAX_LABEL_LEN, BLOCKED_HOSTNAMES, BLOCKED_IPV4_CIDRS, DEFAULT_MYSQL_PORT;
 var init_security = __esm({
   "src/security.ts"() {
     "use strict";
@@ -213,6 +242,7 @@ var init_security = __esm({
       "255.255.255.255/32"
       // broadcast
     ];
+    DEFAULT_MYSQL_PORT = 3306;
   }
 });
 
@@ -236,8 +266,43 @@ var init_graphStore = __esm({
 });
 
 // src/query.ts
+function splitCamelCase(text) {
+  return text.replace(/([a-z0-9])([A-Z])/g, "$1 $2").replace(/([A-Z]+)([A-Z][a-z])/g, "$1 $2");
+}
 function tokenize(text) {
-  return text.toLowerCase().split(/[^a-z0-9_.]+/).filter((token) => token.length > 1 && !STOPWORDS.has(token));
+  return splitCamelCase(text).toLowerCase().split(/[^a-z0-9]+/).filter((token) => token.length > 1 && !STOPWORDS.has(token));
+}
+function subtokenize(text) {
+  return splitCamelCase(text).toLowerCase().split(/[^a-z0-9]+/).filter((token) => token.length > 1);
+}
+function osaDistance(a, b) {
+  let prev2 = [];
+  let prev = Array.from({ length: b.length + 1 }, (_, j) => j);
+  let curr = new Array(b.length + 1).fill(0);
+  for (let i = 1; i <= a.length; i++) {
+    curr[0] = i;
+    for (let j = 1; j <= b.length; j++) {
+      const substitution = a[i - 1] === b[j - 1] ? 0 : 1;
+      let best = Math.min(
+        prev[j] + 1,
+        curr[j - 1] + 1,
+        prev[j - 1] + substitution
+      );
+      if (i > 1 && j > 1 && a[i - 1] === b[j - 2] && a[i - 2] === b[j - 1]) {
+        best = Math.min(best, prev2[j - 2] + 1);
+      }
+      curr[j] = best;
+    }
+    [prev2, prev, curr] = [prev, curr, new Array(b.length + 1).fill(0)];
+  }
+  return prev[b.length];
+}
+function fuzzySimilarity(a, b) {
+  if (a === b) return 1;
+  const maxLen = Math.max(a.length, b.length);
+  if (maxLen === 0) return 1;
+  if (Math.abs(a.length - b.length) / maxLen > 1 - FUZZY_THRESHOLD) return 0;
+  return 1 - osaDistance(a, b) / maxLen;
 }
 function scoreNodes(graph, query) {
   const tokens = tokenize(query);
@@ -245,9 +310,25 @@ function scoreNodes(graph, query) {
   graph.forEachNode((id, attributes) => {
     const label = attributes.label ?? id;
     const haystack = `${label} ${id}`.toLowerCase();
+    const subtokens = new Set(subtokenize(`${label} ${id}`));
     let score = 0;
     for (const token of tokens) {
-      if (haystack.includes(token)) score += 1;
+      if (subtokens.has(token)) {
+        score += SUBTOKEN_MATCH_SCORE;
+        continue;
+      }
+      if (haystack.includes(token)) {
+        score += SUBSTRING_MATCH_SCORE;
+        continue;
+      }
+      if (token.length >= FUZZY_MIN_TOKEN_LEN) {
+        let best = 0;
+        for (const subtoken of subtokens) {
+          const similarity = fuzzySimilarity(token, subtoken);
+          if (similarity > best) best = similarity;
+        }
+        if (best >= FUZZY_THRESHOLD) score += best * FUZZY_MATCH_WEIGHT;
+      }
     }
     if (score > 0) matches.push({ id, label, score });
   });
@@ -258,22 +339,34 @@ function resolveNode(graph, query) {
   const matches = scoreNodes(graph, query);
   return matches[0] ?? null;
 }
+function nodeTokenCost(graph, id) {
+  const attrs = graph.getNodeAttributes(id);
+  const label = attrs.label ?? id;
+  const sourceFile = attrs.sourceFile ?? "";
+  return Math.ceil((id.length * 2 + label.length + sourceFile.length + 24) / 4);
+}
 function queryGraph(graph, question, options = {}) {
   const maxDepth = options.maxDepth ?? DEFAULT_MAX_DEPTH;
   const maxSeeds = options.maxSeeds ?? DEFAULT_MAX_SEEDS;
-  const budget = options.budget ?? DEFAULT_BUDGET;
+  const tokenBudget = options.tokenBudget ?? DEFAULT_TOKEN_BUDGET;
+  const budget = options.budget ?? Math.max(DEFAULT_BUDGET, Math.ceil(tokenBudget * NODES_PER_TOKEN));
   const allMatches = scoreNodes(graph, question);
   const seeds = allMatches.length > 0 ? allMatches.slice(0, maxSeeds) : [];
   const visited = /* @__PURE__ */ new Map();
   const frontier = seeds.map((s) => ({ id: s.id, depth: 0 }));
-  for (const seed of seeds) visited.set(seed.id, 0);
-  while (frontier.length > 0 && visited.size < budget) {
+  let spentTokens = 0;
+  for (const seed of seeds) {
+    visited.set(seed.id, 0);
+    spentTokens += nodeTokenCost(graph, seed.id);
+  }
+  while (frontier.length > 0 && visited.size < budget && spentTokens < tokenBudget) {
     const current = options.dfs ? frontier.pop() : frontier.shift();
     if (current.depth >= maxDepth) continue;
     const neighbors = [...graph.neighbors(current.id)].sort((a, b) => a.localeCompare(b));
     for (const neighbor of neighbors) {
-      if (visited.has(neighbor) || visited.size >= budget) continue;
+      if (visited.has(neighbor) || visited.size >= budget || spentTokens >= tokenBudget) continue;
       visited.set(neighbor, current.depth + 1);
+      spentTokens += nodeTokenCost(graph, neighbor);
       frontier.push({ id: neighbor, depth: current.depth + 1 });
     }
   }
@@ -301,7 +394,30 @@ function queryGraph(graph, question, options = {}) {
   edges.sort(
     (a, b) => a.source.localeCompare(b.source) || a.target.localeCompare(b.target) || a.relation.localeCompare(b.relation)
   );
-  return { seeds, visited: visitedNodes, edges };
+  return enforceTokenBudget({ seeds, visited: visitedNodes, edges }, tokenBudget);
+}
+function enforceTokenBudget(result, tokenBudget) {
+  const cost = (value) => Math.ceil(JSON.stringify(value).length / 4);
+  const visited = [...result.visited];
+  let edges = [...result.edges];
+  let total = cost(result.seeds) + visited.reduce((s, n) => s + cost(n), 0) + edges.reduce((s, e) => s + cost(e), 0);
+  const seedIds = new Set(result.seeds.map((s) => s.id));
+  while (total > tokenBudget && visited.length > 0) {
+    const last = visited[visited.length - 1];
+    if (seedIds.has(last.id)) break;
+    visited.pop();
+    total -= cost(last);
+    const remaining = [];
+    for (const edge of edges) {
+      if (edge.source === last.id || edge.target === last.id) {
+        total -= cost(edge);
+      } else {
+        remaining.push(edge);
+      }
+    }
+    edges = remaining;
+  }
+  return { seeds: result.seeds, visited, edges };
 }
 function shortestPath(graph, fromQuery, toQuery) {
   const from = resolveNode(graph, fromQuery);
@@ -327,25 +443,25 @@ function shortestPath(graph, fromQuery, toQuery) {
   if (!visited.has(to.id)) {
     return { from, to, found: false, path: [], edges: [] };
   }
-  const path11 = [to.id];
+  const path18 = [to.id];
   let cursor = to.id;
   while (cursor !== from.id) {
     const prev = predecessor.get(cursor);
     if (!prev) break;
-    path11.unshift(prev);
+    path18.unshift(prev);
     cursor = prev;
   }
   const edges = [];
-  for (let i = 0; i < path11.length - 1; i++) {
-    const a = path11[i];
-    const b = path11[i + 1];
+  for (let i = 0; i < path18.length - 1; i++) {
+    const a = path18[i];
+    const b = path18[i + 1];
     const key = graph.edges(a, b)[0] ?? graph.edges(b, a)[0];
     if (key) {
       const attrs = graph.getEdgeAttributes(key);
       edges.push({ source: a, target: b, relation: String(attrs.relation), confidence: String(attrs.confidence) });
     }
   }
-  return { from, to, found: true, path: path11, edges };
+  return { from, to, found: true, path: path18, edges };
 }
 function explainNode(graph, query) {
   const match = resolveNode(graph, query);
@@ -371,7 +487,7 @@ function explainNode(graph, query) {
     incoming
   };
 }
-var STOPWORDS, DEFAULT_MAX_DEPTH, DEFAULT_MAX_SEEDS, DEFAULT_BUDGET;
+var STOPWORDS, FUZZY_MIN_TOKEN_LEN, FUZZY_THRESHOLD, SUBTOKEN_MATCH_SCORE, SUBSTRING_MATCH_SCORE, FUZZY_MATCH_WEIGHT, DEFAULT_MAX_DEPTH, DEFAULT_MAX_SEEDS, DEFAULT_BUDGET, DEFAULT_TOKEN_BUDGET, NODES_PER_TOKEN;
 var init_query = __esm({
   "src/query.ts"() {
     "use strict";
@@ -407,9 +523,300 @@ var init_query = __esm({
       "does",
       "that's"
     ]);
+    FUZZY_MIN_TOKEN_LEN = 3;
+    FUZZY_THRESHOLD = 0.7;
+    SUBTOKEN_MATCH_SCORE = 1;
+    SUBSTRING_MATCH_SCORE = 0.6;
+    FUZZY_MATCH_WEIGHT = 0.5;
     DEFAULT_MAX_DEPTH = 2;
     DEFAULT_MAX_SEEDS = 5;
     DEFAULT_BUDGET = 40;
+    DEFAULT_TOKEN_BUDGET = 2e3;
+    NODES_PER_TOKEN = 1 / 10;
+  }
+});
+
+// src/impact.ts
+function affectedBy(graph, nodeQuery, options = {}) {
+  const target = resolveNode(graph, nodeQuery);
+  if (!target) return null;
+  const maxDepth = options.maxDepth ?? DEFAULT_IMPACT_DEPTH;
+  const limit = options.limit ?? DEFAULT_IMPACT_LIMIT;
+  const affected = [];
+  const visited = /* @__PURE__ */ new Set([target.id]);
+  let frontier = [target.id];
+  let truncated = false;
+  for (let depth = 1; depth <= maxDepth && frontier.length > 0 && !truncated; depth++) {
+    const nextFrontier = /* @__PURE__ */ new Map();
+    for (const current of [...frontier].sort((a, b) => a.localeCompare(b))) {
+      graph.forEachInEdge(current, (_edge, edgeAttrs, source) => {
+        if (visited.has(source)) return;
+        const relation = edgeAttrs.relation;
+        if (!DEPENDENCY_RELATIONS.has(relation)) return;
+        const confidence = edgeAttrs.confidence;
+        const existing = nextFrontier.get(source);
+        if (existing && CONFIDENCE_RANK2[existing.via.confidence] >= CONFIDENCE_RANK2[confidence]) return;
+        const attrs = graph.getNodeAttributes(source);
+        nextFrontier.set(source, {
+          id: source,
+          label: attrs.label ?? source,
+          sourceFile: attrs.sourceFile ?? "",
+          sourceLocation: attrs.sourceLocation ?? "",
+          depth,
+          via: { relation, confidence, dependsOn: current }
+        });
+      });
+    }
+    const roundNodes = [...nextFrontier.values()].sort((a, b) => a.id.localeCompare(b.id));
+    for (const node of roundNodes) {
+      if (affected.length >= limit) {
+        truncated = true;
+        break;
+      }
+      visited.add(node.id);
+      affected.push(node);
+    }
+    frontier = roundNodes.filter((n) => visited.has(n.id)).map((n) => n.id);
+  }
+  const byConfidence = { EXTRACTED: 0, INFERRED: 0, AMBIGUOUS: 0 };
+  for (const node of affected) byConfidence[node.via.confidence] += 1;
+  return { target, affected, byConfidence, maxDepth, truncated };
+}
+var DEPENDENCY_RELATIONS, DEFAULT_IMPACT_DEPTH, DEFAULT_IMPACT_LIMIT, CONFIDENCE_RANK2;
+var init_impact = __esm({
+  "src/impact.ts"() {
+    "use strict";
+    init_cjs_shims();
+    init_query();
+    DEPENDENCY_RELATIONS = /* @__PURE__ */ new Set([
+      "calls",
+      "imports",
+      "imports_from",
+      "inherits",
+      "implements",
+      "mixes_in",
+      "embeds",
+      "references",
+      "re_exports",
+      "method",
+      "contains"
+    ]);
+    DEFAULT_IMPACT_DEPTH = 3;
+    DEFAULT_IMPACT_LIMIT = 200;
+    CONFIDENCE_RANK2 = { EXTRACTED: 3, INFERRED: 2, AMBIGUOUS: 1 };
+  }
+});
+
+// src/testmap.ts
+function isTestFile(path18) {
+  return TEST_FILE_PATTERNS.some((p) => p.test(path18));
+}
+function selectionFromImpact(graph, targetIds, targetLabel) {
+  const best = /* @__PURE__ */ new Map();
+  let affectedNodeCount = 0;
+  for (const id of targetIds) {
+    const impact = affectedBy(graph, id, { maxDepth: TEST_REACH_DEPTH, limit: TEST_REACH_LIMIT });
+    if (!impact) continue;
+    affectedNodeCount += impact.affected.length;
+    for (const node of impact.affected) {
+      if (!isTestFile(node.sourceFile)) continue;
+      const existing = best.get(node.sourceFile);
+      if (!existing || node.depth < existing.depth) {
+        best.set(node.sourceFile, { depth: node.depth, via: node.via.dependsOn });
+      }
+    }
+  }
+  const testFiles = [...best.entries()].map(([file, info]) => ({ file, depth: info.depth, via: info.via })).sort((a, b) => a.depth - b.depth || a.file.localeCompare(b.file));
+  return { target: targetLabel, testFiles, affectedNodeCount };
+}
+function testsForNode(graph, nodeQuery) {
+  const match = resolveNode(graph, nodeQuery);
+  if (!match) return null;
+  return selectionFromImpact(graph, [match.id], match.id);
+}
+function testsForChangedFiles(graph, changedFiles) {
+  const fileIds = [];
+  const selfSelected = /* @__PURE__ */ new Map();
+  for (const file of changedFiles) {
+    if (isTestFile(file)) {
+      selfSelected.set(file, { depth: 0, via: "(changed directly)" });
+      continue;
+    }
+    if (graph.hasNode(file)) fileIds.push(file);
+  }
+  const selection = selectionFromImpact(graph, fileIds, changedFiles.join(", "));
+  for (const [file, info] of selfSelected) {
+    if (!selection.testFiles.some((t) => t.file === file)) {
+      selection.testFiles.push({ file, depth: info.depth, via: info.via });
+    }
+  }
+  selection.testFiles.sort((a, b) => a.depth - b.depth || a.file.localeCompare(b.file));
+  return selection;
+}
+var TEST_FILE_PATTERNS, TEST_REACH_DEPTH, TEST_REACH_LIMIT;
+var init_testmap = __esm({
+  "src/testmap.ts"() {
+    "use strict";
+    init_cjs_shims();
+    init_impact();
+    init_query();
+    TEST_FILE_PATTERNS = [
+      /(^|\/)tests?\//,
+      // tests/ or test/ directory
+      /(^|\/)__tests__\//,
+      /(^|\/)spec\//,
+      /\.test\.[cm]?[jt]sx?$/,
+      /\.spec\.[cm]?[jt]sx?$/,
+      /(^|\/)test_[^/]+\.py$/,
+      /_test\.py$/,
+      /_test\.go$/,
+      /Tests?\.(java|cs)$/,
+      /_spec\.rb$/,
+      /_test\.rb$/
+    ];
+    TEST_REACH_DEPTH = 4;
+    TEST_REACH_LIMIT = 2e3;
+  }
+});
+
+// src/context.ts
+function lineNumberOf(sourceLocation) {
+  const match = /^L(\d+)$/.exec(sourceLocation);
+  return match ? Number(match[1]) : null;
+}
+function isReadableFile(sourceFile) {
+  return sourceFile !== "" && !sourceFile.startsWith("<") && !sourceFile.includes("://");
+}
+function rankForTask(graph, task, maxSeeds = DEFAULT_MAX_SEEDS2) {
+  const seeds = scoreNodes(graph, task).slice(0, maxSeeds);
+  const ranked = /* @__PURE__ */ new Map();
+  for (const seed of seeds) {
+    ranked.set(seed.id, { id: seed.id, score: seed.score, reason: "matches the task" });
+  }
+  for (const seed of seeds) {
+    graph.forEachEdge(seed.id, (_edge, attrs, source, target) => {
+      const neighbor = source === seed.id ? target : source;
+      if (ranked.has(neighbor)) return;
+      const relation = String(attrs.relation);
+      const direction = source === seed.id ? `${relation} ->` : `<- ${relation}`;
+      ranked.set(neighbor, {
+        id: neighbor,
+        score: seed.score * NEIGHBOR_DECAY,
+        reason: `${direction} ${seed.label}`
+      });
+    });
+  }
+  return [...ranked.values()].sort((a, b) => b.score - a.score || a.id.localeCompare(b.id));
+}
+function snippetRange(startLine, fileLineCount, entityStartsInFile, maxLines) {
+  const nextStart = entityStartsInFile.find((l) => l > startLine);
+  const hardEnd = nextStart !== void 0 ? nextStart - 1 : fileLineCount;
+  return { start: startLine, end: Math.min(hardEnd, startLine + maxLines - 1) };
+}
+async function buildContextPack(graph, task, readFile21, options = {}) {
+  const tokenBudget = options.tokenBudget ?? DEFAULT_CONTEXT_BUDGET;
+  const maxSnippetLines = options.maxSnippetLines ?? DEFAULT_MAX_SNIPPET_LINES;
+  const ranked = rankForTask(graph, task, options.maxSeeds);
+  const entityStarts = /* @__PURE__ */ new Map();
+  graph.forEachNode((_id, attrs) => {
+    const file = attrs.sourceFile;
+    const line = lineNumberOf(attrs.sourceLocation ?? "");
+    if (file && line !== null) {
+      const starts = entityStarts.get(file) ?? [];
+      starts.push(line);
+      entityStarts.set(file, starts);
+    }
+  });
+  for (const starts of entityStarts.values()) starts.sort((a, b) => a - b);
+  const fileCache = /* @__PURE__ */ new Map();
+  const readLines = async (file) => {
+    const cached = fileCache.get(file);
+    if (cached !== void 0) return cached;
+    let lines;
+    try {
+      lines = (await readFile21(file)).split("\n");
+    } catch {
+      lines = null;
+    }
+    fileCache.set(file, lines);
+    return lines;
+  };
+  const snippets = [];
+  const overflow = [];
+  const coveredRanges = /* @__PURE__ */ new Map();
+  let tokens = 0;
+  for (const node of ranked) {
+    const attrs = graph.getNodeAttributes(node.id);
+    const file = attrs.sourceFile ?? "";
+    const startLine = lineNumberOf(attrs.sourceLocation ?? "");
+    if (!isReadableFile(file) || startLine === null) continue;
+    const lines = await readLines(file);
+    if (lines === null) continue;
+    const { start, end } = snippetRange(startLine, lines.length, entityStarts.get(file) ?? [], maxSnippetLines);
+    const covered = (coveredRanges.get(file) ?? []).some((r) => start >= r.start && end <= r.end);
+    if (covered) continue;
+    const code = lines.slice(start - 1, end).join("\n");
+    const cost = tokensOf2(code) + 15;
+    if (tokens + cost > tokenBudget) {
+      overflow.push({ nodeId: node.id, file: `${file}:L${startLine}` });
+      continue;
+    }
+    tokens += cost;
+    snippets.push({
+      nodeId: node.id,
+      label: attrs.label ?? node.id,
+      file,
+      startLine: start,
+      endLine: end,
+      code,
+      reason: node.reason,
+      score: node.score
+    });
+    const ranges = coveredRanges.get(file) ?? [];
+    ranges.push({ start, end });
+    coveredRanges.set(file, ranges);
+  }
+  return { task, snippets, tokens, tokenBudget, overflow };
+}
+function renderContextPack(pack) {
+  const lines = [
+    `# Context pack: ${pack.task}`,
+    "",
+    `_~${pack.tokens} of ${pack.tokenBudget} token budget, ${pack.snippets.length} snippet(s)._`,
+    ""
+  ];
+  if (pack.snippets.length === 0) {
+    lines.push("No matching code found \u2014 try different keywords.");
+    return lines.join("\n");
+  }
+  for (const snippet of pack.snippets) {
+    lines.push(`## ${snippet.label} \u2014 \`${snippet.file}:L${snippet.startLine}-L${snippet.endLine}\``);
+    lines.push(`_${snippet.reason}_`);
+    lines.push("```");
+    lines.push(snippet.code);
+    lines.push("```");
+    lines.push("");
+  }
+  if (pack.overflow.length > 0) {
+    lines.push(`## Didn't fit the budget (${pack.overflow.length})`);
+    for (const item of pack.overflow.slice(0, 15)) {
+      lines.push(`- ${item.nodeId} (${item.file})`);
+    }
+    lines.push("");
+  }
+  return lines.join("\n");
+}
+var DEFAULT_CONTEXT_BUDGET, DEFAULT_MAX_SEEDS2, DEFAULT_MAX_SNIPPET_LINES, NEIGHBOR_DECAY, tokensOf2;
+var init_context = __esm({
+  "src/context.ts"() {
+    "use strict";
+    init_cjs_shims();
+    init_query();
+    DEFAULT_CONTEXT_BUDGET = 4e3;
+    DEFAULT_MAX_SEEDS2 = 8;
+    DEFAULT_MAX_SNIPPET_LINES = 60;
+    NEIGHBOR_DECAY = 0.4;
+    tokensOf2 = (text) => Math.ceil(text.length / 4);
   }
 });
 
@@ -432,12 +839,13 @@ function createGraphifyMcpServer(outDir) {
       inputSchema: {
         question: import_zod2.z.string().describe("Natural-language question or keywords to search the graph for."),
         dfs: import_zod2.z.boolean().optional().describe("Use depth-first traversal instead of the default breadth-first."),
-        budget: import_zod2.z.number().int().positive().optional().describe("Approximate cap on how many nodes to include.")
+        budget: import_zod2.z.number().int().positive().optional().describe("Hard cap on how many nodes to include."),
+        tokenBudget: import_zod2.z.number().int().positive().optional().describe("Approximate cap, in tokens, on the serialized size of the result (default 2000).")
       }
     },
-    async ({ question, dfs, budget }) => {
+    async ({ question, dfs, budget, tokenBudget }) => {
       const graph = await loadGraph(outDir);
-      const result = queryGraph(graph, question, { dfs, budget });
+      const result = queryGraph(graph, question, { dfs, budget, tokenBudget });
       return textResult(JSON.stringify(result, null, 2));
     }
   );
@@ -476,41 +884,257 @@ function createGraphifyMcpServer(outDir) {
       return textResult(JSON.stringify(result, null, 2));
     }
   );
+  server.registerTool(
+    "affected",
+    {
+      description: 'Reverse impact analysis \u2014 "what breaks if I change X". Walks incoming dependency edges (calls/imports/inherits/...) transitively and returns everything that depends on the node, grouped by depth, with per-confidence blast-radius counts.',
+      inputSchema: {
+        node: import_zod2.z.string().describe("Name/label (or id) of the node being changed."),
+        depth: import_zod2.z.number().int().positive().optional().describe("How many reverse hops to follow (default 3)."),
+        limit: import_zod2.z.number().int().positive().optional().describe("Cap on affected nodes reported (default 200).")
+      }
+    },
+    async ({ node, depth, limit }) => {
+      const graph = await loadGraph(outDir);
+      const result = affectedBy(graph, node, { maxDepth: depth, limit });
+      if (!result) {
+        return textResult(`No node matched "${node}".`);
+      }
+      return textResult(JSON.stringify(result, null, 2));
+    }
+  );
+  server.registerTool(
+    "context",
+    {
+      description: "Token-budgeted working-set pack: the actual code snippets relevant to a task, graph-ranked and packed to a budget. Call this FIRST when starting a task \u2014 it replaces query-then-read-whole-files.",
+      inputSchema: {
+        task: import_zod2.z.string().describe("What you are about to do, in natural language."),
+        budget: import_zod2.z.number().int().positive().optional().describe("Approximate token cap (default 4000).")
+      }
+    },
+    async ({ task, budget }) => {
+      const graph = await loadGraph(outDir);
+      const pack = await buildContextPack(graph, task, (p) => fs23.readFile(p, "utf-8"), {
+        tokenBudget: budget
+      });
+      return textResult(renderContextPack(pack));
+    }
+  );
+  server.registerTool(
+    "tests",
+    {
+      description: "Structural test selection: the minimal test files worth running to verify a change to the given node, via reverse dependency reachability \u2014 no coverage instrumentation.",
+      inputSchema: {
+        node: import_zod2.z.string().describe("Name/label (or id) of the changed node.")
+      }
+    },
+    async ({ node }) => {
+      const graph = await loadGraph(outDir);
+      const result = testsForNode(graph, node);
+      if (!result) {
+        return textResult(`No node matched "${node}".`);
+      }
+      return textResult(JSON.stringify(result, null, 2));
+    }
+  );
   return server;
 }
 async function startServer(graphPath, transport = new import_stdio.StdioServerTransport()) {
-  const outDir = path9.dirname(path9.resolve(graphPath));
-  const fileName = path9.basename(graphPath);
+  const outDir = path16.dirname(path16.resolve(graphPath));
+  const fileName = path16.basename(graphPath);
   validateGraphPath(fileName, outDir);
   const server = createGraphifyMcpServer(outDir);
   await server.connect(transport);
 }
 async function main(argv = process.argv) {
-  const graphPath = argv[2] ?? path9.join(process.cwd(), "graphify-out", "graph.json");
+  const graphPath = argv[2] ?? path16.join(process.cwd(), "graphify-out", "graph.json");
   await startServer(graphPath);
 }
-var path9, import_mcp, import_stdio, import_zod2;
+var fs23, path16, import_mcp, import_stdio, import_zod2;
 var init_server = __esm({
   "src/mcp/server.ts"() {
     "use strict";
     init_cjs_shims();
-    path9 = __toESM(require("path"), 1);
+    fs23 = __toESM(require("fs/promises"), 1);
+    path16 = __toESM(require("path"), 1);
     import_mcp = require("@modelcontextprotocol/sdk/server/mcp.js");
     import_stdio = require("@modelcontextprotocol/sdk/server/stdio.js");
     import_zod2 = require("zod");
+    init_context();
     init_graphStore();
+    init_impact();
     init_query();
+    init_testmap();
+    init_security();
+  }
+});
+
+// src/extractors/mysql.ts
+var mysql_exports = {};
+__export(mysql_exports, {
+  extractMysql: () => extractMysql
+});
+async function defaultQueryFn(dsn) {
+  const { connection } = validateDsn(dsn);
+  const mysql = await import("mysql2/promise");
+  const conn = await mysql.createConnection({
+    host: connection.host,
+    port: connection.port,
+    user: connection.user,
+    password: connection.password,
+    database: connection.database
+  });
+  return {
+    query: async (sql, params) => {
+      const [rows] = await conn.execute(sql, [...params]);
+      return rows;
+    },
+    close: () => conn.end()
+  };
+}
+async function extractMysql(dsn, queryFn) {
+  const { safeDisplay, connection } = validateDsn(dsn);
+  const schema = connection.database;
+  let query = queryFn;
+  let close;
+  if (!query) {
+    const live = await defaultQueryFn(dsn);
+    query = live.query;
+    close = live.close;
+  }
+  try {
+    const nodes = [];
+    const edges = [];
+    nodes.push({ id: schemaId(schema), label: schema, sourceFile: safeDisplay, sourceLocation: schema });
+    const tableRows = await query(
+      "SELECT TABLE_NAME, TABLE_TYPE FROM information_schema.TABLES WHERE TABLE_SCHEMA = ? ORDER BY TABLE_NAME",
+      [schema]
+    );
+    const tables = tableRows.map((row) => ({
+      name: String(row.TABLE_NAME),
+      isView: String(row.TABLE_TYPE).toUpperCase() === "VIEW"
+    }));
+    const tableNames = new Set(tables.map((t) => t.name));
+    for (const table of tables) {
+      nodes.push({
+        id: tableId(schema, table.name),
+        label: `${table.isView ? "view" : "table"} ${table.name}`,
+        sourceFile: safeDisplay,
+        sourceLocation: table.name
+      });
+      edges.push({
+        source: schemaId(schema),
+        target: tableId(schema, table.name),
+        relation: "contains",
+        confidence: "EXTRACTED"
+      });
+    }
+    const columnRows = await query(
+      "SELECT TABLE_NAME, COLUMN_NAME, COLUMN_TYPE FROM information_schema.COLUMNS WHERE TABLE_SCHEMA = ? ORDER BY TABLE_NAME, ORDINAL_POSITION",
+      [schema]
+    );
+    for (const row of columnRows) {
+      const table = String(row.TABLE_NAME);
+      const column = String(row.COLUMN_NAME);
+      if (!tableNames.has(table)) continue;
+      nodes.push({
+        id: columnId(schema, table, column),
+        label: `${table}.${column}: ${String(row.COLUMN_TYPE)}`,
+        sourceFile: safeDisplay,
+        sourceLocation: `${table}.${column}`
+      });
+      edges.push({
+        source: tableId(schema, table),
+        target: columnId(schema, table, column),
+        relation: "contains",
+        confidence: "EXTRACTED"
+      });
+    }
+    const fkRows = await query(
+      "SELECT TABLE_NAME, COLUMN_NAME, REFERENCED_TABLE_NAME FROM information_schema.KEY_COLUMN_USAGE WHERE TABLE_SCHEMA = ? AND REFERENCED_TABLE_NAME IS NOT NULL ORDER BY TABLE_NAME, COLUMN_NAME",
+      [schema]
+    );
+    for (const row of fkRows) {
+      const table = String(row.TABLE_NAME);
+      const column = String(row.COLUMN_NAME);
+      const referenced = String(row.REFERENCED_TABLE_NAME);
+      if (!tableNames.has(table) || !tableNames.has(referenced)) continue;
+      edges.push({
+        source: columnId(schema, table, column),
+        target: tableId(schema, referenced),
+        relation: "references",
+        confidence: "EXTRACTED"
+      });
+    }
+    const viewNames = tables.filter((t) => t.isView).map((t) => t.name);
+    if (viewNames.length > 0) {
+      await addViewEdges(query, schema, viewNames, tableNames, edges);
+    }
+    return { nodes, edges };
+  } finally {
+    await close?.();
+  }
+}
+async function addViewEdges(query, schema, viewNames, tableNames, edges) {
+  try {
+    const usageRows = await query(
+      "SELECT VIEW_NAME, TABLE_NAME FROM information_schema.VIEW_TABLE_USAGE WHERE VIEW_SCHEMA = ? AND TABLE_SCHEMA = ? ORDER BY VIEW_NAME, TABLE_NAME",
+      [schema, schema]
+    );
+    for (const row of usageRows) {
+      const view = String(row.VIEW_NAME);
+      const table = String(row.TABLE_NAME);
+      if (!tableNames.has(view) || !tableNames.has(table) || view === table) continue;
+      edges.push({
+        source: tableId(schema, view),
+        target: tableId(schema, table),
+        relation: "references",
+        confidence: "EXTRACTED"
+      });
+    }
+    return;
+  } catch {
+  }
+  const definitionRows = await query(
+    "SELECT TABLE_NAME, VIEW_DEFINITION FROM information_schema.VIEWS WHERE TABLE_SCHEMA = ? ORDER BY TABLE_NAME",
+    [schema]
+  );
+  for (const row of definitionRows) {
+    const view = String(row.TABLE_NAME);
+    if (!viewNames.includes(view)) continue;
+    const definition = String(row.VIEW_DEFINITION ?? "").toLowerCase();
+    for (const table of [...tableNames].sort((a, b) => a.localeCompare(b))) {
+      if (table === view) continue;
+      if (new RegExp(`\\b${table.toLowerCase()}\\b`).test(definition)) {
+        edges.push({
+          source: tableId(schema, view),
+          target: tableId(schema, table),
+          relation: "references",
+          confidence: "INFERRED"
+        });
+      }
+    }
+  }
+}
+var schemaId, tableId, columnId;
+var init_mysql = __esm({
+  "src/extractors/mysql.ts"() {
+    "use strict";
+    init_cjs_shims();
     init_security();
+    schemaId = (schema) => `db:${schema}`;
+    tableId = (schema, table) => `db:${schema}::${table}`;
+    columnId = (schema, table, column) => `db:${schema}::${table}.${column}`;
   }
 });
 
 // src/cli/index.ts
 init_cjs_shims();
-var import_node_child_process = require("child_process");
-var fs13 = __toESM(require("fs/promises"), 1);
-var os = __toESM(require("os"), 1);
-var path10 = __toESM(require("path"), 1);
-var import_node_util = require("util");
+var import_node_child_process3 = require("child_process");
+var fs24 = __toESM(require("fs/promises"), 1);
+var os3 = __toESM(require("os"), 1);
+var path17 = __toESM(require("path"), 1);
+var import_node_util3 = require("util");
 var import_chokidar = require("chokidar");
 var import_commander = require("commander");
 
@@ -841,7 +1465,8 @@ init_graphStore();
 
 // src/pipeline.ts
 init_cjs_shims();
-var path7 = __toESM(require("path"), 1);
+var fs14 = __toESM(require("fs/promises"), 1);
+var path9 = __toESM(require("path"), 1);
 
 // src/build.ts
 init_cjs_shims();
@@ -947,10 +1572,39 @@ function buildGraph(extractions) {
   return graph;
 }
 
-// src/detect.ts
+// src/extractionCache.ts
 init_cjs_shims();
-var fs4 = __toESM(require("fs"), 1);
+var import_node_crypto3 = require("crypto");
+var fs4 = __toESM(require("fs/promises"), 1);
 var path3 = __toESM(require("path"), 1);
+var ExtractionCache = class {
+  dir;
+  constructor(outDir) {
+    this.dir = path3.join(outDir, "cache");
+  }
+  key(relFile, content) {
+    return (0, import_node_crypto3.createHash)("sha256").update(relFile).update("\0").update(content).digest("hex");
+  }
+  async get(key) {
+    try {
+      const raw = await fs4.readFile(path3.join(this.dir, `${key}.json`), "utf-8");
+      const parsed = JSON.parse(raw);
+      if (!Array.isArray(parsed.nodes) || !Array.isArray(parsed.edges)) return null;
+      return parsed;
+    } catch {
+      return null;
+    }
+  }
+  async put(key, extraction) {
+    await fs4.mkdir(this.dir, { recursive: true });
+    await fs4.writeFile(path3.join(this.dir, `${key}.json`), JSON.stringify(extraction), "utf-8");
+  }
+};
+
+// src/detect.ts
+init_cjs_shims();
+var fs5 = __toESM(require("fs"), 1);
+var path4 = __toESM(require("path"), 1);
 var SKIP_DIRS = /* @__PURE__ */ new Set([
   "node_modules",
   ".git",
@@ -1031,13 +1685,13 @@ function countWords(content) {
   return trimmed.split(/\s+/).length;
 }
 function readTextSafely(filePath) {
-  const buf = fs4.readFileSync(filePath);
+  const buf = fs5.readFileSync(filePath);
   return buf.toString("utf-8");
 }
 function collectFiles(root) {
-  const scanRoot = path3.resolve(root);
-  const stat = fs4.statSync(scanRoot);
-  if (!stat.isDirectory()) {
+  const scanRoot = path4.resolve(root);
+  const stat2 = fs5.statSync(scanRoot);
+  if (!stat2.isDirectory()) {
     throw new Error(`collectFiles: not a directory: ${scanRoot}`);
   }
   const files = {
@@ -1055,15 +1709,15 @@ function collectFiles(root) {
     const dir = stack.pop();
     let entries;
     try {
-      entries = fs4.readdirSync(dir, { withFileTypes: true });
+      entries = fs5.readdirSync(dir, { withFileTypes: true });
     } catch {
       continue;
     }
     entries.sort((a, b) => a.name.localeCompare(b.name));
     for (const entry of entries) {
       if (entry.isSymbolicLink()) continue;
-      const fullPath = path3.join(dir, entry.name);
-      const relPath = path3.relative(scanRoot, fullPath);
+      const fullPath = path4.join(dir, entry.name);
+      const relPath = path4.relative(scanRoot, fullPath);
       if (entry.isDirectory()) {
         if (SKIP_DIRS.has(entry.name) || entry.name.startsWith(".")) continue;
         stack.push(fullPath);
@@ -1074,7 +1728,7 @@ function collectFiles(root) {
         skippedSensitive.push(relPath);
         continue;
       }
-      const ext = path3.extname(entry.name);
+      const ext = path4.extname(entry.name);
       const category = categorize(ext);
       if (category === null) continue;
       files[category].push(relPath);
@@ -1103,15 +1757,15 @@ function collectFiles(root) {
 
 // src/extract.ts
 init_cjs_shims();
-var path6 = __toESM(require("path"), 1);
+var path7 = __toESM(require("path"), 1);
 
 // src/extractors/csharp.ts
 init_cjs_shims();
-var fs5 = __toESM(require("fs/promises"), 1);
+var fs6 = __toESM(require("fs/promises"), 1);
 
 // src/extractors/common.ts
 init_cjs_shims();
-var path4 = __toESM(require("path"), 1);
+var path5 = __toESM(require("path"), 1);
 function namedChildren(node) {
   return node.namedChildren.filter((c) => c !== null);
 }
@@ -1119,7 +1773,7 @@ function descendantsOfType(node, types) {
   return node.descendantsOfType(types).filter((c) => c !== null);
 }
 function toPosix(p) {
-  return p.split(path4.sep).join("/");
+  return p.split(path5.sep).join("/");
 }
 function lineOf(node) {
   return `L${node.startPosition.row + 1}`;
@@ -1132,9 +1786,9 @@ function externalId(name) {
 }
 function resolveModuleRef(sourceFile, specifier) {
   if (specifier.startsWith(".") || specifier.startsWith("/")) {
-    const dir = path4.posix.dirname(toPosix(sourceFile));
-    const joined = specifier.startsWith("/") ? specifier : path4.posix.join(dir, specifier);
-    const normalized = path4.posix.normalize(joined);
+    const dir = path5.posix.dirname(toPosix(sourceFile));
+    const joined = specifier.startsWith("/") ? specifier : path5.posix.join(dir, specifier);
+    const normalized = path5.posix.normalize(joined);
     return { id: normalized, label: specifier, external: false };
   }
   return { id: `module:${specifier}`, label: specifier, external: true };
@@ -1190,16 +1844,16 @@ async function createParser(grammarName) {
 }
 
 // src/extractors/csharp.ts
-async function extractCSharp(filePath) {
+async function extractCSharp(filePath, displayPath) {
   const parser = await createParser("c_sharp");
-  const raw = await fs5.readFile(filePath);
+  const raw = await fs6.readFile(filePath);
   const content = raw.toString("utf-8");
   const tree = parser.parse(content);
   if (!tree) {
     throw new Error(`extractCSharp: parser produced no tree for ${filePath}`);
   }
   const root = tree.rootNode;
-  const sourceFile = toPosix(filePath);
+  const sourceFile = toPosix(displayPath ?? filePath);
   const builder = new ExtractionBuilder();
   const fileId = sourceFile;
   builder.addNode({ id: fileId, label: sourceFile, sourceFile, sourceLocation: "L1" });
@@ -1389,7 +2043,7 @@ async function extractCSharp(filePath) {
 
 // src/extractors/go.ts
 init_cjs_shims();
-var fs6 = __toESM(require("fs/promises"), 1);
+var fs7 = __toESM(require("fs/promises"), 1);
 function stripQuotes(text) {
   if (text.length >= 2) {
     const first = text[0];
@@ -1404,16 +2058,16 @@ function defaultPackageQualifier(importPath) {
   const segments = importPath.split("/");
   return segments[segments.length - 1] ?? importPath;
 }
-async function extractGo(filePath) {
+async function extractGo(filePath, displayPath) {
   const parser = await createParser("go");
-  const raw = await fs6.readFile(filePath);
+  const raw = await fs7.readFile(filePath);
   const content = raw.toString("utf-8");
   const tree = parser.parse(content);
   if (!tree) {
     throw new Error(`extractGo: parser produced no tree for ${filePath}`);
   }
   const root = tree.rootNode;
-  const sourceFile = toPosix(filePath);
+  const sourceFile = toPosix(displayPath ?? filePath);
   const builder = new ExtractionBuilder();
   const fileId = sourceFile;
   builder.addNode({ id: fileId, label: sourceFile, sourceFile, sourceLocation: "L1" });
@@ -1611,17 +2265,17 @@ async function extractGo(filePath) {
 
 // src/extractors/java.ts
 init_cjs_shims();
-var fs7 = __toESM(require("fs/promises"), 1);
-async function extractJava(filePath) {
+var fs8 = __toESM(require("fs/promises"), 1);
+async function extractJava(filePath, displayPath) {
   const parser = await createParser("java");
-  const raw = await fs7.readFile(filePath);
+  const raw = await fs8.readFile(filePath);
   const content = raw.toString("utf-8");
   const tree = parser.parse(content);
   if (!tree) {
     throw new Error(`extractJava: parser produced no tree for ${filePath}`);
   }
   const root = tree.rootNode;
-  const sourceFile = toPosix(filePath);
+  const sourceFile = toPosix(displayPath ?? filePath);
   const builder = new ExtractionBuilder();
   const fileId = sourceFile;
   builder.addNode({ id: fileId, label: sourceFile, sourceFile, sourceLocation: "L1" });
@@ -1813,17 +2467,17 @@ async function extractJava(filePath) {
 
 // src/extractors/python.ts
 init_cjs_shims();
-var fs8 = __toESM(require("fs/promises"), 1);
-async function extractPython(filePath) {
+var fs9 = __toESM(require("fs/promises"), 1);
+async function extractPython(filePath, displayPath) {
   const parser = await createParser("python");
-  const raw = await fs8.readFile(filePath);
+  const raw = await fs9.readFile(filePath);
   const content = raw.toString("utf-8");
   const tree = parser.parse(content);
   if (!tree) {
     throw new Error(`extractPython: parser produced no tree for ${filePath}`);
   }
   const root = tree.rootNode;
-  const sourceFile = toPosix(filePath);
+  const sourceFile = toPosix(displayPath ?? filePath);
   const builder = new ExtractionBuilder();
   const fileId = sourceFile;
   builder.addNode({ id: fileId, label: sourceFile, sourceFile, sourceLocation: "L1" });
@@ -2049,7 +2703,7 @@ async function extractPython(filePath) {
 
 // src/extractors/ruby.ts
 init_cjs_shims();
-var fs9 = __toESM(require("fs/promises"), 1);
+var fs10 = __toESM(require("fs/promises"), 1);
 function conventionalConstantName(specifier) {
   const lastSegment = specifier.split("/").filter(Boolean).pop() ?? specifier;
   return lastSegment.split("_").filter(Boolean).map((word) => word.charAt(0).toUpperCase() + word.slice(1)).join("");
@@ -2059,16 +2713,16 @@ function stringLiteralContent(node) {
   const content = namedChildren(node).find((c) => c.type === "string_content");
   return content ? content.text : "";
 }
-async function extractRuby(filePath) {
+async function extractRuby(filePath, displayPath) {
   const parser = await createParser("ruby");
-  const raw = await fs9.readFile(filePath);
+  const raw = await fs10.readFile(filePath);
   const content = raw.toString("utf-8");
   const tree = parser.parse(content);
   if (!tree) {
     throw new Error(`extractRuby: parser produced no tree for ${filePath}`);
   }
   const root = tree.rootNode;
-  const sourceFile = toPosix(filePath);
+  const sourceFile = toPosix(displayPath ?? filePath);
   const builder = new ExtractionBuilder();
   const fileId = sourceFile;
   builder.addNode({ id: fileId, label: sourceFile, sourceFile, sourceLocation: "L1" });
@@ -2246,7 +2900,7 @@ async function extractRuby(filePath) {
 
 // src/extractors/rust.ts
 init_cjs_shims();
-var fs10 = __toESM(require("fs/promises"), 1);
+var fs11 = __toESM(require("fs/promises"), 1);
 function convertUsePath(segments) {
   const first = segments[0];
   if (first === "crate" || first === "self") {
@@ -2262,16 +2916,16 @@ function convertUsePath(segments) {
   }
   return segments.join("::");
 }
-async function extractRust(filePath) {
+async function extractRust(filePath, displayPath) {
   const parser = await createParser("rust");
-  const raw = await fs10.readFile(filePath);
+  const raw = await fs11.readFile(filePath);
   const content = raw.toString("utf-8");
   const tree = parser.parse(content);
   if (!tree) {
     throw new Error(`extractRust: parser produced no tree for ${filePath}`);
   }
   const root = tree.rootNode;
-  const sourceFile = toPosix(filePath);
+  const sourceFile = toPosix(displayPath ?? filePath);
   const builder = new ExtractionBuilder();
   const fileId = sourceFile;
   builder.addNode({ id: fileId, label: sourceFile, sourceFile, sourceLocation: "L1" });
@@ -2484,10 +3138,10 @@ async function extractRust(filePath) {
         }
       }
     } else if (fn.type === "scoped_identifier") {
-      const path11 = fn.childForFieldName("path")?.text;
+      const path18 = fn.childForFieldName("path")?.text;
       const name = fn.childForFieldName("name")?.text;
-      if (path11 && name) {
-        const viaImport = importIndex.get(path11);
+      if (path18 && name) {
+        const viaImport = importIndex.get(path18);
         if (viaImport) {
           targetId = viaImport.id;
           confidence = "INFERRED";
@@ -2503,8 +3157,8 @@ async function extractRust(filePath) {
 
 // src/extractors/typescript.ts
 init_cjs_shims();
-var fs11 = __toESM(require("fs/promises"), 1);
-var path5 = __toESM(require("path"), 1);
+var fs12 = __toESM(require("fs/promises"), 1);
+var path6 = __toESM(require("path"), 1);
 function grammarForExtension(ext) {
   const lower = ext.toLowerCase();
   if (lower === ".tsx") return "tsx";
@@ -2529,18 +3183,18 @@ function firstStringArgument(call) {
   if (!first || first.type !== "string") return null;
   return stripQuotes2(first.text);
 }
-async function extractTypeScript(filePath) {
-  const ext = path5.extname(filePath);
+async function extractTypeScript(filePath, displayPath) {
+  const ext = path6.extname(filePath);
   const grammar = grammarForExtension(ext);
   const parser = await createParser(grammar);
-  const raw = await fs11.readFile(filePath);
+  const raw = await fs12.readFile(filePath);
   const content = raw.toString("utf-8");
   const tree = parser.parse(content);
   if (!tree) {
     throw new Error(`extractTypeScript: parser produced no tree for ${filePath}`);
   }
   const root = tree.rootNode;
-  const sourceFile = toPosix(filePath);
+  const sourceFile = toPosix(displayPath ?? filePath);
   const builder = new ExtractionBuilder();
   const fileId = sourceFile;
   builder.addNode({ id: fileId, label: sourceFile, sourceFile, sourceLocation: "L1" });
@@ -2857,13 +3511,13 @@ var EXTRACTOR_REGISTRY = {
   ".cs": extractCSharp,
   ".rb": extractRuby
 };
-async function extract(filePath) {
-  const ext = path6.extname(filePath);
+async function extract(filePath, displayPath) {
+  const ext = path7.extname(filePath);
   const extractor = EXTRACTOR_REGISTRY[ext];
   if (!extractor) {
     return { nodes: [], edges: [] };
   }
-  return extractor(filePath);
+  return extractor(filePath, displayPath);
 }
 
 // src/report.ts
@@ -2945,37 +3599,206 @@ function renderReport(graph, analysis, now = /* @__PURE__ */ new Date()) {
   return lines.join("\n");
 }
 
-// src/pipeline.ts
-async function runPipeline(root, options = {}) {
-  const progress = options.onProgress ?? (() => {
-  });
-  const resolvedRoot = path7.resolve(root);
-  progress(`Scanning ${resolvedRoot} ...`);
-  const manifest = collectFiles(resolvedRoot);
-  progress(
-    `Found ${manifest.totalFiles} file(s) (${manifest.files.code.length} code, ${manifest.skippedSensitive.length} skipped as sensitive).`
-  );
-  progress("Extracting...");
-  const extractions = [];
-  for (const relFile of manifest.files.code.sort((a, b) => a.localeCompare(b))) {
-    const filePath = path7.relative(process.cwd(), path7.join(resolvedRoot, relFile)) || relFile;
-    try {
-      const extraction = await extract(filePath);
-      extractions.push(extraction);
-    } catch (error) {
-      progress(`  extraction failed for ${relFile}: ${error.message}`);
-      throw error;
-    }
-  }
-  progress("Building graph...");
-  const graph = buildGraph(extractions);
-  progress(`Clustering (${options.algorithm ?? "louvain"})...`);
-  cluster(graph, { algorithm: options.algorithm, maxIterations: options.maxIterations });
-  progress("Analyzing...");
-  const analysis = analyze(graph);
+// src/resolve.ts
+init_cjs_shims();
+var fs13 = __toESM(require("fs/promises"), 1);
+var path8 = __toESM(require("path"), 1);
+var CODE_EXTENSIONS2 = [
+  ".ts",
+  ".tsx",
+  ".mts",
+  ".cts",
+  ".js",
+  ".jsx",
+  ".mjs",
+  ".cjs",
+  ".py",
+  ".go",
+  ".rs",
+  ".java",
+  ".cs",
+  ".rb"
+];
+function isOpaque(id) {
+  return id.startsWith("module:") || id.startsWith("external:") || id.startsWith("db:");
+}
+var SELF_IMPORT_STEMS = (subpath) => subpath === "" ? ["index", "src/index", "lib/index", "source/index", "src/main"] : [
+  subpath,
+  `src/${subpath}`,
+  `lib/${subpath}`,
+  `source/${subpath}`,
+  `${subpath}/index`,
+  `src/${subpath}/index`,
+  `lib/${subpath}/index`
+];
+function selfImportCandidates(spec, selfNames) {
+  const selfName = selfNames.find((n) => spec === n || spec.startsWith(`${n}/`));
+  if (selfName === void 0) return null;
+  const subpath = spec === selfName ? "" : spec.slice(selfName.length + 1);
+  return SELF_IMPORT_STEMS(subpath).flatMap((stem) => CODE_EXTENSIONS2.map((ext) => `${stem}${ext}`));
+}
+async function readSelfNames(root) {
+  try {
+    const pkg = JSON.parse(await fs13.readFile(path8.join(root, "package.json"), "utf-8"));
+    return typeof pkg.name === "string" && pkg.name.length > 0 ? [pkg.name] : [];
+  } catch {
+    return [];
+  }
+}
+function stripKnownExtension(p) {
+  for (const ext of CODE_EXTENSIONS2) {
+    if (p.endsWith(ext)) return p.slice(0, -ext.length);
+  }
+  return null;
+}
+function candidatePaths(guessed) {
+  const stem = stripKnownExtension(guessed) ?? guessed;
+  const candidates = [];
+  for (const ext of CODE_EXTENSIONS2) candidates.push(`${stem}${ext}`);
+  for (const ext of CODE_EXTENSIONS2) candidates.push(`${guessed}/index${ext}`);
+  if (stem !== guessed) {
+    for (const ext of CODE_EXTENSIONS2) candidates.push(`${stem}/index${ext}`);
+  }
+  return candidates.filter((c) => c !== guessed);
+}
+function uniqueMatch(guessed, candidates, realIds) {
+  const matches = /* @__PURE__ */ new Set();
+  for (const candidate of candidates) {
+    if (realIds.has(candidate)) matches.add(candidate);
+  }
+  if (matches.size !== 1) return null;
+  return [...matches][0];
+}
+function resolveCrossFileReferences(extractions, options = {}) {
+  const selfNames = options.selfNames ?? [];
+  const realIds = /* @__PURE__ */ new Set();
+  const realFiles = /* @__PURE__ */ new Set();
+  for (const extraction of extractions) {
+    for (const node of extraction.nodes) realIds.add(node.id);
+    const first = extraction.nodes[0];
+    if (first && first.id === first.sourceFile && !isOpaque(first.id)) {
+      realFiles.add(first.id);
+    }
+    for (const node of extraction.nodes) {
+      const sep3 = node.id.indexOf("::");
+      if (sep3 > 0) realFiles.add(node.id.slice(0, sep3));
+    }
+    for (const edge of extraction.edges) {
+      if (edge.relation === "contains") realFiles.add(edge.source);
+    }
+  }
+  const remap = /* @__PURE__ */ new Map();
+  const resolveId = (id) => {
+    if (id.startsWith("module:") && selfNames.length > 0) {
+      const cachedSelf = remap.get(id);
+      if (cachedSelf !== void 0) return cachedSelf;
+      const candidates = selfImportCandidates(id.slice("module:".length), selfNames);
+      if (candidates !== null) {
+        const resolved2 = uniqueMatch(id, candidates, realFiles);
+        if (resolved2 !== null) {
+          remap.set(id, resolved2);
+          return resolved2;
+        }
+      }
+      return null;
+    }
+    if (isOpaque(id)) return null;
+    const cached = remap.get(id);
+    if (cached !== void 0) return cached;
+    const sep3 = id.indexOf("::");
+    let resolved;
+    if (sep3 > 0) {
+      if (realIds.has(id)) return null;
+      const guessedPath = id.slice(0, sep3);
+      const name = id.slice(sep3);
+      const candidates = candidatePaths(guessedPath).map((p) => `${p}${name}`);
+      resolved = uniqueMatch(id, candidates, realIds);
+    } else {
+      if (realFiles.has(id)) return null;
+      resolved = uniqueMatch(id, candidatePaths(id), realFiles);
+    }
+    if (resolved !== null) remap.set(id, resolved);
+    return resolved;
+  };
+  let resolvedEndpoints = 0;
+  for (const extraction of extractions) {
+    for (const edge of extraction.edges) {
+      const source = resolveId(edge.source);
+      if (source !== null) {
+        edge.source = source;
+        resolvedEndpoints++;
+      }
+      const target = resolveId(edge.target);
+      if (target !== null) {
+        edge.target = target;
+        resolvedEndpoints++;
+      }
+    }
+  }
+  let droppedPlaceholders = 0;
+  for (const extraction of extractions) {
+    const before = extraction.nodes.length;
+    extraction.nodes = extraction.nodes.filter((node) => !remap.has(node.id));
+    droppedPlaceholders += before - extraction.nodes.length;
+  }
+  return { resolvedEndpoints, droppedPlaceholders };
+}
+
+// src/pipeline.ts
+async function runPipeline(root, options = {}) {
+  const progress = options.onProgress ?? (() => {
+  });
+  const resolvedRoot = path9.resolve(root);
+  progress(`Scanning ${resolvedRoot} ...`);
+  const manifest = collectFiles(resolvedRoot);
+  progress(
+    `Found ${manifest.totalFiles} file(s) (${manifest.files.code.length} code, ${manifest.skippedSensitive.length} skipped as sensitive).`
+  );
+  const outDir = options.outDir ?? path9.join(resolvedRoot, "graphify-out");
+  const cache = new ExtractionCache(outDir);
+  progress("Extracting...");
+  const extractions = [];
+  let cacheHits = 0;
+  for (const relFile of manifest.files.code.sort((a, b) => a.localeCompare(b))) {
+    const filePath = path9.relative(process.cwd(), path9.join(resolvedRoot, relFile)) || relFile;
+    try {
+      const key = cache.key(relFile, await fs14.readFile(path9.join(resolvedRoot, relFile)));
+      let extraction = options.update ? await cache.get(key) : null;
+      if (extraction) {
+        cacheHits++;
+      } else {
+        extraction = await extract(filePath, relFile);
+        await cache.put(key, extraction);
+      }
+      extractions.push(extraction);
+    } catch (error) {
+      progress(`  extraction failed for ${relFile}: ${error.message}`);
+      throw error;
+    }
+  }
+  if (options.update) {
+    progress(`  cache: ${cacheHits} hit(s), ${extractions.length - cacheHits} re-extracted.`);
+  }
+  if (options.extraExtractions && options.extraExtractions.length > 0) {
+    extractions.push(...options.extraExtractions);
+  }
+  progress("Resolving cross-file references...");
+  const resolveStats = resolveCrossFileReferences(extractions, {
+    selfNames: await readSelfNames(resolvedRoot)
+  });
+  if (resolveStats.resolvedEndpoints > 0) {
+    progress(
+      `  re-pointed ${resolveStats.resolvedEndpoints} guessed reference(s) at real nodes (${resolveStats.droppedPlaceholders} placeholder node(s) dropped).`
+    );
+  }
+  progress("Building graph...");
+  const graph = buildGraph(extractions);
+  progress(`Clustering (${options.algorithm ?? "louvain"})...`);
+  cluster(graph, { algorithm: options.algorithm, maxIterations: options.maxIterations });
+  progress("Analyzing...");
+  const analysis = analyze(graph);
   progress("Rendering report...");
   const report = renderReport(graph, analysis);
-  const outDir = options.outDir ?? path7.join(resolvedRoot, "graphify-out");
   progress(`Exporting to ${outDir} ...`);
   await exportGraph(
     graph,
@@ -2996,6 +3819,232 @@ async function runPipeline(root, options = {}) {
 // src/cli/index.ts
 init_security();
 
+// src/cli/commands/affected.ts
+init_cjs_shims();
+init_graphStore();
+init_impact();
+async function runAffected(nodeName, options = {}) {
+  const graph = await loadGraph();
+  const result = affectedBy(graph, nodeName, { maxDepth: options.depth, limit: options.limit });
+  if (!result) {
+    console.log(`No node matched "${nodeName}".`);
+    return;
+  }
+  console.log(`Impact of changing ${result.target.label} (${result.target.id}):`);
+  if (result.affected.length === 0) {
+    console.log("  Nothing in the graph depends on it \u2014 no incoming dependency edges.");
+    return;
+  }
+  let currentDepth = 0;
+  for (const node of result.affected) {
+    if (node.depth !== currentDepth) {
+      currentDepth = node.depth;
+      console.log("");
+      console.log(currentDepth === 1 ? "Directly affected:" : `Affected at depth ${currentDepth}:`);
+    }
+    const isPlaceholder = node.sourceFile === "<unknown>" || node.sourceFile === "<external>" || node.sourceFile === "";
+    const where = isPlaceholder ? "(reference only)" : `${node.sourceFile}${node.sourceLocation ? `:${node.sourceLocation}` : ""}`;
+    console.log(
+      `  ${node.label} \u2014 ${where} (--${node.via.relation}--> ${node.via.dependsOn}, ${node.via.confidence})`
+    );
+  }
+  console.log("");
+  const { EXTRACTED, INFERRED, AMBIGUOUS } = result.byConfidence;
+  console.log(
+    `Blast radius: ${result.affected.length} node(s) within ${result.maxDepth} hop(s) \u2014 ${EXTRACTED} certain (EXTRACTED), ${INFERRED} likely (INFERRED), ${AMBIGUOUS} uncertain (AMBIGUOUS).`
+  );
+  if (result.truncated) {
+    console.log("(List truncated \u2014 raise --limit to see more.)");
+  }
+}
+
+// src/cli/commands/benchmark.ts
+init_cjs_shims();
+var fs15 = __toESM(require("fs/promises"), 1);
+init_graphStore();
+init_query();
+init_testmap();
+var tokensOf = (text) => Math.ceil(text.length / 4);
+async function benchmarkQuestion(graph, question, readFile21) {
+  const result = queryGraph(graph, question);
+  const graphTokens = tokensOf(JSON.stringify(result));
+  const sourceFiles = /* @__PURE__ */ new Set();
+  for (const node of result.visited) {
+    if (node.sourceFile && !node.sourceFile.startsWith("<") && !node.sourceFile.includes("://")) {
+      sourceFiles.add(node.sourceFile);
+    }
+  }
+  let naiveTokens = 0;
+  let filesRead = 0;
+  let filesMissing = 0;
+  for (const file of [...sourceFiles].sort((a, b) => a.localeCompare(b))) {
+    try {
+      naiveTokens += tokensOf(await readFile21(file));
+      filesRead++;
+    } catch {
+      filesMissing++;
+    }
+  }
+  return {
+    question,
+    graphTokens,
+    naiveTokens,
+    reduction: graphTokens > 0 && naiveTokens > 0 ? naiveTokens / graphTokens : 0,
+    filesRead,
+    filesMissing
+  };
+}
+var NON_QUESTION_FILE = /(^|\/)(examples?|scripts?|bench(?:mark)?s?|fixtures?|docs?|\.github)\/|\.(config|conf)\.[^/]+$|(^|\/)(rollup|webpack|vite|vitest|jest|babel|tsup|eslint|prettier)\.[^/]*$/i;
+function defaultQuestions(graph, count = 5) {
+  const entries = [...graph.nodes()].map((id) => ({
+    id,
+    degree: graph.degree(id),
+    label: graph.getNodeAttribute(id, "label") ?? id,
+    file: graph.getNodeAttribute(id, "sourceFile") ?? ""
+  })).filter((e) => e.id.includes("::")).filter((e) => !isTestFile(e.file) && !NON_QUESTION_FILE.test(e.file)).sort((a, b) => b.degree - a.degree || a.id.localeCompare(b.id));
+  return entries.slice(0, count).map((e) => `how does ${e.label} work`);
+}
+async function runBenchmark(questions) {
+  const graph = await loadGraph();
+  const effective = questions.length > 0 ? questions : defaultQuestions(graph);
+  if (effective.length === 0) {
+    console.log("The graph has no entity nodes to benchmark against \u2014 build it first.");
+    return [];
+  }
+  const rows = [];
+  for (const question of effective) {
+    rows.push(await benchmarkQuestion(graph, question, (p) => fs15.readFile(p, "utf-8")));
+  }
+  console.log("Token cost per question \u2014 graph answer vs reading the files it touches:\n");
+  for (const row of rows) {
+    const reduction = row.reduction > 0 ? `${row.reduction.toFixed(1)}x` : "n/a";
+    console.log(`  "${row.question}"`);
+    console.log(
+      `    graph: ~${row.graphTokens} tokens | files: ~${row.naiveTokens} tokens (${row.filesRead} file(s)${row.filesMissing ? `, ${row.filesMissing} unreadable` : ""}) | reduction: ${reduction}`
+    );
+  }
+  const scored = rows.filter((r) => r.reduction > 0);
+  if (scored.length > 0) {
+    const avg = scored.reduce((s, r) => s + r.reduction, 0) / scored.length;
+    console.log(`
+Average reduction: ${avg.toFixed(1)}x across ${scored.length} question(s).`);
+  } else {
+    console.log("\nNo reduction could be measured \u2014 run from the project root so source files are readable.");
+  }
+  return rows;
+}
+
+// src/cli/commands/check.ts
+init_cjs_shims();
+var fs16 = __toESM(require("fs/promises"), 1);
+var path10 = __toESM(require("path"), 1);
+
+// src/check.ts
+init_cjs_shims();
+var DEPENDENCY_RELATIONS2 = /* @__PURE__ */ new Set([
+  "calls",
+  "imports",
+  "imports_from",
+  "inherits",
+  "implements",
+  "mixes_in",
+  "embeds",
+  "re_exports"
+]);
+function globToRegExp(glob) {
+  const escaped = glob.replace(/[.+^${}()|[\]\\]/g, "\\$&");
+  const pattern = escaped.replace(
+    /\*\*|\*|\?/g,
+    (token) => token === "**" ? ".*" : token === "*" ? "[^/]*" : "[^/]"
+  );
+  return new RegExp(`^${pattern}$`);
+}
+function validateRules(value) {
+  const config = value;
+  if (!config || !Array.isArray(config.rules)) {
+    throw new Error('Rules file must be JSON of shape { "rules": [{ "name", "from", "disallow": [...] }] }');
+  }
+  for (const rule of config.rules) {
+    if (!rule.name || typeof rule.from !== "string" || !Array.isArray(rule.disallow)) {
+      throw new Error(`Malformed rule "${rule.name ?? "(unnamed)"}" \u2014 need name, from, and disallow[].`);
+    }
+  }
+  return config;
+}
+function checkRules(graph, config) {
+  const compiled = config.rules.map((rule) => ({
+    rule,
+    from: globToRegExp(rule.from),
+    disallow: rule.disallow.map(globToRegExp)
+  }));
+  const violations = [];
+  graph.forEachEdge((_edge, attrs, source, target) => {
+    const relation = String(attrs.relation);
+    if (!DEPENDENCY_RELATIONS2.has(relation)) return;
+    const fromFile = graph.getNodeAttribute(source, "sourceFile") ?? "";
+    const toFile = graph.getNodeAttribute(target, "sourceFile") ?? "";
+    if (!fromFile || !toFile || fromFile === toFile) return;
+    for (const { rule, from, disallow } of compiled) {
+      if (!from.test(fromFile)) continue;
+      if (disallow.some((d) => d.test(toFile))) {
+        violations.push({
+          rule: rule.name,
+          reason: rule.reason,
+          fromFile,
+          fromNode: source,
+          toFile,
+          toNode: target,
+          relation
+        });
+      }
+    }
+  });
+  violations.sort(
+    (a, b) => a.rule.localeCompare(b.rule) || a.fromFile.localeCompare(b.fromFile) || a.toFile.localeCompare(b.toFile) || a.fromNode.localeCompare(b.fromNode)
+  );
+  return violations;
+}
+
+// src/cli/commands/check.ts
+init_graphStore();
+async function runCheck(options = {}) {
+  const rulesPath = path10.resolve(options.rules ?? "graphify.rules.json");
+  let raw;
+  try {
+    raw = await fs16.readFile(rulesPath, "utf-8");
+  } catch {
+    throw new Error(
+      `No rules file at ${rulesPath} \u2014 create graphify.rules.json with { "rules": [{ "name": "...", "from": "src/a/**", "disallow": ["src/b/**"] }] }.`
+    );
+  }
+  const config = validateRules(JSON.parse(raw));
+  const graph = await loadGraph();
+  const violations = checkRules(graph, config);
+  if (violations.length === 0) {
+    console.log(`OK \u2014 ${config.rules.length} rule(s), no violations.`);
+    return;
+  }
+  console.log(`${violations.length} violation(s):`);
+  for (const v of violations) {
+    console.log(`  [${v.rule}] ${v.fromNode} --${v.relation}--> ${v.toNode}`);
+    console.log(`    ${v.fromFile} must not depend on ${v.toFile}${v.reason ? ` \u2014 ${v.reason}` : ""}`);
+  }
+  process.exitCode = 1;
+}
+
+// src/cli/commands/context.ts
+init_cjs_shims();
+var fs17 = __toESM(require("fs/promises"), 1);
+init_context();
+init_graphStore();
+async function runContext(task, options = {}) {
+  const graph = await loadGraph();
+  const pack = await buildContextPack(graph, task, (p) => fs17.readFile(p, "utf-8"), {
+    tokenBudget: options.budget
+  });
+  console.log(renderContextPack(pack));
+}
+
 // src/cli/commands/explain.ts
 init_cjs_shims();
 init_graphStore();
@@ -3007,9 +4056,13 @@ async function runExplain(nodeName) {
     console.log(`No node matched "${nodeName}".`);
     return;
   }
-  const location = result.sourceLocation ? `:${result.sourceLocation}` : "";
   console.log(result.label);
-  console.log(`  location: ${result.sourceFile}${location}`);
+  if (result.sourceFile === "<unknown>" || result.sourceFile === "<external>" || result.sourceFile === "") {
+    console.log("  location: (reference only \u2014 no declaration seen; check its outgoing edges for the real definition)");
+  } else {
+    const location = result.sourceLocation ? `:${result.sourceLocation}` : "";
+    console.log(`  location: ${result.sourceFile}${location}`);
+  }
   if (result.communityLabel) {
     console.log(`  community: ${result.communityLabel}`);
   }
@@ -3033,32 +4086,685 @@ async function runExplain(nodeName) {
   }
 }
 
+// src/cli/commands/review.ts
+init_cjs_shims();
+
+// src/diff.ts
+init_cjs_shims();
+var import_node_child_process = require("child_process");
+var fs18 = __toESM(require("fs/promises"), 1);
+var os = __toESM(require("os"), 1);
+var path11 = __toESM(require("path"), 1);
+var import_node_util = require("util");
+init_impact();
+init_testmap();
+var execFileAsync = (0, import_node_util.promisify)(import_node_child_process.execFile);
+async function graphForDirectory(root) {
+  const manifest = collectFiles(root);
+  const extractions = [];
+  for (const relFile of manifest.files.code.sort((a, b) => a.localeCompare(b))) {
+    extractions.push(await extract(path11.join(root, relFile), relFile));
+  }
+  resolveCrossFileReferences(extractions, { selfNames: await readSelfNames(root) });
+  return buildGraph(extractions);
+}
+async function checkoutRev(repoRoot, rev) {
+  const dest = await fs18.mkdtemp(path11.join(os.tmpdir(), `graphify-review-${rev.replace(/[^a-zA-Z0-9]/g, "_")}-`));
+  const { stdout } = await execFileAsync(
+    "git",
+    ["-C", repoRoot, "archive", "--format=tar", rev],
+    { encoding: "buffer", maxBuffer: 512 * 1024 * 1024 }
+  );
+  await new Promise((resolve10, reject) => {
+    const tar = (0, import_node_child_process.execFile)("tar", ["-x", "-C", dest], (error) => error ? reject(error) : resolve10());
+    tar.stdin?.end(stdout);
+  });
+  return dest;
+}
+function edgeSignature(graph, id) {
+  const signature = /* @__PURE__ */ new Set();
+  graph.forEachOutEdge(id, (_e, attrs, _s, target) => signature.add(`-> ${String(attrs.relation)} ${target}`));
+  graph.forEachInEdge(id, (_e, attrs, source) => signature.add(`<- ${String(attrs.relation)} ${source}`));
+  return signature;
+}
+function describeSymbol(graph, id) {
+  const attrs = graph.getNodeAttributes(id);
+  const impact = affectedBy(graph, id, { maxDepth: 3 });
+  const tests = testsForNode(graph, id);
+  return {
+    id,
+    label: attrs.label ?? id,
+    sourceFile: attrs.sourceFile ?? "",
+    blastRadius: impact?.affected.length ?? 0,
+    tests: tests?.testFiles.map((t) => t.file) ?? []
+  };
+}
+function entityIds(graph) {
+  const ids = /* @__PURE__ */ new Set();
+  graph.forEachNode((id) => {
+    if (id.includes("::")) ids.add(id);
+  });
+  return ids;
+}
+function diffGraphs(baseGraph, headGraph, base, head) {
+  const baseIds = entityIds(baseGraph);
+  const headIds = entityIds(headGraph);
+  const added = [];
+  const removed = [];
+  const rewired = [];
+  for (const id of [...headIds].sort((a, b) => a.localeCompare(b))) {
+    if (!baseIds.has(id)) {
+      added.push(describeSymbol(headGraph, id));
+      continue;
+    }
+    const before = edgeSignature(baseGraph, id);
+    const after = edgeSignature(headGraph, id);
+    const gained = [...after].filter((e) => !before.has(e)).sort((a, b) => a.localeCompare(b));
+    const lost = [...before].filter((e) => !after.has(e)).sort((a, b) => a.localeCompare(b));
+    if (gained.length > 0 || lost.length > 0) {
+      rewired.push({ ...describeSymbol(headGraph, id), gainedEdges: gained, lostEdges: lost });
+    }
+  }
+  for (const id of [...baseIds].sort((a, b) => a.localeCompare(b))) {
+    if (!headIds.has(id)) removed.push(describeSymbol(baseGraph, id));
+  }
+  return { base, head, added, removed, rewired };
+}
+async function reviewRevisions(repoRoot, base, head = "HEAD") {
+  const [baseDir, headDir] = await Promise.all([checkoutRev(repoRoot, base), checkoutRev(repoRoot, head)]);
+  try {
+    const [baseGraph, headGraph] = [await graphForDirectory(baseDir), await graphForDirectory(headDir)];
+    return diffGraphs(baseGraph, headGraph, base, head);
+  } finally {
+    await Promise.all([
+      fs18.rm(baseDir, { recursive: true, force: true }),
+      fs18.rm(headDir, { recursive: true, force: true })
+    ]);
+  }
+}
+function renderReview(diff) {
+  const lines = [
+    `# Structural review: ${diff.base}..${diff.head}`,
+    "",
+    `${diff.added.length} symbol(s) added, ${diff.removed.length} removed, ${diff.rewired.length} rewired.`,
+    ""
+  ];
+  const section = (title, symbols) => {
+    lines.push(`## ${title} (${symbols.length})`, "");
+    if (symbols.length === 0) {
+      lines.push("(none)", "");
+      return;
+    }
+    for (const s of symbols) {
+      const tests = s.tests.length > 0 ? ` | tests: ${s.tests.join(", ")}` : " | tests: none found";
+      lines.push(`- **${s.label}** (${s.sourceFile}) \u2014 blast radius ${s.blastRadius}${tests}`);
+      const r = s;
+      if (r.gainedEdges) {
+        for (const e of r.gainedEdges.slice(0, 5)) lines.push(`  - gained: ${e}`);
+        for (const e of r.lostEdges.slice(0, 5)) lines.push(`  - lost: ${e}`);
+      }
+    }
+    lines.push("");
+  };
+  section("Removed \u2014 check every caller", diff.removed);
+  section("Rewired \u2014 dependencies changed", diff.rewired);
+  section("Added", diff.added);
+  const allTests = /* @__PURE__ */ new Set();
+  for (const s of [...diff.removed, ...diff.rewired, ...diff.added]) {
+    for (const t of s.tests) allTests.add(t);
+  }
+  lines.push(`## Suggested test run (${allTests.size} file(s))`, "");
+  for (const t of [...allTests].sort((a, b) => a.localeCompare(b))) lines.push(`- ${t}`);
+  lines.push("");
+  return lines.join("\n");
+}
+
+// src/cli/commands/review.ts
+async function runReview(base, head) {
+  const diff = await reviewRevisions(process.cwd(), base, head ?? "HEAD");
+  console.log(renderReview(diff));
+}
+
+// src/cli/commands/tests.ts
+init_cjs_shims();
+var import_node_child_process2 = require("child_process");
+var import_node_util2 = require("util");
+init_graphStore();
+init_testmap();
+var execFileAsync2 = (0, import_node_util2.promisify)(import_node_child_process2.execFile);
+async function runTests(nodeQuery, options = {}) {
+  const graph = await loadGraph();
+  let selection;
+  if (options.changed !== void 0 && options.changed !== false) {
+    const args = ["diff", "--name-only"];
+    if (typeof options.changed === "string") args.push(options.changed);
+    const { stdout } = await execFileAsync2("git", args);
+    const changedFiles = stdout.split("\n").map((l) => l.trim()).filter(Boolean);
+    if (changedFiles.length === 0) {
+      console.log("No changed files in the diff.");
+      return;
+    }
+    selection = testsForChangedFiles(graph, changedFiles);
+  } else if (nodeQuery) {
+    selection = testsForNode(graph, nodeQuery);
+    if (!selection) {
+      console.log(`No node matched "${nodeQuery}".`);
+      return;
+    }
+  } else {
+    console.log("Provide a node to select tests for, or --changed for the working-tree diff.");
+    return;
+  }
+  if (selection.testFiles.length === 0) {
+    console.log(
+      `No test files found in the blast radius of ${selection.target} (${selection.affectedNodeCount} affected node(s) checked) \u2014 either it's untested or the tests reach it through a path the graph does not capture.`
+    );
+    return;
+  }
+  console.log(`Test files for ${selection.target} (most direct first):`);
+  for (const test of selection.testFiles) {
+    const via = test.depth === 0 ? test.via : `depth ${test.depth}, via ${test.via}`;
+    console.log(`  ${test.file}  (${via})`);
+  }
+}
+
+// src/cli/commands/global.ts
+init_cjs_shims();
+var fs19 = __toESM(require("fs/promises"), 1);
+var os2 = __toESM(require("os"), 1);
+var path12 = __toESM(require("path"), 1);
+init_graphStore();
+
+// src/merge.ts
+init_cjs_shims();
+var import_graphology4 = __toESM(require("graphology"), 1);
+var CONFIDENCE_RANK3 = { EXTRACTED: 3, INFERRED: 2, AMBIGUOUS: 1 };
+function strongerConfidence2(a, b) {
+  return CONFIDENCE_RANK3[a] >= CONFIDENCE_RANK3[b] ? a : b;
+}
+function isShared(id) {
+  return id.startsWith("external:") || id.startsWith("module:");
+}
+function namespaced(project, id) {
+  return isShared(id) ? id : `${project}/${id}`;
+}
+function mergeGraphs(entries) {
+  const names = entries.map((e) => e.name);
+  const duplicate = names.find((name, i) => names.indexOf(name) !== i);
+  if (duplicate !== void 0) {
+    throw new Error(`Duplicate project name in merge: "${duplicate}" \u2014 every entry needs a unique name.`);
+  }
+  const merged = new import_graphology4.default({ type: "directed", multi: true, allowSelfLoops: true });
+  const sorted = [...entries].sort((a, b) => a.name.localeCompare(b.name));
+  for (const { name, graph } of sorted) {
+    const nodeIds = [...graph.nodes()].sort((a, b) => a.localeCompare(b));
+    for (const id of nodeIds) {
+      const attrs = graph.getNodeAttributes(id);
+      const newId = namespaced(name, id);
+      if (merged.hasNode(newId)) {
+        merged.setNodeAttribute(newId, "project", "(shared)");
+        continue;
+      }
+      const sourceFile = attrs.sourceFile ?? "";
+      merged.addNode(newId, {
+        label: attrs.label ?? id,
+        sourceFile: isShared(id) || sourceFile === "" ? sourceFile : `${name}/${sourceFile}`,
+        sourceLocation: attrs.sourceLocation ?? "",
+        project: name
+      });
+    }
+    const edgeKeys = [...graph.edges()].sort((a, b) => a.localeCompare(b));
+    for (const edgeKey of edgeKeys) {
+      const attrs = graph.getEdgeAttributes(edgeKey);
+      const source = namespaced(name, graph.source(edgeKey));
+      const target = namespaced(name, graph.target(edgeKey));
+      const relation = String(attrs.relation);
+      const confidence = attrs.confidence;
+      const key = `${source}|${relation}|${target}`;
+      if (merged.hasEdge(key)) {
+        const existing = merged.getEdgeAttribute(key, "confidence");
+        merged.setEdgeAttribute(key, "confidence", strongerConfidence2(existing, confidence));
+        continue;
+      }
+      merged.addEdgeWithKey(key, source, target, { relation, confidence });
+    }
+  }
+  return merged;
+}
+
+// src/cli/commands/global.ts
+function registryDir() {
+  return path12.join(os2.homedir(), ".graphify");
+}
+function registryPath() {
+  return path12.join(registryDir(), "global.json");
+}
+async function readRegistry() {
+  try {
+    const raw = await fs19.readFile(registryPath(), "utf-8");
+    const parsed = JSON.parse(raw);
+    const projects = parsed.projects;
+    if (!Array.isArray(projects)) return { projects: [] };
+    return { projects: projects.filter((p) => typeof p?.name === "string" && typeof p?.root === "string") };
+  } catch {
+    return { projects: [] };
+  }
+}
+async function writeRegistry(registry) {
+  await fs19.mkdir(registryDir(), { recursive: true });
+  await fs19.writeFile(registryPath(), JSON.stringify(registry, null, 2), "utf-8");
+}
+async function projectNameFor(root) {
+  try {
+    const raw = await fs19.readFile(path12.join(root, "package.json"), "utf-8");
+    const name = JSON.parse(raw).name;
+    if (typeof name === "string" && name.length > 0) return name;
+  } catch {
+  }
+  return path12.basename(root);
+}
+async function runGlobalAdd(target = ".") {
+  const root = path12.resolve(target);
+  const graphJson = path12.join(root, "graphify-out", "graph.json");
+  try {
+    await fs19.access(graphJson);
+  } catch {
+    throw new Error(`${root} has no graphify-out/graph.json \u2014 run \`graphify ${target}\` first, then add it.`);
+  }
+  const name = await projectNameFor(root);
+  const registry = await readRegistry();
+  const existing = registry.projects.find((p) => p.name === name);
+  if (existing) {
+    if (existing.root === root) {
+      console.log(`${name} is already registered (${root}).`);
+      return;
+    }
+    throw new Error(
+      `A different project is already registered as "${name}" (${existing.root}). Remove it first with \`graphify global remove\`.`
+    );
+  }
+  registry.projects.push({ name, root });
+  registry.projects.sort((a, b) => a.name.localeCompare(b.name));
+  await writeRegistry(registry);
+  console.log(`Registered ${name} (${root}). ${registry.projects.length} project(s) in the global graph.`);
+}
+async function runGlobalRemove(name) {
+  const registry = await readRegistry();
+  const before = registry.projects.length;
+  registry.projects = registry.projects.filter((p) => p.name !== name);
+  if (registry.projects.length === before) {
+    throw new Error(`No project named "${name}" is registered. See \`graphify global list\`.`);
+  }
+  await writeRegistry(registry);
+  console.log(`Removed ${name}. ${registry.projects.length} project(s) remain.`);
+}
+async function runGlobalList() {
+  const registry = await readRegistry();
+  if (registry.projects.length === 0) {
+    console.log("No projects registered. Add one with `graphify global add <path>`.");
+    return;
+  }
+  for (const project of registry.projects) {
+    console.log(`${project.name}  ${project.root}`);
+  }
+}
+async function loadEntries(sources) {
+  const entries = [];
+  for (const source of sources) {
+    try {
+      entries.push({ name: source.name, graph: await loadGraph(source.outDir) });
+    } catch (error) {
+      console.warn(`Skipping ${source.name}: ${error.message}`);
+    }
+  }
+  return entries;
+}
+async function mergeAndExport(entries, outDir) {
+  if (entries.length === 0) {
+    throw new Error("Nothing to merge \u2014 no project graphs could be loaded.");
+  }
+  const merged = mergeGraphs(entries);
+  cluster(merged);
+  const analysis = analyze(merged);
+  const report = renderReport(merged, analysis);
+  await exportGraph(merged, { outDir }, report);
+  console.log(
+    `Merged ${entries.length} project(s) into ${outDir} \u2014 ${merged.order} node(s), ${merged.size} edge(s).`
+  );
+}
+async function runGlobalBuild(options = {}) {
+  const registry = await readRegistry();
+  if (registry.projects.length === 0) {
+    throw new Error("No projects registered. Add some with `graphify global add <path>` first.");
+  }
+  const entries = await loadEntries(
+    registry.projects.map((p) => ({ name: p.name, outDir: path12.join(p.root, "graphify-out") }))
+  );
+  await mergeAndExport(entries, path12.resolve(options.out ?? path12.join(registryDir(), "global-out")));
+}
+async function runMerge(targets, options = {}) {
+  if (targets.length < 2) {
+    throw new Error("Provide at least two project directories to merge.");
+  }
+  const sources = [];
+  for (const target of targets) {
+    const root = path12.resolve(target);
+    sources.push({ name: await projectNameFor(root), outDir: path12.join(root, "graphify-out") });
+  }
+  const names = sources.map((s) => s.name);
+  const duplicate = names.find((name, i) => names.indexOf(name) !== i);
+  if (duplicate !== void 0) {
+    throw new Error(`Two of the given projects resolve to the same name ("${duplicate}") \u2014 rename one.`);
+  }
+  const entries = await loadEntries(sources);
+  await mergeAndExport(entries, path12.resolve(options.out ?? "graphify-merged"));
+}
+
+// src/cli/commands/hook.ts
+init_cjs_shims();
+var fs20 = __toESM(require("fs/promises"), 1);
+var path13 = __toESM(require("path"), 1);
+var MARKER_BEGIN = "# >>> graphify >>>";
+var MARKER_END = "# <<< graphify <<<";
+var HOOK_NAMES = ["post-commit", "post-merge"];
+var HOOK_BLOCK = `${MARKER_BEGIN}
+# Rebuild the graphify knowledge graph in the background so the hook never
+# slows down the commit. Errors are silenced \u2014 a failed rebuild should never
+# break a git operation. Installed by \`graphify hook install\`.
+(graphify . --update --no-viz >/dev/null 2>&1 &)
+${MARKER_END}`;
+async function hooksDir(cwd) {
+  const gitDir = path13.join(cwd, ".git");
+  let stats;
+  try {
+    stats = await fs20.stat(gitDir);
+  } catch {
+    throw new Error(`${cwd} is not a git repository (no .git directory) \u2014 run this from the repo root.`);
+  }
+  if (!stats.isDirectory()) {
+    const content = (await fs20.readFile(gitDir, "utf-8")).trim();
+    const match = /^gitdir:\s*(.+)$/.exec(content);
+    if (!match) throw new Error(`${gitDir} exists but is neither a directory nor a gitdir pointer.`);
+    return path13.resolve(cwd, match[1], "hooks");
+  }
+  return path13.join(gitDir, "hooks");
+}
+async function runHookInstall(cwd = process.cwd()) {
+  const dir = await hooksDir(cwd);
+  await fs20.mkdir(dir, { recursive: true });
+  const results = [];
+  for (const hook of HOOK_NAMES) {
+    const hookPath = path13.join(dir, hook);
+    let existing = null;
+    try {
+      existing = await fs20.readFile(hookPath, "utf-8");
+    } catch {
+    }
+    if (existing === null) {
+      await fs20.writeFile(hookPath, `#!/bin/sh
+${HOOK_BLOCK}
+`, { mode: 493 });
+      results.push({ hook, path: hookPath, action: "created" });
+    } else if (existing.includes(MARKER_BEGIN)) {
+      results.push({ hook, path: hookPath, action: "already-installed" });
+    } else {
+      const separator = existing.endsWith("\n") ? "" : "\n";
+      await fs20.writeFile(hookPath, `${existing}${separator}${HOOK_BLOCK}
+`, "utf-8");
+      await fs20.chmod(hookPath, 493);
+      results.push({ hook, path: hookPath, action: "appended" });
+    }
+  }
+  for (const result of results) {
+    console.log(`${result.hook}: ${result.action} (${result.path})`);
+  }
+  console.log("");
+  console.log("The graph will rebuild in the background after each commit and pull.");
+  console.log("Remove with `graphify hook uninstall`.");
+  return results;
+}
+async function runHookUninstall(cwd = process.cwd()) {
+  const dir = await hooksDir(cwd);
+  const results = [];
+  for (const hook of HOOK_NAMES) {
+    const hookPath = path13.join(dir, hook);
+    let existing = null;
+    try {
+      existing = await fs20.readFile(hookPath, "utf-8");
+    } catch {
+    }
+    if (existing === null || !existing.includes(MARKER_BEGIN)) {
+      results.push({ hook, path: hookPath, action: "not-installed" });
+      continue;
+    }
+    const blockPattern = new RegExp(`\\n?${MARKER_BEGIN}[\\s\\S]*?${MARKER_END}\\n?`);
+    const remaining = existing.replace(blockPattern, "\n").trim();
+    if (remaining === "" || remaining === "#!/bin/sh") {
+      await fs20.unlink(hookPath);
+    } else {
+      await fs20.writeFile(hookPath, `${remaining}
+`, "utf-8");
+    }
+    results.push({ hook, path: hookPath, action: "removed" });
+  }
+  for (const result of results) {
+    console.log(`${result.hook}: ${result.action}`);
+  }
+  return results;
+}
+
+// src/memory.ts
+init_cjs_shims();
+var import_node_crypto4 = require("crypto");
+var fs21 = __toESM(require("fs/promises"), 1);
+var path14 = __toESM(require("path"), 1);
+var OUTCOMES = /* @__PURE__ */ new Set(["useful", "dead_end", "corrected"]);
+var TYPES = /* @__PURE__ */ new Set(["query", "path", "explain", "affected"]);
+function validateResult(value) {
+  if (!value.question) throw new Error("save-result requires --question");
+  if (!value.answer) throw new Error("save-result requires --answer");
+  if (!OUTCOMES.has(value.outcome)) {
+    throw new Error(`--outcome must be one of: useful, dead_end, corrected (got "${value.outcome}")`);
+  }
+  if (!TYPES.has(value.type)) {
+    throw new Error(`--type must be one of: query, path, explain, affected (got "${value.type}")`);
+  }
+  if (value.outcome === "corrected" && !value.correction) {
+    throw new Error("--outcome corrected requires --correction with what the right answer was");
+  }
+}
+async function saveResult(entry, memoryDir, now = /* @__PURE__ */ new Date()) {
+  validateResult(entry);
+  await fs21.mkdir(memoryDir, { recursive: true });
+  const saved = { ...entry, savedAt: now.toISOString() };
+  const hash = (0, import_node_crypto4.createHash)("sha256").update(JSON.stringify(saved)).digest("hex").slice(0, 8);
+  const stamp = saved.savedAt.replace(/[:.]/g, "-");
+  const filePath = path14.join(memoryDir, `result-${stamp}-${hash}.json`);
+  await fs21.writeFile(filePath, JSON.stringify(saved, null, 2), "utf-8");
+  return filePath;
+}
+async function loadResults(memoryDir) {
+  let files;
+  try {
+    files = (await fs21.readdir(memoryDir)).filter((f) => f.startsWith("result-") && f.endsWith(".json"));
+  } catch {
+    return [];
+  }
+  const results = [];
+  for (const file of files.sort((a, b) => a.localeCompare(b))) {
+    try {
+      const parsed = JSON.parse(await fs21.readFile(path14.join(memoryDir, file), "utf-8"));
+      if (parsed.question && parsed.savedAt) results.push(parsed);
+    } catch {
+    }
+  }
+  return results;
+}
+function renderLessons(results, options = {}) {
+  const halfLife = options.halfLifeDays ?? 30;
+  const now = options.now ?? /* @__PURE__ */ new Date();
+  const minCorroboration = options.minCorroboration ?? 2;
+  const weightOf = (savedAt) => {
+    const ageDays = Math.max(0, (now.getTime() - new Date(savedAt).getTime()) / 864e5);
+    return Math.pow(0.5, ageDays / halfLife);
+  };
+  const signals = /* @__PURE__ */ new Map();
+  const corrections = [];
+  for (const result of results) {
+    const weight = weightOf(result.savedAt);
+    for (const node of result.nodes ?? []) {
+      const signal = signals.get(node) ?? { useful: 0, deadEnd: 0, usefulCount: 0, deadEndCount: 0 };
+      if (result.outcome === "useful") {
+        signal.useful += weight;
+        signal.usefulCount++;
+      } else if (result.outcome === "dead_end") {
+        signal.deadEnd += weight;
+        signal.deadEndCount++;
+      }
+      signals.set(node, signal);
+    }
+    if (result.outcome === "corrected" && result.correction) {
+      corrections.push({ question: result.question, correction: result.correction, savedAt: result.savedAt });
+    }
+  }
+  const byScore = (kind) => [...signals.entries()].filter(([, s]) => kind === "useful" ? s.usefulCount >= minCorroboration : s.deadEndCount > 0).sort((a, b) => b[1][kind] - a[1][kind] || a[0].localeCompare(b[0])).slice(0, 10);
+  const lines = [
+    "# Graph lessons",
+    "",
+    `_Aggregated from ${results.length} saved result(s); signal half-life ${halfLife} day(s)._`,
+    "",
+    "## Nodes that keep answering",
+    ""
+  ];
+  const useful = byScore("useful");
+  if (useful.length === 0) {
+    lines.push(`(none yet with >= ${minCorroboration} corroborating results \u2014 keep saving results)`);
+  } else {
+    for (const [node, s] of useful) {
+      lines.push(`- **${node}** \u2014 score ${s.useful.toFixed(2)} across ${s.usefulCount} useful result(s)`);
+    }
+  }
+  lines.push("", "## Dead ends", "");
+  const deadEnds = byScore("deadEnd");
+  if (deadEnds.length === 0) {
+    lines.push("(none recorded)");
+  } else {
+    for (const [node, s] of deadEnds) {
+      lines.push(`- **${node}** \u2014 score ${s.deadEnd.toFixed(2)} across ${s.deadEndCount} dead-end result(s)`);
+    }
+  }
+  lines.push("", "## Corrections", "");
+  if (corrections.length === 0) {
+    lines.push("(none recorded)");
+  } else {
+    corrections.sort((a, b) => b.savedAt.localeCompare(a.savedAt));
+    for (const c of corrections.slice(0, 20)) {
+      lines.push(`- (${c.savedAt.slice(0, 10)}) Q: ${c.question}`);
+      lines.push(`  Right answer: ${c.correction}`);
+    }
+  }
+  lines.push("");
+  return lines.join("\n");
+}
+
 // src/cli/commands/install.ts
 init_cjs_shims();
 var import_node_module3 = require("module");
-var fs12 = __toESM(require("fs/promises"), 1);
-var path8 = __toESM(require("path"), 1);
+var fs22 = __toESM(require("fs/promises"), 1);
+var path15 = __toESM(require("path"), 1);
 var require4 = (0, import_node_module3.createRequire)(importMetaUrl);
 function packageRoot() {
   const packageJsonPath = require4.resolve("@dreamtree-org/graphify/package.json");
-  return path8.dirname(packageJsonPath);
+  return path15.dirname(packageJsonPath);
+}
+var MD_MARKER_BEGIN = "<!-- >>> graphify >>> -->";
+var MD_MARKER_END = "<!-- <<< graphify <<< -->";
+async function writeOwnedFile(filePath, content) {
+  await fs22.mkdir(path15.dirname(filePath), { recursive: true });
+  await fs22.writeFile(filePath, content, "utf-8");
 }
-async function runInstall(cwd = process.cwd()) {
-  const sourcePath = path8.join(packageRoot(), "src", "skill", "SKILL.md");
-  const content = await fs12.readFile(sourcePath, "utf-8");
+async function upsertMarkedBlock(filePath, content) {
+  const block = `${MD_MARKER_BEGIN}
+${content.trim()}
+${MD_MARKER_END}`;
+  let existing = null;
+  try {
+    existing = await fs22.readFile(filePath, "utf-8");
+  } catch {
+  }
+  if (existing === null) {
+    await fs22.mkdir(path15.dirname(filePath), { recursive: true });
+    await fs22.writeFile(filePath, `${block}
+`, "utf-8");
+    return;
+  }
+  if (existing.includes(MD_MARKER_BEGIN)) {
+    const pattern = new RegExp(`${MD_MARKER_BEGIN}[\\s\\S]*?${MD_MARKER_END}`);
+    await fs22.writeFile(filePath, existing.replace(pattern, block), "utf-8");
+    return;
+  }
+  const separator = existing.endsWith("\n") ? "\n" : "\n\n";
+  await fs22.writeFile(filePath, `${existing}${separator}${block}
+`, "utf-8");
+}
+var PLATFORMS = {
+  claude: async (cwd, content) => {
+    const target = path15.join(cwd, ".claude", "skills", "graphify", "SKILL.md");
+    await writeOwnedFile(target, content);
+    return { host: "Claude Code", path: target };
+  },
+  cursor: async (cwd, content) => {
+    const target = path15.join(cwd, ".cursor", "rules", "graphify.mdc");
+    const body = content.replace(/^---[\s\S]*?---\n/, "");
+    await writeOwnedFile(
+      target,
+      `---
+description: Query the graphify knowledge graph for codebase structure questions
+alwaysApply: false
+---
+${body}`
+    );
+    return { host: "Cursor", path: target };
+  },
+  windsurf: async (cwd, content) => {
+    const target = path15.join(cwd, ".windsurf", "rules", "graphify.md");
+    await writeOwnedFile(target, content.replace(/^---[\s\S]*?---\n/, ""));
+    return { host: "Windsurf", path: target };
+  },
+  cline: async (cwd, content) => {
+    const target = path15.join(cwd, ".clinerules", "graphify.md");
+    await writeOwnedFile(target, content.replace(/^---[\s\S]*?---\n/, ""));
+    return { host: "Cline", path: target };
+  },
+  agents: async (cwd, content) => {
+    const target = path15.join(cwd, "AGENTS.md");
+    await upsertMarkedBlock(target, content.replace(/^---[\s\S]*?---\n/, ""));
+    return { host: "AGENTS.md agents (Codex, opencode, Amp, ...)", path: target };
+  },
+  gemini: async (cwd, content) => {
+    const target = path15.join(cwd, "GEMINI.md");
+    await upsertMarkedBlock(target, content.replace(/^---[\s\S]*?---\n/, ""));
+    return { host: "Gemini CLI", path: target };
+  }
+};
+var SUPPORTED_PLATFORMS = Object.keys(PLATFORMS).sort((a, b) => a.localeCompare(b));
+async function runInstall(platforms = ["claude"], cwd = process.cwd()) {
+  const sourcePath = path15.join(packageRoot(), "src", "skill", "SKILL.md");
+  const content = await fs22.readFile(sourcePath, "utf-8");
+  const requested = platforms.includes("all") ? SUPPORTED_PLATFORMS : platforms;
   const results = [];
-  const claudeCodeDir = path8.join(cwd, ".claude", "skills", "graphify");
-  await fs12.mkdir(claudeCodeDir, { recursive: true });
-  const claudeCodePath = path8.join(claudeCodeDir, "SKILL.md");
-  await fs12.writeFile(claudeCodePath, content, "utf-8");
-  results.push({ host: "Claude Code", path: claudeCodePath });
+  for (const platform of requested) {
+    const installer = PLATFORMS[platform];
+    if (!installer) {
+      throw new Error(
+        `Unknown platform "${platform}" \u2014 supported: ${SUPPORTED_PLATFORMS.join(", ")}, or "all".`
+      );
+    }
+    results.push(await installer(cwd, content));
+  }
   for (const result of results) {
-    console.log(`Installed graphify skill for ${result.host} -> ${result.path}`);
+    console.log(`Installed graphify for ${result.host} -> ${result.path}`);
   }
-  console.log("");
-  console.log(
-    "Other hosts (Cursor, etc.) are not implemented yet by `graphify install` \u2014 see ARCHITECTURE.md."
-  );
   return results;
 }
 
@@ -3096,7 +4802,7 @@ init_graphStore();
 init_query();
 async function runQuery(question, options = {}) {
   const graph = await loadGraph();
-  const result = queryGraph(graph, question, { dfs: options.dfs, budget: options.budget });
+  const result = queryGraph(graph, question, { dfs: options.dfs, tokenBudget: options.budget });
   if (result.seeds.length === 0) {
     console.log(
       `No nodes matched "${question}". Try different keywords, or run \`graphify explain <node>\` if you already know the name.`
@@ -3121,15 +4827,15 @@ async function runQuery(question, options = {}) {
 }
 
 // src/cli/index.ts
-var execFileAsync = (0, import_node_util.promisify)(import_node_child_process.execFile);
+var execFileAsync3 = (0, import_node_util3.promisify)(import_node_child_process3.execFile);
 function looksLikeGitUrl(value) {
   if (!/^https?:\/\//i.test(value)) return false;
   return /github\.com|gitlab\.com|bitbucket\.org/i.test(value) || value.endsWith(".git");
 }
 async function cloneRepo(url) {
   const validated = validateUrl(url);
-  const dest = await fs13.mkdtemp(path10.join(os.tmpdir(), "graphify-clone-"));
-  await execFileAsync("git", ["clone", "--depth", "1", validated, dest]);
+  const dest = await fs24.mkdtemp(path17.join(os3.tmpdir(), "graphify-clone-"));
+  await execFileAsync3("git", ["clone", "--depth", "1", validated, dest]);
   return dest;
 }
 function exportOptionsFrom(options) {
@@ -3142,7 +4848,7 @@ function clusterOptionsFrom(options) {
   };
 }
 async function runClusterOnly(root, options) {
-  const outDir = path10.join(root, "graphify-out");
+  const outDir = path17.join(root, "graphify-out");
   const graph = await loadGraph(outDir);
   cluster(graph, clusterOptionsFrom(options));
   const analysis = analyze(graph);
@@ -3173,12 +4879,12 @@ async function watchAndRebuild(root, runOnce) {
   });
 }
 var program = new import_commander.Command();
-program.name("graphify").description("Turn a folder of code/docs/papers into a queryable knowledge graph.").argument("[path]", "path to scan, or a GitHub URL", ".").option("--mode <mode>", "extraction mode (deep for richer INFERRED edges \u2014 reserved, no-op in v1)").option("--update", "incremental re-extract of changed files only (not implemented in v1 \u2014 runs full pipeline)").option("--watch", "rebuild on file change").option("--cluster-only", "rerun clustering on an existing graph").option("--leiden", "use Leiden instead of Louvain for community detection (v2 \u2014 better community quality)").option("--max-iterations <n>", "Leiden only: cap on outer iterations for very large graphs", Number).option("--no-viz", "skip graph.html").option("--svg", "also export graph.svg (not implemented in v1)").option("--graphml", "also export graph.graphml (not implemented in v1)").option("--neo4j", "generate graphify-out/cypher.txt for Neo4j (not implemented in v1)").option("--mcp", "start MCP stdio server instead of running the pipeline").action(async (targetArg, options) => {
+program.name("graphify").description("Turn a folder of code/docs/papers into a queryable knowledge graph.").argument("[path]", "path to scan, or a GitHub URL", ".").option("--mode <mode>", "extraction mode (deep for richer INFERRED edges \u2014 reserved, no-op in v1)").option("--update", "incremental rebuild \u2014 reuse cached extractions for unchanged files").option("--watch", "rebuild on file change").option("--cluster-only", "rerun clustering on an existing graph").option("--leiden", "use Leiden instead of Louvain for community detection (v2 \u2014 better community quality)").option("--max-iterations <n>", "Leiden only: cap on outer iterations for very large graphs", Number).option("--no-viz", "skip graph.html").option("--svg", "also export graph.svg (not implemented in v1)").option("--graphml", "also export graph.graphml (not implemented in v1)").option("--neo4j", "generate graphify-out/cypher.txt for Neo4j (not implemented in v1)").option("--mcp", "start MCP stdio server instead of running the pipeline").option("--mysql <dsn>", "also extract a MySQL schema (mysql://user:pass@host:port/db) into the graph").action(async (targetArg, options) => {
   try {
     if (options.mcp) {
-      const outDir = path10.resolve(targetArg === "." ? process.cwd() : targetArg, "graphify-out");
+      const outDir = path17.resolve(targetArg === "." ? process.cwd() : targetArg, "graphify-out");
       const { startServer: startServer2 } = await Promise.resolve().then(() => (init_server(), server_exports));
-      await startServer2(path10.join(outDir, "graph.json"));
+      await startServer2(path17.join(outDir, "graph.json"));
       return;
     }
     let root = targetArg;
@@ -3186,12 +4892,7 @@ program.name("graphify").description("Turn a folder of code/docs/papers into a q
       console.error(`Cloning ${targetArg} ...`);
       root = await cloneRepo(targetArg);
     }
-    root = path10.resolve(root);
-    if (options.update) {
-      console.error(
-        "--update (incremental re-extract) is not implemented yet in v1 \u2014 running the full pipeline instead."
-      );
-    }
+    root = path17.resolve(root);
     if (options.mode) {
       console.error(`--mode ${options.mode} is reserved for a future richer-INFERRED-edges pass \u2014 currently a no-op.`);
     }
@@ -3199,9 +4900,17 @@ program.name("graphify").description("Turn a folder of code/docs/papers into a q
       await runClusterOnly(root, options);
       return;
     }
+    let extraExtractions;
+    if (options.mysql) {
+      const { extractMysql: extractMysql2 } = await Promise.resolve().then(() => (init_mysql(), mysql_exports));
+      console.error(`Extracting MySQL schema from ${validateDsn(options.mysql).safeDisplay} ...`);
+      extraExtractions = [await extractMysql2(options.mysql)];
+    }
     const runOnce = () => runPipeline(root, {
       ...exportOptionsFrom(options),
       ...clusterOptionsFrom(options),
+      extraExtractions,
+      update: options.update,
       onProgress: (m) => console.error(m)
     });
     await runOnce();
@@ -3238,13 +4947,153 @@ program.command("explain <node>").description("plain-language explanation of a n
     process.exitCode = 1;
   }
 });
-program.command("install").description("install the skill files into the local agent(s)").action(async () => {
+program.command("affected <node>").description("reverse impact analysis \u2014 everything that (transitively) depends on a node").option("--depth <n>", "how many reverse hops to follow (default 3)", Number).option("--limit <n>", "cap on affected nodes reported (default 200)", Number).action(async (node, options) => {
+  try {
+    await runAffected(node, options);
+  } catch (error) {
+    console.error(`graphify affected: ${error.message}`);
+    process.exitCode = 1;
+  }
+});
+program.command("context <task>").description("token-budgeted working-set pack \u2014 the actual code for a task, in one call").option("--budget <tokens>", "approximate token cap for the pack (default 4000)", Number).action(async (task, options) => {
+  try {
+    await runContext(task, options);
+  } catch (error) {
+    console.error(`graphify context: ${error.message}`);
+    process.exitCode = 1;
+  }
+});
+program.command("tests [node]").description("structural test selection \u2014 the minimal test files worth running for a change").option("--changed [rev]", "select for the working-tree diff (optionally vs a revision) instead of a node").action(async (node, options) => {
+  try {
+    await runTests(node, options);
+  } catch (error) {
+    console.error(`graphify tests: ${error.message}`);
+    process.exitCode = 1;
+  }
+});
+program.command("review <base> [head]").description("structural review between two git revisions: added/removed/rewired symbols with blast radius + tests").action(async (base, head) => {
   try {
-    await runInstall();
+    await runReview(base, head);
+  } catch (error) {
+    console.error(`graphify review: ${error.message}`);
+    process.exitCode = 1;
+  }
+});
+program.command("check").description("check the graph against dependency rules (graphify.rules.json) \u2014 exits 1 on violations").option("--rules <file>", "rules file (default ./graphify.rules.json)").action(async (options) => {
+  try {
+    await runCheck(options);
+  } catch (error) {
+    console.error(`graphify check: ${error.message}`);
+    process.exitCode = 1;
+  }
+});
+program.command("benchmark [questions...]").description("measure token savings of graph answers vs reading the files they touch").action(async (questions) => {
+  try {
+    await runBenchmark(questions);
+  } catch (error) {
+    console.error(`graphify benchmark: ${error.message}`);
+    process.exitCode = 1;
+  }
+});
+program.command("install").description("install the skill/rules files into local agents (claude, cursor, windsurf, cline, agents, gemini, all)").option("--platform <names...>", "platform(s) to install for", ["claude"]).action(async (options) => {
+  try {
+    await runInstall(options.platform);
   } catch (error) {
     console.error(`graphify install: ${error.message}`);
     process.exitCode = 1;
   }
 });
+var globalCommand = program.command("global").description("manage the cross-project global graph (registry at ~/.graphify/global.json)");
+globalCommand.command("add [path]").description("register a project (must already have graphify-out/graph.json)").action(async (target) => {
+  try {
+    await runGlobalAdd(target);
+  } catch (error) {
+    console.error(`graphify global add: ${error.message}`);
+    process.exitCode = 1;
+  }
+});
+globalCommand.command("remove <name>").description("unregister a project by name").action(async (name) => {
+  try {
+    await runGlobalRemove(name);
+  } catch (error) {
+    console.error(`graphify global remove: ${error.message}`);
+    process.exitCode = 1;
+  }
+});
+globalCommand.command("list").description("list registered projects").action(async () => {
+  try {
+    await runGlobalList();
+  } catch (error) {
+    console.error(`graphify global list: ${error.message}`);
+    process.exitCode = 1;
+  }
+});
+globalCommand.command("build").description("merge every registered project into one global graph").option("--out <dir>", "output directory (default ~/.graphify/global-out)").action(async (options) => {
+  try {
+    await runGlobalBuild(options);
+  } catch (error) {
+    console.error(`graphify global build: ${error.message}`);
+    process.exitCode = 1;
+  }
+});
+program.command("merge <dirs...>").description("one-shot merge of two or more built project graphs into one").option("--out <dir>", "output directory (default ./graphify-merged)").action(async (dirs, options) => {
+  try {
+    await runMerge(dirs, options);
+  } catch (error) {
+    console.error(`graphify merge: ${error.message}`);
+    process.exitCode = 1;
+  }
+});
+program.command("save-result").description("save a Q&A result to graphify-out/memory/ for the graph feedback loop").requiredOption("--question <q>", "the question that was asked").requiredOption("--answer <a>", "the answer that was given").option("--nodes <ids...>", "node ids/labels cited in the answer", []).option("--type <t>", "query|path|explain|affected", "query").option("--outcome <o>", "useful|dead_end|corrected", "useful").option("--correction <text>", "what the right answer was (pairs with --outcome corrected)").action(async (options) => {
+  try {
+    const memoryDir = path17.join(process.cwd(), "graphify-out", "memory");
+    const file = await saveResult(
+      {
+        question: options.question,
+        answer: options.answer,
+        nodes: options.nodes,
+        type: options.type,
+        outcome: options.outcome,
+        correction: options.correction
+      },
+      memoryDir
+    );
+    console.log(`Saved -> ${file}`);
+  } catch (error) {
+    console.error(`graphify save-result: ${error.message}`);
+    process.exitCode = 1;
+  }
+});
+program.command("reflect").description("aggregate graphify-out/memory/ into a recency-weighted lessons doc").option("--half-life-days <n>", "a result loses half its weight every N days (default 30)", Number).option("--out <file>", "output path (default graphify-out/reflections/LESSONS.md)").action(async (options) => {
+  try {
+    const memoryDir = path17.join(process.cwd(), "graphify-out", "memory");
+    const results = await loadResults(memoryDir);
+    const lessons = renderLessons(results, { halfLifeDays: options.halfLifeDays });
+    const outPath = path17.resolve(options.out ?? path17.join(process.cwd(), "graphify-out", "reflections", "LESSONS.md"));
+    await fs24.mkdir(path17.dirname(outPath), { recursive: true });
+    await fs24.writeFile(outPath, lessons, "utf-8");
+    console.log(`Reflected ${results.length} result(s) -> ${outPath}`);
+  } catch (error) {
+    console.error(`graphify reflect: ${error.message}`);
+    process.exitCode = 1;
+  }
+});
+var hookCommand = program.command("hook").description("manage the git hooks that auto-rebuild the graph on commit/pull");
+hookCommand.command("install").description("install post-commit and post-merge hooks (preserves existing hook content)").action(async () => {
+  try {
+    await runHookInstall();
+  } catch (error) {
+    console.error(`graphify hook install: ${error.message}`);
+    process.exitCode = 1;
+  }
+});
+hookCommand.command("uninstall").description("remove the graphify block from the git hooks").action(async () => {
+  try {
+    await runHookUninstall();
+  } catch (error) {
+    console.error(`graphify hook uninstall: ${error.message}`);
+    process.exitCode = 1;
+  }
+});
 program.parseAsync(process.argv);
 //# sourceMappingURL=index.cjs.map