@jefuriiij/synthra 0.12.0 → 0.13.0

package/CHANGELOG.md

@@ -7,6 +7,26 @@ For older versions, see [GitHub Releases](https://github.com/jefuriiij/synthra/r
 
 ---
 
+## [0.13.0] — 2026-06-24
+
+### Added
+
+- **The resume digest now lists the symbols that changed since your last session.**
+  The SessionStart "Since you were last here" primer showed *files* touched; it now
+  leads its supporting context with the actual **symbols/signatures** that changed —
+  e.g. `src/auth.ts::login (function) — function login(creds: Creds): Promise<...>`.
+  Computed from a git diff against the previous session's HEAD (committed **and**
+  uncommitted changes), overlapped with the current graph. Best-effort: silently
+  omitted in non-git projects.
+- **`call_path(from, to)` — trace control flow.** Returns the shortest chain of
+  calls from one symbol to another (`handler → service → repo`), so you can see how
+  one symbol reaches another. The forward complement to `blast_radius` (callers).
+  Each of `from`/`to` is a `file::symbol` target or a bare symbol name when unique.
+
+Both reuse the existing call graph + git — no graph schema change, no new dependencies.
+
+---
+
 ## [0.12.0] — 2026-06-24
 
 ### Added

package/dist/cli/index.js

@@ -18,7 +18,7 @@ var init_package = __esm({
   "package.json"() {
     package_default = {
       name: "@jefuriiij/synthra",
-      version: "0.12.0",
+      version: "0.13.0",
       publishConfig: {
         access: "public"
       },
@@ -4244,6 +4244,19 @@ var TOOLS = [
         limit: { type: "number", description: "Cap on returned names. Default 30." }
       }
     }
+  },
+  {
+    name: "call_path",
+    description: "Trace how one symbol reaches another through the call graph \u2014 the shortest chain of calls from 'from' to 'to'. Use to understand control flow ('how does this handler end up hitting the DB layer?'). Each of 'from'/'to' is a 'file::symbol' target or a bare symbol name when unique.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        from: { type: "string", description: "Starting symbol ('file::symbol' or unique name)." },
+        to: { type: "string", description: "Target symbol ('file::symbol' or unique name)." },
+        depth: { type: "number", description: "Max call hops to search. Default 6." }
+      },
+      required: ["from", "to"]
+    }
   }
 ];
 async function callTool(name, args, ctx) {
@@ -4270,6 +4283,8 @@ async function callTool(name, args, ctx) {
       return findSymbol(args, ctx);
     case "duplicate_symbols":
       return duplicateSymbols(args, ctx);
+    case "call_path":
+      return callPath(args, ctx);
     default:
       return errorContent(`Unknown tool: ${name}`);
   }
@@ -4426,6 +4441,97 @@ function testsCoveringLine(graph, filePaths) {
   const omitted = tests.length - shown.length;
   return `Tests covering the impact: ${shown.join(" \xB7 ")}${omitted > 0 ? ` \u2026+${omitted} more` : ""}`;
 }
+function resolveSymbolArg(ctx, arg) {
+  const a = arg.trim();
+  if (a.includes("::")) {
+    const [rawFile, rawSym] = a.split("::", 2);
+    const resolved = resolveFileTarget(ctx.graph, (rawFile ?? "").trim());
+    if (!("node" in resolved)) return null;
+    const name = (rawSym ?? "").trim();
+    return ctx.graph.nodes.find(
+      (n) => n.kind === "symbol" && n.file === resolved.node.path && n.name === name
+    ) ?? null;
+  }
+  const matches = ctx.graph.nodes.filter(
+    (n) => n.kind === "symbol" && n.name === a
+  );
+  return matches.length === 1 ? matches[0] : null;
+}
+function callPath(args, ctx) {
+  const fromArg = typeof args?.from === "string" ? args.from : "";
+  const toArg = typeof args?.to === "string" ? args.to : "";
+  const maxDepth = typeof args?.depth === "number" && args.depth > 0 ? Math.floor(args.depth) : 6;
+  if (!fromArg.trim() || !toArg.trim()) {
+    return errorContent("call_path: 'from' and 'to' (strings) are required");
+  }
+  const from = resolveSymbolArg(ctx, fromArg);
+  if (!from) {
+    return errorContent(
+      `call_path: could not resolve 'from': ${fromArg} (use file::symbol if the name is ambiguous)`
+    );
+  }
+  const to = resolveSymbolArg(ctx, toArg);
+  if (!to) {
+    return errorContent(
+      `call_path: could not resolve 'to': ${toArg} (use file::symbol if the name is ambiguous)`
+    );
+  }
+  if (from.id === to.id) {
+    return textContent(`# call_path
+
+\`${from.name}\` and \`${to.name}\` are the same symbol.`);
+  }
+  const calleesBy = /* @__PURE__ */ new Map();
+  for (const e of ctx.graph.edges) {
+    if (e.kind !== "calls" || e.from === e.to) continue;
+    (calleesBy.get(e.from) ?? calleesBy.set(e.from, []).get(e.from)).push(e.to);
+  }
+  const symById = /* @__PURE__ */ new Map();
+  for (const n of ctx.graph.nodes) if (n.kind === "symbol") symById.set(n.id, n);
+  const prevOf = /* @__PURE__ */ new Map();
+  const visited = /* @__PURE__ */ new Set([from.id]);
+  let frontier = [from.id];
+  let found = false;
+  for (let d = 0; d < maxDepth && !found && frontier.length > 0; d++) {
+    const next = [];
+    for (const cur2 of frontier) {
+      for (const nb of calleesBy.get(cur2) ?? []) {
+        if (visited.has(nb)) continue;
+        visited.add(nb);
+        prevOf.set(nb, cur2);
+        if (nb === to.id) {
+          found = true;
+          break;
+        }
+        next.push(nb);
+      }
+      if (found) break;
+    }
+    frontier = next;
+  }
+  if (!found) {
+    return textContent(
+      `# call_path: ${from.name} \u2192 ${to.name}
+
+_(no call path found within depth ${maxDepth})_`
+    );
+  }
+  const chain = [];
+  let cur = to.id;
+  while (cur !== void 0) {
+    chain.unshift(cur);
+    if (cur === from.id) break;
+    cur = prevOf.get(cur);
+  }
+  const syms = chain.map((id) => symById.get(id)).filter((s) => !!s);
+  const hops = syms.length - 1;
+  const rendered = syms.map((s) => `\`${s.name}\` (${s.file}:${s.start_line})`).join("\n  \u2192 ");
+  return textContent(
+    `# call_path: ${from.name} \u2192 ${to.name}  (${hops} hop${hops === 1 ? "" : "s"})
+
+${rendered}`
+  );
+}
 var LIKELY_ENTRY_PATTERNS = [
   /(?:^|\/)main\.[a-z0-9_]+$/i,
   /(?:^|\/)index\.[a-z0-9_]+$/i,
@@ -4972,11 +5078,51 @@ async function getCommitsSince(projectRoot, sinceIso) {
     return [];
   }
 }
+async function getHeadSha(projectRoot) {
+  try {
+    const { stdout } = await execFileAsync3("git", ["rev-parse", "HEAD"], { cwd: projectRoot });
+    return stdout.trim();
+  } catch {
+    return "";
+  }
+}
+function parseDiffHunks(stdout) {
+  const out = /* @__PURE__ */ new Map();
+  let current = null;
+  for (const line of stdout.split("\n")) {
+    if (line.startsWith("+++ ")) {
+      const p = line.slice(4).trim();
+      current = p === "/dev/null" ? null : p.replace(/^b\//, "");
+    } else if (current && line.startsWith("@@")) {
+      const m = /\+(\d+)(?:,(\d+))?/.exec(line);
+      if (!m) continue;
+      const start = Number(m[1]);
+      const count = m[2] === void 0 ? 1 : Number(m[2]);
+      const end = count === 0 ? start : start + count - 1;
+      const list = out.get(current) ?? [];
+      list.push([start, end]);
+      out.set(current, list);
+    }
+  }
+  return out;
+}
+async function getChangedLineRanges(projectRoot, sinceRef) {
+  if (!sinceRef) return /* @__PURE__ */ new Map();
+  try {
+    const { stdout } = await execFileAsync3("git", ["diff", "-U0", "--no-color", sinceRef, "--"], {
+      cwd: projectRoot,
+      maxBuffer: 16 * 1024 * 1024
+    });
+    return parseDiffHunks(stdout);
+  } catch {
+    return /* @__PURE__ */ new Map();
+  }
+}
 
 // src/memory/session.ts
 import { mkdir as mkdir11, readFile as readFile17, writeFile as writeFile10 } from "fs/promises";
 import { dirname as dirname13 } from "path";
-var SESSION_SCHEMA_VERSION = 1;
+var SESSION_SCHEMA_VERSION = 2;
 async function readSession(path) {
   try {
     const raw = await readFile17(path, "utf8");
@@ -5005,6 +5151,7 @@ async function captureSnapshot(ctx, branchOverride) {
   for (const p of ctx.activity.recentFilePaths(TOUCHED_WINDOW_MS)) touched.add(p);
   const prev = await readSession(ctx.paths.sessionState);
   const recentCommits = await getCommitsSince(ctx.paths.projectRoot, prev?.endedAt ?? "");
+  const headSha = await getHeadSha(ctx.paths.projectRoot);
   const snapshot = {
     schema_version: SESSION_SCHEMA_VERSION,
     endedAt: (/* @__PURE__ */ new Date()).toISOString(),
@@ -5015,7 +5162,8 @@ async function captureSnapshot(ctx, branchOverride) {
       tasks: tasks.entries.map((e) => e.content),
       decisions: decisions.entries.map((e) => e.content),
       next: next.entries.map((e) => e.content)
-    }
+    },
+    headSha
   };
   await writeSession(ctx.paths.sessionState, snapshot);
 }
@@ -5463,6 +5611,34 @@ var RESUME_PRIMER_MAX_CHARS = 2720;
 var MAX_FILES = 15;
 var MAX_COMMITS2 = 5;
 var MAX_BULLETS2 = 3;
+var MAX_CHANGED_SYMBOLS = 20;
+var CHANGED_SIG_MAX = 100;
+function changedSymbols(ranges, graph) {
+  if (ranges.size === 0) return [];
+  const hits = [];
+  for (const n of graph.nodes) {
+    if (n.kind !== "symbol") continue;
+    const rs = ranges.get(n.file);
+    if (!rs) continue;
+    if (rs.some(([a, b]) => a <= n.end_line && b >= n.start_line)) hits.push(n);
+  }
+  hits.sort((a, b) => a.file === b.file ? a.start_line - b.start_line : a.file < b.file ? -1 : 1);
+  return hits;
+}
+function changedSymbolsSection(ranges, graph) {
+  const hits = changedSymbols(ranges, graph);
+  if (hits.length === 0) return [];
+  const shown = hits.slice(0, MAX_CHANGED_SYMBOLS);
+  const lines = ["", "### Changed symbols (since last session)"];
+  for (const s of shown) {
+    lines.push(
+      `- \`${s.file}::${s.name}\` (${s.symbol_kind}) \u2014 ${s.signature.trim().slice(0, CHANGED_SIG_MAX)}`
+    );
+  }
+  const more = hits.length - shown.length;
+  if (more > 0) lines.push(`_(+${more} more)_`);
+  return lines;
+}
 function legacyPrimer(ctx) {
   const g = ctx.graph;
   return `Synthra context loaded for ${g.root}.
@@ -5473,7 +5649,7 @@ function hasContent(snap) {
     snap.recentCommits.length || snap.filesTouched.length || snap.summary.tasks.length || snap.summary.next.length || snap.summary.decisions.length
   );
 }
-function buildResumeDigest(snap, branchNow) {
+function buildResumeDigest(snap, branchNow, changedSymbolLines = []) {
   const plural = (n) => n === 1 ? "" : "s";
   const head = `## Since you were last here \u2014 ${snap.branch}  (${snap.recentCommits.length} commit${plural(snap.recentCommits.length)}, ${snap.filesTouched.length} file${plural(snap.filesTouched.length)} touched)`;
   const essential = [head];
@@ -5494,7 +5670,7 @@ function buildResumeDigest(snap, branchNow) {
     essential.push("", "### Recent decisions");
     for (const d of snap.summary.decisions.slice(0, MAX_BULLETS2)) essential.push(`- ${d}`);
   }
-  const extra = [];
+  const extra = [...changedSymbolLines];
   if (snap.recentCommits.length) {
     extra.push("", "### Recent commits");
     for (const c of snap.recentCommits.slice(0, MAX_COMMITS2)) {
@@ -5521,7 +5697,12 @@ async function handlePrime(ctx, port) {
     return { primer: legacy, port };
   }
   const branchNow = await currentBranch(ctx.paths.projectRoot);
-  const digest = buildResumeDigest(snap, branchNow);
+  let changedSymbolLines = [];
+  if (snap.headSha) {
+    const ranges = await getChangedLineRanges(ctx.paths.projectRoot, snap.headSha);
+    changedSymbolLines = changedSymbolsSection(ranges, ctx.graph);
+  }
+  const digest = buildResumeDigest(snap, branchNow, changedSymbolLines);
   return { primer: `${digest}
 
 ---