@jefuriiij/synthra 0.2.0 → 0.3.0

package/dist/server/index.js

@@ -1,7 +1,7 @@
 // src/server/http.ts
 import { serve } from "@hono/node-server";
 import { Hono } from "hono";
-import { writeFile as writeFile8 } from "fs/promises";
+import { writeFile as writeFile9 } from "fs/promises";
 
 // src/activity/activity-log.ts
 import { appendFile, mkdir } from "fs/promises";
@@ -274,7 +274,7 @@ import { resolve } from "path";
 import { dirname as dirname2, join as join3, posix } from "path";
 
 // src/graph/types.ts
-var SCHEMA_VERSION = 1;
+var SCHEMA_VERSION = 2;
 
 // src/scanner/hash.ts
 import { createHash } from "crypto";
@@ -592,14 +592,20 @@ async function buildGraph(root, parsed) {
   for (const p of parsed) filesByPath.set(p.file.relPath, true);
   const nodes = [];
   const edges = [];
+  const symbolsByFile = /* @__PURE__ */ new Map();
+  const callsByFile = /* @__PURE__ */ new Map();
   for (const p of parsed) {
     const fileNode = toFileNode(p);
     nodes.push(fileNode);
+    const fileSymNodes = [];
     for (const sym of p.symbols) {
       const symNode = toSymbolNode(p, sym);
       nodes.push(symNode);
+      fileSymNodes.push(symNode);
       edges.push({ from: fileNode.id, to: symNode.id, kind: "defines" });
     }
+    symbolsByFile.set(p.file.relPath, fileSymNodes);
+    callsByFile.set(p.file.relPath, p.calls);
     const importEdges = /* @__PURE__ */ new Set();
     for (const spec of p.imports) {
       const target = resolveImport(p.file.relPath, spec, filesByPath);
@@ -614,6 +620,7 @@ async function buildGraph(root, parsed) {
       edges.push({ from: fileNode.id, to: fileId(testTargetPath), kind: "tests" });
     }
   }
+  edges.push(...buildCallEdges(symbolsByFile, callsByFile));
   const symbolCount = nodes.filter((n) => n.kind === "symbol").length;
   const fileCount = nodes.length - symbolCount;
   return {
@@ -637,6 +644,49 @@ function buildSymbolIndex(graph) {
   }
   return out;
 }
+function tightestContainer(syms, line) {
+  let best = null;
+  for (const s of syms) {
+    if (line < s.start_line || line > s.end_line) continue;
+    if (!best || s.end_line - s.start_line < best.end_line - best.start_line) best = s;
+  }
+  return best;
+}
+function buildCallEdges(symbolsByFile, callsByFile) {
+  const byName = /* @__PURE__ */ new Map();
+  for (const syms of symbolsByFile.values()) {
+    for (const s of syms) {
+      const list = byName.get(s.name);
+      if (list) list.push(s);
+      else byName.set(s.name, [s]);
+    }
+  }
+  const edges = [];
+  const seen = /* @__PURE__ */ new Set();
+  for (const [relPath, sites] of callsByFile) {
+    const fileSyms = symbolsByFile.get(relPath) ?? [];
+    for (const site of sites) {
+      const caller = tightestContainer(fileSyms, site.line);
+      if (!caller) continue;
+      let callee = fileSyms.find((s) => s.name === site.callee);
+      if (!callee) {
+        const cands = byName.get(site.callee) ?? [];
+        if (cands.length !== 1) continue;
+        callee = cands[0];
+      }
+      if (!callee || callee.id === caller.id) continue;
+      const key = `${caller.id}->${callee.id}`;
+      if (seen.has(key)) continue;
+      seen.add(key);
+      edges.push({ from: caller.id, to: callee.id, kind: "calls" });
+    }
+  }
+  return edges;
+}
+
+// src/scanner/parse-cache.ts
+import { mkdir as mkdir2, readFile as readFile4, writeFile } from "fs/promises";
+import { dirname as dirname3 } from "path";
 
 // src/scanner/parser.ts
 import { readFile as readFile3 } from "fs/promises";
@@ -655,10 +705,11 @@ function cleanImport(s) {
 async function runGenericParser(config, f, source) {
   let symbols = [];
   let imports = [];
+  const calls = [];
   try {
     const { parser, language } = await createParser(config.grammar);
     const tree = parser.parse(source);
-    if (!tree) return { file: f, source, symbols, imports, calls: [] };
+    if (!tree) return { file: f, source, symbols, imports, calls };
     const query = new Query(language, config.query);
     const matches = query.matches(tree.rootNode);
     for (const match of matches) {
@@ -683,6 +734,14 @@ async function runGenericParser(config, f, source) {
         });
         continue;
       }
+      if (config.callCapture && config.callCalleeCapture) {
+        const callNode = byName.get(config.callCapture);
+        const calleeNode = byName.get(config.callCalleeCapture);
+        if (callNode && calleeNode) {
+          calls.push({ callee: calleeNode.text, line: callNode.startPosition.row + 1 });
+          continue;
+        }
+      }
       if (config.importCapture) {
         const imp = byName.get(config.importCapture);
         if (imp) imports.push(cleanImport(imp.text));
@@ -698,7 +757,7 @@ async function runGenericParser(config, f, source) {
     imports = Array.from(new Set(imports)).filter((s) => s.length > 0);
   } catch {
   }
-  return { file: f, source, symbols, imports, calls: [] };
+  return { file: f, source, symbols, imports, calls };
 }
 
 // src/scanner/parsers/c.ts
@@ -709,6 +768,7 @@ var QUERY = `
 (type_definition declarator: (type_identifier) @type.name) @type
 (preproc_include path: (string_literal) @import)
 (preproc_include path: (system_lib_string) @import)
+(call_expression function: (identifier) @call.name) @call
 `;
 async function parseC(f, source) {
   return runGenericParser(
@@ -721,7 +781,9 @@ async function parseC(f, source) {
         { declCapture: "enum", nameCapture: "enum.name", kind: "enum" },
         { declCapture: "type", nameCapture: "type.name", kind: "type" }
       ],
-      importCapture: "import"
+      importCapture: "import",
+      callCapture: "call",
+      callCalleeCapture: "call.name"
     },
     f,
     source
@@ -738,6 +800,9 @@ var QUERY2 = `
 (namespace_definition name: (namespace_identifier) @namespace.name) @namespace
 (preproc_include path: (string_literal) @import)
 (preproc_include path: (system_lib_string) @import)
+(call_expression function: (identifier) @call.name) @call
+(call_expression function: (field_expression field: (field_identifier) @call.name)) @call
+(call_expression function: (qualified_identifier name: (identifier) @call.name)) @call
 `;
 async function parseCpp(f, source) {
   return runGenericParser(
@@ -752,7 +817,9 @@ async function parseCpp(f, source) {
         { declCapture: "enum", nameCapture: "enum.name", kind: "enum" },
         { declCapture: "namespace", nameCapture: "namespace.name", kind: "class" }
       ],
-      importCapture: "import"
+      importCapture: "import",
+      callCapture: "call",
+      callCalleeCapture: "call.name"
     },
     f,
     source
@@ -768,6 +835,8 @@ var QUERY3 = `
 (method_declaration name: (identifier) @method.name) @method
 (namespace_declaration name: (_) @namespace.name) @namespace
 (using_directive (_) @import)
+(invocation_expression function: (identifier) @call.name) @call
+(invocation_expression function: (member_access_expression name: (identifier) @call.name)) @call
 `;
 async function parseCSharp(f, source) {
   return runGenericParser(
@@ -782,7 +851,9 @@ async function parseCSharp(f, source) {
         { declCapture: "method", nameCapture: "method.name", kind: "method" },
         { declCapture: "namespace", nameCapture: "namespace.name", kind: "class" }
       ],
-      importCapture: "import"
+      importCapture: "import",
+      callCapture: "call",
+      callCalleeCapture: "call.name"
     },
     f,
     source
@@ -887,6 +958,8 @@ var QUERY5 = `
 (method_declaration name: (field_identifier) @method.name) @method
 (type_spec name: (type_identifier) @type.name) @type
 (import_spec path: (interpreted_string_literal) @import)
+(call_expression function: (identifier) @call.name) @call
+(call_expression function: (selector_expression field: (field_identifier) @call.name)) @call
 `;
 async function parseGo(f, source) {
   return runGenericParser(
@@ -898,7 +971,9 @@ async function parseGo(f, source) {
         { declCapture: "method", nameCapture: "method.name", kind: "method" },
         { declCapture: "type", nameCapture: "type.name", kind: "type" }
       ],
-      importCapture: "import"
+      importCapture: "import",
+      callCapture: "call",
+      callCalleeCapture: "call.name"
     },
     f,
     source
@@ -963,6 +1038,7 @@ var QUERY6 = `
 (method_declaration name: (identifier) @method.name) @method
 (enum_declaration name: (identifier) @enum.name) @enum
 (import_declaration (scoped_identifier) @import)
+(method_invocation name: (identifier) @call.name) @call
 `;
 async function parseJava(f, source) {
   return runGenericParser(
@@ -975,7 +1051,9 @@ async function parseJava(f, source) {
         { declCapture: "method", nameCapture: "method.name", kind: "method" },
         { declCapture: "enum", nameCapture: "enum.name", kind: "enum" }
       ],
-      importCapture: "import"
+      importCapture: "import",
+      callCapture: "call",
+      callCalleeCapture: "call.name"
     },
     f,
     source
@@ -988,6 +1066,7 @@ var QUERY7 = `
 (class_declaration (type_identifier) @class.name) @class
 (object_declaration (type_identifier) @object.name) @object
 (import_header (identifier) @import)
+(call_expression (simple_identifier) @call.name) @call
 `;
 async function parseKotlin(f, source) {
   return runGenericParser(
@@ -999,7 +1078,9 @@ async function parseKotlin(f, source) {
         { declCapture: "class", nameCapture: "class.name", kind: "class" },
         { declCapture: "object", nameCapture: "object.name", kind: "class" }
       ],
-      importCapture: "import"
+      importCapture: "import",
+      callCapture: "call",
+      callCalleeCapture: "call.name"
     },
     f,
     source
@@ -1013,6 +1094,9 @@ var QUERY8 = `
 (interface_declaration name: (name) @interface.name) @interface
 (trait_declaration name: (name) @trait.name) @trait
 (method_declaration name: (name) @method.name) @method
+(function_call_expression function: (name) @call.name) @call
+(member_call_expression name: (name) @call.name) @call
+(scoped_call_expression name: (name) @call.name) @call
 `;
 async function parsePhp(f, source) {
   return runGenericParser(
@@ -1025,7 +1109,9 @@ async function parsePhp(f, source) {
         { declCapture: "interface", nameCapture: "interface.name", kind: "interface" },
         { declCapture: "trait", nameCapture: "trait.name", kind: "class" },
         { declCapture: "method", nameCapture: "method.name", kind: "method" }
-      ]
+      ],
+      callCapture: "call",
+      callCalleeCapture: "call.name"
     },
     f,
     source
@@ -1040,6 +1126,8 @@ var QUERY9 = `
 (import_statement name: (dotted_name) @import.module)
 (import_from_statement module_name: (dotted_name) @import.from)
 (import_from_statement module_name: (relative_import) @import.from)
+(call function: (identifier) @call.name) @call
+(call function: (attribute attribute: (identifier) @call.name)) @call
 `;
 function firstLine3(text, max = 200) {
   const line = text.split(/\r?\n/, 1)[0] ?? "";
@@ -1048,10 +1136,11 @@ function firstLine3(text, max = 200) {
 async function parsePython(f, source) {
   let symbols = [];
   let imports = [];
+  const calls = [];
   try {
     const { parser, language } = await createParser("python");
     const tree = parser.parse(source);
-    if (!tree) return { file: f, source, symbols, imports, calls: [] };
+    if (!tree) return { file: f, source, symbols, imports, calls };
     const query = new Query3(language, QUERY9);
     const matches = query.matches(tree.rootNode);
     for (const match of matches) {
@@ -1084,7 +1173,15 @@ async function parsePython(f, source) {
         continue;
       }
       const importNode = byName.get("import.module") ?? byName.get("import.from");
-      if (importNode) imports.push(importNode.text);
+      if (importNode) {
+        imports.push(importNode.text);
+        continue;
+      }
+      const callName = byName.get("call.name");
+      const callNode = byName.get("call");
+      if (callName && callNode) {
+        calls.push({ callee: callName.text, line: callNode.startPosition.row + 1 });
+      }
     }
     const seen = /* @__PURE__ */ new Set();
     symbols = symbols.filter((s) => {
@@ -1096,7 +1193,7 @@ async function parsePython(f, source) {
     imports = Array.from(new Set(imports));
   } catch {
   }
-  return { file: f, source, symbols, imports, calls: [] };
+  return { file: f, source, symbols, imports, calls };
 }
 
 // src/scanner/parsers/ruby.ts
@@ -1105,6 +1202,7 @@ var QUERY10 = `
 (singleton_method name: (identifier) @method.name) @method
 (class name: (constant) @class.name) @class
 (module name: (constant) @module.name) @module
+(call method: (identifier) @call.name) @call
 `;
 async function parseRuby(f, source) {
   return runGenericParser(
@@ -1116,7 +1214,9 @@ async function parseRuby(f, source) {
         { declCapture: "method", nameCapture: "method.name", kind: "method" },
         { declCapture: "class", nameCapture: "class.name", kind: "class" },
         { declCapture: "module", nameCapture: "module.name", kind: "class" }
-      ]
+      ],
+      callCapture: "call",
+      callCalleeCapture: "call.name"
     },
     f,
     source
@@ -1130,6 +1230,9 @@ var QUERY11 = `
 (enum_item name: (type_identifier) @enum.name) @enum
 (trait_item name: (type_identifier) @trait.name) @trait
 (impl_item type: (type_identifier) @impl.name) @impl
+(call_expression function: (identifier) @call.name) @call
+(call_expression function: (scoped_identifier name: (identifier) @call.name)) @call
+(call_expression function: (field_expression field: (field_identifier) @call.name)) @call
 `;
 async function parseRust(f, source) {
   return runGenericParser(
@@ -1142,7 +1245,9 @@ async function parseRust(f, source) {
         { declCapture: "enum", nameCapture: "enum.name", kind: "enum" },
         { declCapture: "trait", nameCapture: "trait.name", kind: "interface" },
         { declCapture: "impl", nameCapture: "impl.name", kind: "class" }
-      ]
+      ],
+      callCapture: "call",
+      callCalleeCapture: "call.name"
     },
     f,
     source
@@ -1161,6 +1266,8 @@ var TS_QUERY = `
 (lexical_declaration (variable_declarator name: (identifier) @const-fn.name value: [(arrow_function) (function_expression)])) @const-fn
 (assignment_expression left: (member_expression property: (property_identifier) @member-fn.name) right: [(arrow_function) (function_expression)]) @member-fn
 (import_statement source: (string) @import)
+(call_expression function: (identifier) @call.name) @call
+(call_expression function: (member_expression property: (property_identifier) @call.name)) @call
 `;
 var JS_QUERY = `
 (function_declaration name: (identifier) @function.name) @function
@@ -1170,6 +1277,8 @@ var JS_QUERY = `
 (assignment_expression left: (member_expression property: (property_identifier) @member-fn.name) right: [(arrow_function) (function_expression)]) @member-fn
 (import_statement source: (string) @import)
 (call_expression function: (identifier) @_require_fn arguments: (arguments . (string) @require_source))
+(call_expression function: (identifier) @call.name) @call
+(call_expression function: (member_expression property: (property_identifier) @call.name)) @call
 `;
 function grammarFor(ext) {
   if (ext === ".tsx" || ext === ".jsx") return "tsx";
@@ -1198,10 +1307,11 @@ async function parseTypeScript(f, source) {
   const grammar = grammarFor(f.ext);
   let symbols = [];
   let imports = [];
+  const calls = [];
   try {
     const { parser, language } = await createParser(grammar);
     const tree = parser.parse(source);
-    if (!tree) return { file: f, source, symbols, imports, calls: [] };
+    if (!tree) return { file: f, source, symbols, imports, calls };
     const query = new Query4(language, queryFor(grammar));
     const matches = query.matches(tree.rootNode);
     for (const match of matches) {
@@ -1227,6 +1337,12 @@ async function parseTypeScript(f, source) {
       const requireSource = byName.get("require_source");
       if (requireFn && requireSource && requireFn.text === "require") {
         imports.push(unquote(requireSource.text));
+        continue;
+      }
+      const callName = byName.get("call.name");
+      const callNode = byName.get("call");
+      if (callName && callNode) {
+        calls.push({ callee: callName.text, line: callNode.startPosition.row + 1 });
       }
     }
     const seen = /* @__PURE__ */ new Set();
@@ -1239,7 +1355,7 @@ async function parseTypeScript(f, source) {
     imports = Array.from(new Set(imports));
   } catch {
   }
-  return { file: f, source, symbols, imports, calls: [] };
+  return { file: f, source, symbols, imports, calls };
 }
 
 // src/scanner/parsers/svelte.ts
@@ -1273,6 +1389,7 @@ async function parseSvelte(f, source) {
       });
     }
     for (const imp of parsed.imports) out.imports.push(imp);
+    for (const call of parsed.calls) out.calls.push({ ...call, line: call.line + offset });
   }
   out.symbols.push({
     name: f.relPath.split("/").pop()?.replace(/\.svelte$/i, "") ?? f.relPath,
@@ -1316,6 +1433,7 @@ async function parseVue(f, source) {
       });
     }
     for (const imp of parsed.imports) out.imports.push(imp);
+    for (const call of parsed.calls) out.calls.push({ ...call, line: call.line + offset });
   }
   out.symbols.push({
     name: f.relPath.split("/").pop()?.replace(/\.vue$/i, "") ?? f.relPath,
@@ -1372,13 +1490,7 @@ async function createParser(name) {
 function emptyParsed(file, source) {
   return { file, source, symbols: [], imports: [], calls: [] };
 }
-async function parseFile(f) {
-  let source;
-  try {
-    source = await readFile3(f.absPath, "utf8");
-  } catch {
-    return emptyParsed(f, "");
-  }
+async function parseSource(f, source) {
   switch (f.ext) {
     case ".ts":
     case ".tsx":
@@ -1431,8 +1543,72 @@ async function parseFile(f) {
   }
 }
 
+// src/scanner/parse-cache.ts
+var PARSE_CACHE_VERSION = 2;
+function emptyParseCache() {
+  return { schema_version: PARSE_CACHE_VERSION, files: {} };
+}
+async function readParseCache(path) {
+  try {
+    const raw = await readFile4(path, "utf8");
+    const parsed = JSON.parse(raw);
+    if (parsed.schema_version !== PARSE_CACHE_VERSION || typeof parsed.files !== "object" || parsed.files === null) {
+      return emptyParseCache();
+    }
+    return { schema_version: PARSE_CACHE_VERSION, files: parsed.files };
+  } catch {
+    return emptyParseCache();
+  }
+}
+async function writeParseCache(path, cache) {
+  try {
+    await mkdir2(dirname3(path), { recursive: true });
+    await writeFile(path, `${JSON.stringify(cache)}
+`, "utf8");
+  } catch {
+  }
+}
+async function incrementalParse(parsable, prev, opts = {}) {
+  const cache = emptyParseCache();
+  const parsed = [];
+  let reused = 0;
+  let reparsed = 0;
+  let parseErrors = 0;
+  for (const f of parsable) {
+    let source;
+    try {
+      source = await readFile4(f.absPath, "utf8");
+    } catch {
+      continue;
+    }
+    const hash = fileHash(source);
+    const cached = opts.full ? void 0 : prev.files[f.relPath];
+    if (cached && cached.hash === hash) {
+      parsed.push({
+        file: f,
+        source,
+        symbols: cached.symbols,
+        imports: cached.imports,
+        calls: cached.calls
+      });
+      cache.files[f.relPath] = cached;
+      reused += 1;
+      continue;
+    }
+    try {
+      const p = await parseSource(f, source);
+      parsed.push(p);
+      cache.files[f.relPath] = { hash, symbols: p.symbols, imports: p.imports, calls: p.calls };
+      reparsed += 1;
+    } catch {
+      parseErrors += 1;
+    }
+  }
+  return { parsed, cache, reused, reparsed, parseErrors };
+}
+
 // src/scanner/walker.ts
-import { readFile as readFile4, readdir, stat } from "fs/promises";
+import { readFile as readFile5, readdir, stat } from "fs/promises";
 import { extname, join as join4, relative as relative2, sep as sep2 } from "path";
 import ignore2 from "ignore";
 var DEFAULT_IGNORE = [
@@ -1513,7 +1689,7 @@ var BINARY_EXTS = /* @__PURE__ */ new Set([
 ]);
 async function readIgnoreFile2(path) {
   try {
-    const text = await readFile4(path, "utf8");
+    const text = await readFile5(path, "utf8");
     return text.split(/\r?\n/).map((l) => l.trim()).filter((l) => l.length > 0 && !l.startsWith("#"));
   } catch {
     return [];
@@ -1568,15 +1744,15 @@ async function* walk(root, options = {}) {
 }
 
 // src/graph/store.ts
-import { mkdir as mkdir2, readFile as readFile5, writeFile } from "fs/promises";
-import { dirname as dirname3 } from "path";
+import { mkdir as mkdir3, readFile as readFile6, writeFile as writeFile2 } from "fs/promises";
+import { dirname as dirname4 } from "path";
 async function writeJson(path, data, pretty) {
-  await mkdir2(dirname3(path), { recursive: true });
+  await mkdir3(dirname4(path), { recursive: true });
   const text = pretty ? JSON.stringify(data, null, 2) : JSON.stringify(data);
-  await writeFile(path, text + "\n", "utf8");
+  await writeFile2(path, text + "\n", "utf8");
 }
 async function readJson(path) {
-  const text = await readFile5(path, "utf8");
+  const text = await readFile6(path, "utf8");
   return JSON.parse(text);
 }
 async function writeGraph(path, graph) {
@@ -1612,6 +1788,7 @@ function resolvePaths(projectRoot) {
     toolLog: join5(graphDir, "tool_log.jsonl"),
     accessLog: join5(graphDir, "access_log.jsonl"),
     learnStore: join5(graphDir, "learn_store.json"),
+    parseCache: join5(graphDir, "parse_cache.json"),
     mcpPort: join5(graphDir, "mcp_port"),
     mcpServerLog: join5(graphDir, "mcp_server.log"),
     mcpServerErrLog: join5(graphDir, "mcp_server.err.log"),
@@ -1627,12 +1804,12 @@ function resolvePaths(projectRoot) {
 }
 
 // src/cli/bootstrap.ts
-import { mkdir as mkdir3, readFile as readFile7, stat as stat2, writeFile as writeFile3 } from "fs/promises";
+import { mkdir as mkdir4, readFile as readFile8, stat as stat2, writeFile as writeFile4 } from "fs/promises";
 import { basename as basename2 } from "path";
 
 // src/hooks/claude-md.ts
-import { readFile as readFile6, writeFile as writeFile2 } from "fs/promises";
-import { basename, dirname as dirname4 } from "path";
+import { readFile as readFile7, writeFile as writeFile3 } from "fs/promises";
+import { basename, dirname as dirname5 } from "path";
 var POLICY_VERSION = 6;
 var POLICY_BEGIN = `<!-- synthra-policy v${POLICY_VERSION} BEGIN -->`;
 var POLICY_END = `<!-- synthra-policy v${POLICY_VERSION} END -->`;
@@ -1794,14 +1971,14 @@ function onboardingSkeleton(projectName) {
 async function patchClaudeMd(path, projectName) {
   let existing;
   try {
-    existing = await readFile6(path, "utf8");
+    existing = await readFile7(path, "utf8");
   } catch {
     existing = null;
   }
   const block = policyBlock();
   if (existing === null) {
-    const name = projectName || basename(dirname4(path)) || "this project";
-    await writeFile2(path, onboardingSkeleton(name) + "\n" + block + "\n", "utf8");
+    const name = projectName || basename(dirname5(path)) || "this project";
+    await writeFile3(path, onboardingSkeleton(name) + "\n" + block + "\n", "utf8");
     return { created: true, updated: false, skipped: false };
   }
   const stripped = existing.replace(ANY_BLOCK_RE, "");
@@ -1810,7 +1987,7 @@ async function patchClaudeMd(path, projectName) {
   if (hadBlock && desired === existing) {
     return { created: false, updated: false, skipped: true };
   }
-  await writeFile2(path, desired, "utf8");
+  await writeFile3(path, desired, "utf8");
   return { created: false, updated: true, skipped: false };
 }
 
@@ -1835,13 +2012,13 @@ async function exists(path) {
 }
 async function ensureDir(path) {
   const had = await exists(path);
-  await mkdir3(path, { recursive: true });
+  await mkdir4(path, { recursive: true });
   return !had;
 }
 async function patchGitignore(path) {
   let existing = "";
   try {
-    existing = await readFile7(path, "utf8");
+    existing = await readFile8(path, "utf8");
   } catch {
   }
   const trimmed = new Set(existing.split(/\r?\n/).map((l) => l.trim()));
@@ -1850,7 +2027,7 @@ async function patchGitignore(path) {
   const block = missing.map((m) => `# ${m.comment}
 ${m.entry}`).join("\n") + "\n";
   const appendix = (existing.length === 0 || existing.endsWith("\n") ? "" : "\n") + (existing.length ? "\n" : "") + block;
-  await writeFile3(path, existing + appendix, "utf8");
+  await writeFile4(path, existing + appendix, "utf8");
   return true;
 }
 async function bootstrap(paths) {
@@ -1924,25 +2101,22 @@ async function scanProject(projectRootRaw, opts = {}) {
   for await (const file of walk(projectRoot)) walked.push(file);
   if (verbose) log.info(`  walked ${walked.length} files`);
   const parsable = walked.filter((f) => PARSABLE_EXTS.has(f.ext));
-  const parsed = [];
-  let parseErrors = 0;
-  for (const file of parsable) {
-    try {
-      parsed.push(await parseFile(file));
-    } catch (err2) {
-      parseErrors += 1;
-      if (verbose) log.debug(`    parse failed: ${file.relPath} \u2014 ${err2.message}`);
-    }
-  }
+  const prevCache = await readParseCache(paths.parseCache);
+  const { parsed, cache, reused, reparsed, parseErrors } = await incrementalParse(
+    parsable,
+    prevCache,
+    { full: opts.full }
+  );
   if (verbose) {
     log.info(
-      `  parsed ${parsed.length} files (${walked.length - parsable.length} skipped` + (parseErrors ? `, ${parseErrors} errored` : "") + ")"
+      `  parsed ${parsed.length} files (${reused} reused \xB7 ${reparsed} reparsed` + (parseErrors ? `, ${parseErrors} errored` : "") + `; ${walked.length - parsable.length} non-code skipped)`
     );
   }
   const graph = await buildGraph(projectRoot, parsed);
   const symbolIndex = buildSymbolIndex(graph);
   await writeGraph(paths.infoGraph, graph);
   await writeSymbolIndex(paths.symbolIndex, symbolIndex);
+  await writeParseCache(paths.parseCache, cache);
   if (verbose) {
     log.info(
       `  wrote ${paths.infoGraph} \u2014 ${graph.symbol_count} symbols, ${graph.edge_count} edges`
@@ -1961,8 +2135,8 @@ async function scanProject(projectRootRaw, opts = {}) {
 }
 
 // src/learn/store.ts
-import { appendFile as appendFile2, mkdir as mkdir4, readFile as readFile8, writeFile as writeFile4 } from "fs/promises";
-import { dirname as dirname5 } from "path";
+import { appendFile as appendFile2, mkdir as mkdir5, readFile as readFile9, writeFile as writeFile5 } from "fs/promises";
+import { dirname as dirname6 } from "path";
 
 // src/learn/usage.ts
 var LEARN_SCHEMA_VERSION = 1;
@@ -2029,7 +2203,7 @@ function recomputeFromLog(events) {
 // src/learn/store.ts
 async function readLearnStore(path) {
   try {
-    const raw = await readFile8(path, "utf8");
+    const raw = await readFile9(path, "utf8");
     const parsed = JSON.parse(raw);
     if (parsed.schema_version !== LEARN_SCHEMA_VERSION || typeof parsed.files !== "object" || parsed.files === null) {
       return emptyStore();
@@ -2045,14 +2219,14 @@ async function readLearnStore(path) {
 }
 async function writeLearnStore(path, store) {
   try {
-    await mkdir4(dirname5(path), { recursive: true });
-    await writeFile4(path, JSON.stringify(store, null, 2) + "\n", "utf8");
+    await mkdir5(dirname6(path), { recursive: true });
+    await writeFile5(path, JSON.stringify(store, null, 2) + "\n", "utf8");
   } catch {
   }
 }
 async function readAccessLog(path) {
   try {
-    const raw = await readFile8(path, "utf8");
+    const raw = await readFile9(path, "utf8");
     const out = [];
     for (const line of raw.split("\n")) {
       const t = line.trim();
@@ -2072,7 +2246,7 @@ async function readAccessLog(path) {
 }
 async function appendAccess(path, ev) {
   try {
-    await mkdir4(dirname5(path), { recursive: true });
+    await mkdir5(dirname6(path), { recursive: true });
     await appendFile2(path, JSON.stringify(ev) + "\n", "utf8");
   } catch {
   }
@@ -2136,10 +2310,11 @@ var LearnRuntime = class _LearnRuntime {
 };
 
 // src/server/mcp.ts
-import { appendFile as appendFile3, mkdir as mkdir7 } from "fs/promises";
-import { dirname as dirname8 } from "path";
+import { appendFile as appendFile3, mkdir as mkdir8 } from "fs/promises";
+import { dirname as dirname9 } from "path";
 
 // src/graph/rank.ts
+var KW_BASE_WEIGHT = 2;
 var USAGE_BOOST_CAP_DEFAULT = 4;
 function usageBoostCap() {
   const env = Number(process.env.SYN_LEARN_BOOST_CAP);
@@ -2229,14 +2404,41 @@ function scoreFiles(inputs) {
   const importsFrom = indexImportEdges(inputs.graph);
   const seeds = new Set(inputs.sessionKnownPaths ?? []);
   for (const p of inputs.recentlyEditedPaths ?? []) seeds.add(p);
+  const corpusSize = inputs.candidates.length;
+  const queryDf = /* @__PURE__ */ new Map();
+  for (const f of inputs.candidates) {
+    for (const kw of f.keywords) {
+      if (qTokens.has(kw)) queryDf.set(kw, (queryDf.get(kw) ?? 0) + 1);
+    }
+  }
+  const idf = (token) => {
+    const n = queryDf.get(token) ?? 0;
+    if (n <= 0) return 0;
+    return Math.log(1 + (corpusSize - n + 0.5) / (n + 0.5));
+  };
+  let idfSum = 0;
+  let idfCount = 0;
+  for (const t of qTokens) {
+    const v = idf(t);
+    if (v > 0) {
+      idfSum += v;
+      idfCount += 1;
+    }
+  }
+  const refIdf = idfCount > 0 ? idfSum / idfCount : 1;
   const scored = [];
   for (const file of inputs.candidates) {
     const reasons = [];
     let score2 = 0;
     let kwHits = 0;
-    for (const kw of file.keywords) if (qTokens.has(kw)) kwHits += 1;
+    let kwScore = 0;
+    for (const kw of file.keywords) {
+      if (!qTokens.has(kw)) continue;
+      kwHits += 1;
+      kwScore += KW_BASE_WEIGHT * (idf(kw) / refIdf);
+    }
     if (kwHits) {
-      score2 += kwHits * 2;
+      score2 += kwScore;
       reasons.push(`kw=${kwHits}`);
     }
     const symbols = symbolsByFile.get(file.path) ?? [];
@@ -2362,14 +2564,14 @@ async function retrieve(graph, query, options = {}) {
 
 // src/memory/branches.ts
 import { execFile as execFile2 } from "child_process";
-import { readFile as readFile9 } from "fs/promises";
+import { readFile as readFile10 } from "fs/promises";
 import { join as join6 } from "path";
 import { promisify as promisify2 } from "util";
 var execFileAsync2 = promisify2(execFile2);
 async function currentBranch(projectRoot) {
   try {
     const headPath = join6(projectRoot, ".git", "HEAD");
-    const head = await readFile9(headPath, "utf8");
+    const head = await readFile10(headPath, "utf8");
     const trimmed = head.trim();
     const match = trimmed.match(/^ref:\s+refs\/heads\/(.+)$/);
     if (match?.[1]) return match[1];
@@ -2419,8 +2621,8 @@ function resolveBranchPaths(contextDir, branch, isDefault) {
 }
 
 // src/memory/context-md.ts
-import { mkdir as mkdir5, readFile as readFile10, writeFile as writeFile5 } from "fs/promises";
-import { dirname as dirname6 } from "path";
+import { mkdir as mkdir6, readFile as readFile11, writeFile as writeFile6 } from "fs/promises";
+import { dirname as dirname7 } from "path";
 var MAX_BULLETS = 3;
 function deriveContextMd(entries, branch) {
   const tasks = entries.filter((e) => e.type === "task").reverse();
@@ -2463,17 +2665,17 @@ function formatContextMd(ctx) {
   return lines.join("\n");
 }
 async function writeContextMd(path, ctx) {
-  await mkdir5(dirname6(path), { recursive: true });
-  await writeFile5(path, formatContextMd(ctx), "utf8");
+  await mkdir6(dirname7(path), { recursive: true });
+  await writeFile6(path, formatContextMd(ctx), "utf8");
 }
 
 // src/memory/context-store.ts
-import { mkdir as mkdir6, readFile as readFile11, writeFile as writeFile6 } from "fs/promises";
-import { dirname as dirname7 } from "path";
+import { mkdir as mkdir7, readFile as readFile12, writeFile as writeFile7 } from "fs/promises";
+import { dirname as dirname8 } from "path";
 var SCHEMA_VERSION2 = 1;
 async function readEntries(path) {
   try {
-    const raw = await readFile11(path, "utf8");
+    const raw = await readFile12(path, "utf8");
     const parsed = JSON.parse(raw);
     return Array.isArray(parsed.entries) ? parsed.entries : [];
   } catch {
@@ -2481,9 +2683,9 @@ async function readEntries(path) {
   }
 }
 async function writeEntries(path, entries) {
-  await mkdir6(dirname7(path), { recursive: true });
+  await mkdir7(dirname8(path), { recursive: true });
   const store = { schema_version: SCHEMA_VERSION2, entries };
-  await writeFile6(path, JSON.stringify(store, null, 2) + "\n", "utf8");
+  await writeFile7(path, JSON.stringify(store, null, 2) + "\n", "utf8");
 }
 async function appendEntry(path, entry) {
   const entries = await readEntries(path);
@@ -2860,7 +3062,7 @@ var TOOLS = [
   },
   {
     name: "blast_radius",
-    description: "Given a file (or 'file::symbol' target), return all files that depend on it transitively via imports + tests edges. Use BEFORE editing a widely-used file to see what could break. Symbol-level granularity is approximated at the file level (we don't track call edges in v0.1).",
+    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.",
     inputSchema: {
       type: "object",
       properties: {
@@ -2872,7 +3074,7 @@ var TOOLS = [
   },
   {
     name: "dead_code",
-    description: "Return files in the project that no other file imports and no test file references \u2014 strong candidates for unused/orphaned code. File-level granularity (v0.1 limitation \u2014 symbol-level needs call-graph edges). Common entry-point patterns (main, index, app, CLI, bin/) are excluded heuristically.",
+    description: "Return files in the project that no other file imports and no test file references \u2014 strong candidates for unused/orphaned code. File-level granularity; symbol-level dead code (unused exports, on top of the call graph) is a planned follow-up. Common entry-point patterns (main, index, app, CLI, bin/) are excluded heuristically.",
     inputSchema: {
       type: "object",
       properties: {
@@ -2918,12 +3120,24 @@ function blastRadius(args, ctx) {
   const filePath = targetRaw.split("::", 1)[0]?.trim() ?? 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();
+  for (const n of ctx.graph.nodes) {
+    if (n.kind === "symbol") fileIdBySymbol.set(n.id, `file:${n.file}`);
+  }
   const incoming = /* @__PURE__ */ new Map();
+  const addIncoming = (to, from, kind) => {
+    const list = incoming.get(to) ?? [];
+    list.push({ from, kind });
+    incoming.set(to, list);
+  };
   for (const e of ctx.graph.edges) {
-    if (e.kind !== "imports" && e.kind !== "tests") continue;
-    const list = incoming.get(e.to) ?? [];
-    list.push({ from: e.from, kind: e.kind });
-    incoming.set(e.to, list);
+    if (e.kind === "imports" || e.kind === "tests") {
+      addIncoming(e.to, e.from, e.kind);
+    } else if (e.kind === "calls") {
+      const fromFile = fileIdBySymbol.get(e.from);
+      const toFile = fileIdBySymbol.get(e.to);
+      if (fromFile && toFile && fromFile !== toFile) addIncoming(toFile, fromFile, "calls");
+    }
   }
   const visited = /* @__PURE__ */ new Set([root.id]);
   const hits = [];
@@ -3001,7 +3215,7 @@ _(no file is unreferenced \u2014 every file is either imported by another, has a
   }
   lines.push("");
   lines.push(
-    `_v0.1 caveat:_ this is file-level only. Symbol-level dead code (unused exports) needs call-graph edges, which land in v0.2.`
+    `_caveat:_ this is file-level only. Symbol-level dead code (unused exports), built on the now-populated call graph, is a planned follow-up.`
   );
   return textContent(lines.join("\n"));
 }
@@ -3153,7 +3367,7 @@ async function contextRecall(args, ctx) {
 }
 async function logToolCall(ctx, tool) {
   try {
-    await mkdir7(dirname8(ctx.paths.toolLog), { recursive: true });
+    await mkdir8(dirname9(ctx.paths.toolLog), { recursive: true });
     await appendFile3(
       ctx.paths.toolLog,
       JSON.stringify({ ts: (/* @__PURE__ */ new Date()).toISOString(), tool }) + "\n",
@@ -3271,12 +3485,12 @@ async function getCommitsSince(projectRoot, sinceIso) {
 }
 
 // src/memory/session.ts
-import { mkdir as mkdir8, readFile as readFile12, writeFile as writeFile7 } from "fs/promises";
-import { dirname as dirname9 } from "path";
+import { mkdir as mkdir9, readFile as readFile13, writeFile as writeFile8 } from "fs/promises";
+import { dirname as dirname10 } from "path";
 var SESSION_SCHEMA_VERSION = 1;
 async function readSession(path) {
   try {
-    const raw = await readFile12(path, "utf8");
+    const raw = await readFile13(path, "utf8");
     const parsed = JSON.parse(raw);
     if (parsed.schema_version !== SESSION_SCHEMA_VERSION) return null;
     return parsed;
@@ -3285,8 +3499,8 @@ async function readSession(path) {
   }
 }
 async function writeSession(path, state) {
-  await mkdir8(dirname9(path), { recursive: true });
-  await writeFile7(path, JSON.stringify(state, null, 2) + "\n", "utf8");
+  await mkdir9(dirname10(path), { recursive: true });
+  await writeFile8(path, JSON.stringify(state, null, 2) + "\n", "utf8");
 }
 
 // src/server/routes/context-update.ts
@@ -3331,8 +3545,8 @@ async function handleContextUpdate(req, ctx) {
 }
 
 // src/server/routes/gate.ts
-import { appendFile as appendFile4, mkdir as mkdir9 } from "fs/promises";
-import { dirname as dirname10 } from "path";
+import { appendFile as appendFile4, mkdir as mkdir10 } from "fs/promises";
+import { dirname as dirname11 } from "path";
 var BLOCKABLE_TOOLS = /* @__PURE__ */ new Set(["Grep", "Glob"]);
 var RECENT_ACTIVITY_WINDOW_MS = 5 * 60 * 1e3;
 function extractQuery(toolName, input) {
@@ -3388,7 +3602,7 @@ function recentlyTouchedMatchesQuery(recentPaths, queryTokens, graph) {
 }
 async function logDecision(ctx, toolName, query, decision, reason) {
   try {
-    await mkdir9(dirname10(ctx.paths.gateLog), { recursive: true });
+    await mkdir10(dirname11(ctx.paths.gateLog), { recursive: true });
     const entry = {
       ts: (/* @__PURE__ */ new Date()).toISOString(),
       tool: toolName,
@@ -3460,15 +3674,15 @@ async function handleGate(req, ctx) {
 }
 
 // src/server/routes/log.ts
-import { appendFile as appendFile5, mkdir as mkdir10 } from "fs/promises";
-import { dirname as dirname11 } from "path";
+import { appendFile as appendFile5, mkdir as mkdir11 } from "fs/promises";
+import { dirname as dirname12 } from "path";
 async function handleLog(entry, ctx) {
   if (!entry || typeof entry.input_tokens !== "number" || typeof entry.output_tokens !== "number") {
     throw new Error("log: input_tokens and output_tokens (number) are required");
   }
   const written_at = (/* @__PURE__ */ new Date()).toISOString();
   const record = { ...entry, written_at };
-  await mkdir10(dirname11(ctx.paths.tokenLog), { recursive: true });
+  await mkdir11(dirname12(ctx.paths.tokenLog), { recursive: true });
   await appendFile5(ctx.paths.tokenLog, JSON.stringify(record) + "\n", "utf8");
   return { ok: true, written_at };
 }
@@ -3654,7 +3868,7 @@ async function startServer(paths, options = {}) {
   const port = options.port ?? await findFreePort();
   const app = buildApp(ctx, port);
   const nodeServer = serve({ fetch: app.fetch, port, hostname: "127.0.0.1" });
-  await writeFile8(paths.mcpPort, String(port), "utf8");
+  await writeFile9(paths.mcpPort, String(port), "utf8");
   const fileWatcher = createFileWatcher(paths.projectRoot, (e) => ctx.activity.add(e));
   const gitWatcher = createGitWatcher(paths.projectRoot, async (e) => {
     await ctx.activity.add(e);