@jefuriiij/synthra 0.8.1 → 0.9.0

package/CHANGELOG.md

@@ -7,6 +7,34 @@ For older versions, see [GitHub Releases](https://github.com/jefuriiij/synthra/r
 
 ---
 
+## [0.9.0] — 2026-06-20
+
+### Added
+
+- **The graph auto-reindexes edited files mid-session — it never goes stale.**
+  Previously the in-memory graph was a snapshot from the last `syn .`: edit a
+  file and `graph_read` / `blast_radius` / the dependency footer would keep
+  serving the *old* signature, body, and line ranges until the next manual scan.
+  Now the running server watches for source changes and, ~1s after edits settle,
+  re-runs the incremental scan and hot-swaps the graph in place — so reads always
+  reflect what's on disk. The rescan is incremental (only the changed file hits
+  tree-sitter; everything else reuses the content-hash parse cache) and debounced
+  so a burst of saves coalesces into one rebuild. Tune with
+  `SYN_REINDEX_DEBOUNCE_MS` (default `1000`); disable with `SYN_NO_AUTOREINDEX`.
+
+### Fixed
+
+- **In-session rescans (auto-reindex and branch-switch) no longer rewrite your
+  `CLAUDE.md` / `.gitignore`.** A rescan now skips the bootstrap step — it only
+  rebuilds the graph. This also closes a feedback loop the new auto-reindex would
+  otherwise hit (rewriting the watched `CLAUDE.md` on every rescan would retrigger
+  the watcher endlessly).
+- **`CLAUDE.md` no longer accumulates a blank line on every `syn .`.** The policy
+  block patcher is now idempotent — re-running with nothing to change is a true
+  no-op instead of appending an empty line above the managed block each time.
+
+---
+
 ## [0.8.1] — 2026-06-16
 
 ### Changed

package/dist/cli/index.js

@@ -18,7 +18,7 @@ var init_package = __esm({
   "package.json"() {
     package_default = {
       name: "@jefuriiij/synthra",
-      version: "0.8.1",
+      version: "0.9.0",
       publishConfig: {
         access: "public"
       },
@@ -3167,9 +3167,13 @@ async function patchClaudeMd(path, projectName) {
     return { created: true, updated: false, skipped: false };
   }
   const stripped = existing.replace(ANY_BLOCK_RE, "");
-  const hadBlock = stripped !== existing;
-  const desired = stripped.endsWith("\n") ? stripped + "\n" + block + "\n" : (stripped.length ? stripped + "\n\n" : "") + block + "\n";
-  if (hadBlock && desired === existing) {
+  const base = stripped.replace(/\s+$/, "");
+  const desired = base.length ? `${base}
+
+${block}
+` : `${block}
+`;
+  if (desired === existing) {
     return { created: false, updated: false, skipped: true };
   }
   await writeFile6(path, desired, "utf8");
@@ -3268,8 +3272,8 @@ async function scanProject(projectRootRaw, opts = {}) {
   const start = Date.now();
   const verbose = !opts.silent;
   if (verbose) log.info(`scanning ${projectRoot}`);
-  const boot = await bootstrap(paths);
-  if (verbose) {
+  const boot = opts.skipBootstrap ? null : await bootstrap(paths);
+  if (verbose && boot) {
     if (boot.graphCreated) log.info("  created .synthra-graph/");
     if (boot.contextCreated) log.info("  created .synthra/");
     if (boot.gitignoreUpdated) log.info("  updated .gitignore");
@@ -3379,6 +3383,36 @@ var LearnRuntime = class _LearnRuntime {
   }
 };
 
+// src/shared/config.ts
+function num(name, fallback) {
+  const v = process.env[name];
+  if (!v) return fallback;
+  const n = Number(v);
+  return Number.isFinite(n) ? n : fallback;
+}
+function str(name, fallback) {
+  return process.env[name] ?? fallback;
+}
+function loadConfig() {
+  return {
+    hardMaxReadChars: num("SYN_HARD_MAX_READ_CHARS", 4e3),
+    gateHintMaxChars: num("SYN_GATE_HINT_CHARS", 1200),
+    readDepsMaxChars: num("SYN_READ_DEPS_CHARS", 900),
+    turnReadBudgetChars: num("SYN_TURN_READ_BUDGET_CHARS", 18e3),
+    fallbackMaxCallsPerTurn: num("SYN_FALLBACK_MAX_CALLS_PER_TURN", 1),
+    retrieveCacheTtlSec: num("SYN_RETRIEVE_CACHE_TTL_SEC", 900),
+    // Auto-reindex: re-run the incremental scan + swap the in-memory graph this
+    // many ms after the last source-file change, so graph reads never go stale
+    // mid-session. Set SYN_NO_AUTOREINDEX to disable entirely.
+    reindexDebounceMs: num("SYN_REINDEX_DEBOUNCE_MS", 1e3),
+    autoReindex: !process.env.SYN_NO_AUTOREINDEX,
+    mcpPort: process.env.SYN_MCP_PORT ? num("SYN_MCP_PORT", 0) : null,
+    dashboardPort: num("SYN_DASHBOARD_PORT", 8901),
+    logLevel: str("SYN_LOG_LEVEL", "info"),
+    claudeBin: str("SYN_CLAUDE_BIN", "claude")
+  };
+}
+
 // src/server/mcp.ts
 import { appendFile as appendFile3, mkdir as mkdir10 } from "fs/promises";
 import { dirname as dirname12 } from "path";
@@ -4000,31 +4034,6 @@ async function pack(files, opts) {
   };
 }
 
-// src/shared/config.ts
-function num(name, fallback) {
-  const v = process.env[name];
-  if (!v) return fallback;
-  const n = Number(v);
-  return Number.isFinite(n) ? n : fallback;
-}
-function str(name, fallback) {
-  return process.env[name] ?? fallback;
-}
-function loadConfig() {
-  return {
-    hardMaxReadChars: num("SYN_HARD_MAX_READ_CHARS", 4e3),
-    gateHintMaxChars: num("SYN_GATE_HINT_CHARS", 1200),
-    readDepsMaxChars: num("SYN_READ_DEPS_CHARS", 900),
-    turnReadBudgetChars: num("SYN_TURN_READ_BUDGET_CHARS", 18e3),
-    fallbackMaxCallsPerTurn: num("SYN_FALLBACK_MAX_CALLS_PER_TURN", 1),
-    retrieveCacheTtlSec: num("SYN_RETRIEVE_CACHE_TTL_SEC", 900),
-    mcpPort: process.env.SYN_MCP_PORT ? num("SYN_MCP_PORT", 0) : null,
-    dashboardPort: num("SYN_DASHBOARD_PORT", 8901),
-    logLevel: str("SYN_LOG_LEVEL", "info"),
-    claudeBin: str("SYN_CLAUDE_BIN", "claude")
-  };
-}
-
 // src/server/mcp.ts
 var PROTOCOL_VERSION = "2024-11-05";
 var SERVER_INFO = { name: "synthra", version: "0.0.1" };
@@ -4598,6 +4607,61 @@ async function handleMcpRequest(body, ctx) {
   }
 }
 
+// src/server/reindex.ts
+async function rescanAndSwap(ctx, paths, label) {
+  try {
+    await scanProject(paths.projectRoot, { silent: true, skipBootstrap: true });
+    const [graph, symbolIndex] = await Promise.all([
+      readGraph(paths.infoGraph),
+      readSymbolIndex(paths.symbolIndex)
+    ]);
+    ctx.graph = graph;
+    ctx.symbolIndex = symbolIndex;
+    log.info(`reindexed (${label}) \u2014 ${graph.symbol_count} symbols, ${graph.edge_count} edges.`);
+  } catch (err2) {
+    log.warn(`reindex failed (${label}): ${err2.message}`);
+  }
+}
+function createReindexer(ctx, paths, opts = {}) {
+  const debounceMs = opts.debounceMs ?? 1e3;
+  const rescan = opts.rescan ?? rescanAndSwap;
+  let timer = null;
+  let running = false;
+  let pending = false;
+  async function run() {
+    if (running) {
+      pending = true;
+      return;
+    }
+    running = true;
+    try {
+      await rescan(ctx, paths, "edit");
+    } finally {
+      running = false;
+      if (pending) {
+        pending = false;
+        void run();
+      }
+    }
+  }
+  return {
+    schedule() {
+      if (timer) clearTimeout(timer);
+      timer = setTimeout(() => {
+        timer = null;
+        void run();
+      }, debounceMs);
+      timer.unref?.();
+    },
+    stop() {
+      if (timer) {
+        clearTimeout(timer);
+        timer = null;
+      }
+    }
+  };
+}
+
 // src/server/routes/activity.ts
 async function handleActivity(sinceMs, ctx) {
   const events = ctx.activity.getEvents(sinceMs);
@@ -5083,24 +5147,17 @@ async function startServer(paths, options = {}) {
   const app = buildApp(ctx, port);
   const nodeServer = serve2({ fetch: app.fetch, port, hostname: "127.0.0.1" });
   await writeFile11(paths.mcpPort, String(port), "utf8");
-  const fileWatcher = createFileWatcher(paths.projectRoot, (e) => ctx.activity.add(e));
+  const cfg = loadConfig();
+  const reindexer = cfg.autoReindex ? createReindexer(ctx, paths, { debounceMs: cfg.reindexDebounceMs }) : null;
+  const fileWatcher = createFileWatcher(paths.projectRoot, (e) => {
+    void ctx.activity.add(e);
+    reindexer?.schedule();
+  });
   const gitWatcher = createGitWatcher(paths.projectRoot, async (e) => {
     await ctx.activity.add(e);
     if (e.kind === "branch-switch") {
-      try {
-        const to = e.details?.to ?? "unknown";
-        log.info(`branch switched to '${to}' \u2014 rebuilding graph\u2026`);
-        await scanProject(paths.projectRoot, { silent: true });
-        const [g, idx] = await Promise.all([
-          readGraph(paths.infoGraph),
-          readSymbolIndex(paths.symbolIndex)
-        ]);
-        ctx.graph = g;
-        ctx.symbolIndex = idx;
-        log.info(`graph rebuilt for '${to}' (${g.symbol_count} symbols).`);
-      } catch (err2) {
-        log.warn(`branch rescan failed: ${err2.message}`);
-      }
+      const to = e.details?.to ?? "unknown";
+      await rescanAndSwap(ctx, paths, `branch ${to}`);
     }
   });
   try {
@@ -5118,6 +5175,7 @@ async function startServer(paths, options = {}) {
     port,
     url,
     async stop() {
+      reindexer?.stop();
       await fileWatcher.stop().catch(() => void 0);
       await gitWatcher.stop().catch(() => void 0);
       await ctx.learn?.flush().catch(() => void 0);