@jefuriiij/synthra 0.10.0 → 0.11.0

package/CHANGELOG.md

@@ -7,6 +7,24 @@ For older versions, see [GitHub Releases](https://github.com/jefuriiij/synthra/r
 
 ---
 
+## [0.11.0] — 2026-06-24
+
+### Added
+
+- **`graph_read` now shows which tests cover a symbol.** A symbol read appends a
+  `Tests (file-level): …` line listing the test files linked to the symbol's file
+  (via the graph's `tests` edges) — so after an edit you run the *right* test
+  instead of guessing or running the whole suite. Ordinary source files with no
+  linked test get a one-line "none linked" nudge.
+- **`blast_radius` is now symbol-aware.** A `file::symbol` target returns the
+  exact caller **symbols** that transitively call it (`name → file:line`), plus a
+  line naming the test files that guard the impact — the precise view you want
+  before a rename. A bare file target keeps the existing file-level dependent
+  list. (The `graph_read` "Used by (N)" footer remains the cheap always-on
+  direct-caller summary; this is the complete, transitive, on-demand one.)
+
+---
+
 ## [0.10.0] — 2026-06-20
 
 ### Added

package/dist/cli/index.js

@@ -18,7 +18,7 @@ var init_package = __esm({
   "package.json"() {
     package_default = {
       name: "@jefuriiij/synthra",
-      version: "0.10.0",
+      version: "0.11.0",
       publishConfig: {
         access: "public"
       },
@@ -4197,11 +4197,14 @@ var TOOLS = [
   },
   {
     name: "blast_radius",
-    description: "Given a file (or 'file::symbol' target), return all files that depend on it transitively via imports, tests, and call edges (callers). Use BEFORE editing a widely-used file to see what could break. Call edges are name-resolved (precise within a file, unique-name across files) and projected to file granularity.",
+    description: "See what could break before an edit. A bare file target returns all files that depend on it transitively via imports, tests, and call edges. A 'file::symbol' target returns the exact caller SYMBOLS that transitively call it (name \u2192 file:line) plus the test files guarding the impact \u2014 the precise rename-safety view. Call edges are name-resolved (precise within a file, unique-name across files).",
     inputSchema: {
       type: "object",
       properties: {
-        target: { type: "string", description: "File path or 'file::symbol' notation." },
+        target: {
+          type: "string",
+          description: "File path (file-level dependents) or 'file::symbol' (caller symbols)."
+        },
         depth: { type: "number", description: "Max hops to traverse. Default 3." }
       },
       required: ["target"]
@@ -4252,7 +4255,8 @@ function blastRadius(args, ctx) {
   const targetRaw = typeof args?.target === "string" ? args.target.trim() : "";
   const maxDepth = typeof args?.depth === "number" && args.depth > 0 ? Math.floor(args.depth) : 3;
   if (!targetRaw) return errorContent("blast_radius: 'target' (string) is required");
-  const filePath = targetRaw.split("::", 1)[0]?.trim() ?? targetRaw;
+  if (targetRaw.includes("::")) return blastRadiusSymbol(targetRaw, maxDepth, ctx);
+  const filePath = targetRaw;
   const root = ctx.graph.nodes.find((n) => n.kind === "file" && n.path === filePath);
   if (!root) return errorContent(`blast_radius: file not in graph: ${filePath}`);
   const fileIdBySymbol = /* @__PURE__ */ new Map();
@@ -4307,6 +4311,92 @@ _(no dependents \u2014 file is isolated)_`);
   }
   return textContent(lines.join("\n"));
 }
+function blastRadiusSymbol(targetRaw, maxDepth, ctx) {
+  const [rawFile, rawSym] = targetRaw.split("::", 2);
+  const filePath = (rawFile ?? "").trim();
+  const symName = (rawSym ?? "").trim();
+  if (!symName) return errorContent("blast_radius: 'file::symbol' target needs a symbol name");
+  const resolved = resolveFileTarget(ctx.graph, filePath);
+  if ("ambiguous" in resolved) {
+    const shown = resolved.ambiguous.slice(0, 5).join(", ");
+    return errorContent(
+      `blast_radius: '${filePath}' matches multiple files (${shown}). Pass a longer path.`
+    );
+  }
+  if ("none" in resolved) return errorContent(`blast_radius: file not in graph: ${filePath}`);
+  const fileNode = resolved.node;
+  const symbol = ctx.graph.nodes.find(
+    (n) => n.kind === "symbol" && n.file === fileNode.path && n.name === symName
+  );
+  if (!symbol)
+    return errorContent(`blast_radius: symbol '${symName}' not found in ${fileNode.path}`);
+  const callersBySym = /* @__PURE__ */ new Map();
+  for (const e of ctx.graph.edges) {
+    if (e.kind !== "calls" || e.from === e.to) continue;
+    const list = callersBySym.get(e.to) ?? [];
+    list.push(e.from);
+    callersBySym.set(e.to, list);
+  }
+  const symById = /* @__PURE__ */ new Map();
+  for (const n of ctx.graph.nodes) if (n.kind === "symbol") symById.set(n.id, n);
+  const visited = /* @__PURE__ */ new Set([symbol.id]);
+  const hits = [];
+  let frontier = [symbol.id];
+  for (let d = 1; d <= maxDepth; d++) {
+    const next = [];
+    for (const cur of frontier) {
+      for (const fromId of callersBySym.get(cur) ?? []) {
+        if (visited.has(fromId)) continue;
+        visited.add(fromId);
+        next.push(fromId);
+        const s = symById.get(fromId);
+        if (s) hits.push({ name: s.name, file: s.file, line: s.start_line, depth: d });
+      }
+    }
+    frontier = next;
+    if (next.length === 0) break;
+  }
+  const header = `# Blast radius for ${fileNode.path}::${symbol.name}  (callers, depth \u2264 ${maxDepth})`;
+  if (hits.length === 0) {
+    const tline2 = testsCoveringLine(ctx.graph, [fileNode.path]);
+    return textContent(
+      `${header}
+
+_(no callers \u2014 safe to rename)_${tline2 ? `
+
+${tline2}` : ""}`
+    );
+  }
+  hits.sort((a, b) => a.depth - b.depth || a.file.localeCompare(b.file) || a.line - b.line);
+  const lines = [header, "", `${hits.length} caller symbol(s):`];
+  for (const h of hits) lines.push(`- **depth ${h.depth}** \`${h.name}\` \u2192 ${h.file}:${h.line}`);
+  const tline = testsCoveringLine(ctx.graph, [fileNode.path, ...hits.map((h) => h.file)]);
+  if (tline) {
+    lines.push("");
+    lines.push(tline);
+  }
+  return textContent(lines.join("\n"));
+}
+function testsCoveringLine(graph, filePaths) {
+  const fileByPath = /* @__PURE__ */ new Map();
+  for (const n of graph.nodes) if (n.kind === "file") fileByPath.set(n.path, n);
+  const seen = /* @__PURE__ */ new Set();
+  const tests = [];
+  for (const p of new Set(filePaths)) {
+    const fn = fileByPath.get(p);
+    if (!fn) continue;
+    for (const t of findTestsForFile(graph, fn)) {
+      if (!seen.has(t.path)) {
+        seen.add(t.path);
+        tests.push(t.path);
+      }
+    }
+  }
+  if (tests.length === 0) return "";
+  const shown = tests.slice(0, TESTS_MAX_FILES);
+  const omitted = tests.length - shown.length;
+  return `Tests covering the impact: ${shown.join(" \xB7 ")}${omitted > 0 ? ` \u2026+${omitted} more` : ""}`;
+}
 var LIKELY_ENTRY_PATTERNS = [
   /(?:^|\/)main\.[a-z0-9_]+$/i,
   /(?:^|\/)index\.[a-z0-9_]+$/i,
@@ -4384,6 +4474,7 @@ function resolveFileTarget(graph, filePath) {
 var DEPS_SIG_MAX = 140;
 var DEPS_MAX_CALLEES = 10;
 var DEPS_MAX_CALLERS = 12;
+var TESTS_MAX_FILES = 6;
 function buildDepsFooter(symbol, graph, maxChars = loadConfig().readDepsMaxChars) {
   const symById = /* @__PURE__ */ new Map();
   for (const n of graph.nodes) if (n.kind === "symbol") symById.set(n.id, n);
@@ -4447,6 +4538,21 @@ function buildDepsFooter(symbol, graph, maxChars = loadConfig().readDepsMaxChars
   }
   return lines.join("\n");
 }
+function buildTestsFooter(symbol, graph) {
+  const fileNode = graph.nodes.find(
+    (n) => n.kind === "file" && n.path === symbol.file
+  );
+  if (!fileNode) return "";
+  const tests = findTestsForFile(graph, fileNode);
+  if (tests.length > 0) {
+    const shown = tests.slice(0, TESTS_MAX_FILES).map((t) => t.path);
+    const omitted = tests.length - shown.length;
+    const more = omitted > 0 ? ` \u2026+${omitted} more` : "";
+    return `Tests (file-level): ${shown.join(" \xB7 ")}${more}  \u2014 run after editing`;
+  }
+  if (isLikelyEntry(symbol.file)) return "";
+  return "Tests: none linked to this file.";
+}
 async function graphRead(args, ctx) {
   const target = typeof args?.target === "string" ? args.target : "";
   if (!target) return errorContent("graph_read: 'target' (string) is required");
@@ -4490,10 +4596,15 @@ ${fileNode.content}`);
 
 ---
 ${deps}` : "";
+  const tests = buildTestsFooter(symbol, ctx.graph);
+  const testsBlock = tests ? `
+
+---
+${tests}` : "";
   return textContent(
     `# ${fileNode.path}::${symbol.name}  (L${symbol.start_line}-${symbol.end_line})
 
-${body}${depsBlock}${editHint}`
+${body}${depsBlock}${testsBlock}${editHint}`
   );
 }
 var editedFiles = /* @__PURE__ */ new Set();