@jefuriiij/synthra 0.12.0 → 0.13.0

package/dist/server/index.js

@@ -3153,6 +3153,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) {
@@ -3179,6 +3192,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}`);
   }
@@ -3335,6 +3350,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,
@@ -3900,11 +4006,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 mkdir9, readFile as readFile13, writeFile as writeFile8 } from "fs/promises";
 import { dirname as dirname10 } from "path";
-var SESSION_SCHEMA_VERSION = 1;
+var SESSION_SCHEMA_VERSION = 2;
 async function readSession(path) {
   try {
     const raw = await readFile13(path, "utf8");
@@ -3933,6 +4079,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(),
@@ -3943,7 +4090,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);
 }
@@ -4391,6 +4539,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}.
@@ -4401,7 +4577,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];
@@ -4422,7 +4598,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)) {
@@ -4449,7 +4625,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}
 
 ---