@dreamtree-org/graphify 1.0.0 → 1.1.1

package/dist/mcp/server.cjs

@@ -35,57 +35,12 @@ __export(server_exports, {
   startServer: () => startServer
 });
 module.exports = __toCommonJS(server_exports);
+var fs3 = __toESM(require("fs/promises"), 1);
 var path2 = __toESM(require("path"), 1);
 var import_mcp = require("@modelcontextprotocol/sdk/server/mcp.js");
 var import_stdio = require("@modelcontextprotocol/sdk/server/stdio.js");
 var import_zod = require("zod");
 
-// src/graphStore.ts
-var fs2 = __toESM(require("fs/promises"), 1);
-var path = __toESM(require("path"), 1);
-var import_graphology = __toESM(require("graphology"), 1);
-
-// src/security.ts
-var import_node_crypto = require("crypto");
-var dns = __toESM(require("dns"), 1);
-var http = __toESM(require("http"), 1);
-var https = __toESM(require("https"), 1);
-var fs = __toESM(require("fs"), 1);
-var net = __toESM(require("net"), 1);
-var nodePath = __toESM(require("path"), 1);
-var MAX_FETCH_BYTES = 50 * 1024 * 1024;
-var MAX_TEXT_BYTES = 10 * 1024 * 1024;
-function validateGraphPath(path3, base) {
-  const baseDir = base ?? nodePath.join(process.cwd(), "graphify-out");
-  let resolvedBase;
-  try {
-    resolvedBase = fs.realpathSync(baseDir);
-  } catch {
-    throw new Error(`Base directory does not exist: ${baseDir}`);
-  }
-  const candidate = nodePath.isAbsolute(path3) ? path3 : nodePath.join(resolvedBase, path3);
-  const resolvedCandidate = nodePath.resolve(candidate);
-  let realCandidate = resolvedCandidate;
-  try {
-    realCandidate = fs.realpathSync(resolvedCandidate);
-  } catch {
-  }
-  const relative2 = nodePath.relative(resolvedBase, realCandidate);
-  const escapes = relative2 === ".." || relative2.startsWith(`..${nodePath.sep}`) || nodePath.isAbsolute(relative2);
-  if (escapes) {
-    throw new Error(`Path escapes graphify-out/: ${path3}`);
-  }
-  return realCandidate;
-}
-
-// src/graphStore.ts
-async function loadGraph(outDir = path.join(process.cwd(), "graphify-out")) {
-  const jsonPath = validateGraphPath("graph.json", outDir);
-  const raw = await fs2.readFile(jsonPath, "utf-8");
-  const data = JSON.parse(raw);
-  return import_graphology.default.from(data);
-}
-
 // src/query.ts
 var STOPWORDS = /* @__PURE__ */ new Set([
   "a",
@@ -118,8 +73,48 @@ var STOPWORDS = /* @__PURE__ */ new Set([
   "does",
   "that's"
 ]);
+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);
+}
+var FUZZY_MIN_TOKEN_LEN = 3;
+var FUZZY_THRESHOLD = 0.7;
+var SUBTOKEN_MATCH_SCORE = 1;
+var SUBSTRING_MATCH_SCORE = 0.6;
+var FUZZY_MATCH_WEIGHT = 0.5;
+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);
@@ -127,9 +122,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 });
   });
@@ -143,22 +154,36 @@ function resolveNode(graph, query) {
 var DEFAULT_MAX_DEPTH = 2;
 var DEFAULT_MAX_SEEDS = 5;
 var DEFAULT_BUDGET = 40;
+var DEFAULT_TOKEN_BUDGET = 2e3;
+var NODES_PER_TOKEN = 1 / 10;
+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 });
     }
   }
@@ -186,7 +211,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);
@@ -257,6 +305,292 @@ function explainNode(graph, query) {
   };
 }
 
+// src/context.ts
+var DEFAULT_CONTEXT_BUDGET = 4e3;
+var DEFAULT_MAX_SEEDS2 = 8;
+var DEFAULT_MAX_SNIPPET_LINES = 60;
+var NEIGHBOR_DECAY = 0.4;
+var tokensOf = (text) => Math.ceil(text.length / 4);
+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, readFile3, 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 readFile3(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 = tokensOf(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");
+}
+
+// src/graphStore.ts
+var fs2 = __toESM(require("fs/promises"), 1);
+var path = __toESM(require("path"), 1);
+var import_graphology = __toESM(require("graphology"), 1);
+
+// src/security.ts
+var import_node_crypto = require("crypto");
+var dns = __toESM(require("dns"), 1);
+var http = __toESM(require("http"), 1);
+var https = __toESM(require("https"), 1);
+var fs = __toESM(require("fs"), 1);
+var net = __toESM(require("net"), 1);
+var nodePath = __toESM(require("path"), 1);
+var MAX_FETCH_BYTES = 50 * 1024 * 1024;
+var MAX_TEXT_BYTES = 10 * 1024 * 1024;
+function validateGraphPath(path3, base) {
+  const baseDir = base ?? nodePath.join(process.cwd(), "graphify-out");
+  let resolvedBase;
+  try {
+    resolvedBase = fs.realpathSync(baseDir);
+  } catch {
+    throw new Error(`Base directory does not exist: ${baseDir}`);
+  }
+  const candidate = nodePath.isAbsolute(path3) ? path3 : nodePath.join(resolvedBase, path3);
+  const resolvedCandidate = nodePath.resolve(candidate);
+  let realCandidate = resolvedCandidate;
+  try {
+    realCandidate = fs.realpathSync(resolvedCandidate);
+  } catch {
+  }
+  const relative2 = nodePath.relative(resolvedBase, realCandidate);
+  const escapes = relative2 === ".." || relative2.startsWith(`..${nodePath.sep}`) || nodePath.isAbsolute(relative2);
+  if (escapes) {
+    throw new Error(`Path escapes graphify-out/: ${path3}`);
+  }
+  return realCandidate;
+}
+
+// src/graphStore.ts
+async function loadGraph(outDir = path.join(process.cwd(), "graphify-out")) {
+  const jsonPath = validateGraphPath("graph.json", outDir);
+  const raw = await fs2.readFile(jsonPath, "utf-8");
+  const data = JSON.parse(raw);
+  return import_graphology.default.from(data);
+}
+
+// src/impact.ts
+var DEPENDENCY_RELATIONS = /* @__PURE__ */ new Set([
+  "calls",
+  "imports",
+  "imports_from",
+  "inherits",
+  "implements",
+  "mixes_in",
+  "embeds",
+  "references",
+  "re_exports",
+  "method",
+  "contains"
+]);
+var DEFAULT_IMPACT_DEPTH = 3;
+var DEFAULT_IMPACT_LIMIT = 200;
+var CONFIDENCE_RANK = { EXTRACTED: 3, INFERRED: 2, AMBIGUOUS: 1 };
+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_RANK[existing.via.confidence] >= CONFIDENCE_RANK[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 };
+}
+
+// src/testmap.ts
+var 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$/
+];
+function isTestFile(path3) {
+  return TEST_FILE_PATTERNS.some((p) => p.test(path3));
+}
+var TEST_REACH_DEPTH = 4;
+var TEST_REACH_LIMIT = 2e3;
+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);
+}
+
 // src/mcp/server.ts
 function textResult(text) {
   return { content: [{ type: "text", text }] };
@@ -270,12 +604,13 @@ function createGraphifyMcpServer(outDir) {
       inputSchema: {
         question: import_zod.z.string().describe("Natural-language question or keywords to search the graph for."),
         dfs: import_zod.z.boolean().optional().describe("Use depth-first traversal instead of the default breadth-first."),
-        budget: import_zod.z.number().int().positive().optional().describe("Approximate cap on how many nodes to include.")
+        budget: import_zod.z.number().int().positive().optional().describe("Hard cap on how many nodes to include."),
+        tokenBudget: import_zod.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));
     }
   );
@@ -314,6 +649,59 @@ 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_zod.z.string().describe("Name/label (or id) of the node being changed."),
+        depth: import_zod.z.number().int().positive().optional().describe("How many reverse hops to follow (default 3)."),
+        limit: import_zod.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_zod.z.string().describe("What you are about to do, in natural language."),
+        budget: import_zod.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) => fs3.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_zod.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()) {