@jefuriiij/synthra 0.8.1 → 0.10.0

package/dist/server/index.js

@@ -1785,6 +1785,7 @@ function resolvePaths(projectRoot) {
     activityLog: join5(graphDir, "activity.jsonl"),
     tokenLog: join5(graphDir, "token_log.jsonl"),
     gateLog: join5(graphDir, "gate_log.jsonl"),
+    bashLog: join5(graphDir, "bash_log.jsonl"),
     toolLog: join5(graphDir, "tool_log.jsonl"),
     accessLog: join5(graphDir, "access_log.jsonl"),
     learnStore: join5(graphDir, "learn_store.json"),
@@ -1987,9 +1988,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 writeFile3(path, desired, "utf8");
@@ -2088,8 +2093,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");
@@ -2314,6 +2319,40 @@ 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,
+    // Observe-only: log codebase-exploration Bash commands (grep/cat/find …) so
+    // the terminal bypass of the Moat can be measured. Never blocks. Opt out
+    // with SYN_NO_BASH_OBSERVE.
+    bashObserve: !process.env.SYN_NO_BASH_OBSERVE,
+    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 mkdir8 } from "fs/promises";
 import { dirname as dirname9 } from "path";
@@ -2935,31 +2974,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" };
@@ -3552,6 +3566,61 @@ function isFree(port) {
   });
 }
 
+// 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);
@@ -3652,22 +3721,14 @@ async function handleContextUpdate(req, ctx) {
 }
 
 // src/server/routes/gate.ts
+import { appendFile as appendFile5, mkdir as mkdir11 } from "fs/promises";
+import { dirname as dirname12 } from "path";
+
+// src/server/routes/bash-observe.ts
 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) {
-  if (toolName === "Grep") {
-    const pattern = typeof input.pattern === "string" ? input.pattern : "";
-    const query = typeof input.query === "string" ? input.query : "";
-    return (pattern || query).trim() || null;
-  }
-  if (toolName === "Glob") {
-    const pattern = typeof input.pattern === "string" ? input.pattern : "";
-    return pattern.replace(/[*?/\\.]+/g, " ").trim() || null;
-  }
-  return null;
-}
+
+// src/server/routes/query-heuristics.ts
 function looksLikeNonSymbolQuery(pattern) {
   if (/<\/?[a-zA-Z]/.test(pattern)) return true;
   if (/[a-zA-Z][\w-]*-[\w-]*\s*=/.test(pattern)) return true;
@@ -3683,6 +3744,195 @@ function looksLikeNonSymbolQuery(pattern) {
   if (branches.length > 0 && branches.every(isKebab)) return true;
   return false;
 }
+
+// src/server/routes/bash-observe.ts
+var SEARCH_TOOLS = /* @__PURE__ */ new Set(["grep", "egrep", "fgrep", "rg", "ripgrep", "ag", "ack"]);
+var READ_TOOLS = /* @__PURE__ */ new Set(["cat", "head", "tail", "less", "more", "bat", "tac"]);
+var LIST_TOOLS = /* @__PURE__ */ new Set(["find", "tree"]);
+var SOURCE_EXT = /\.(ts|tsx|js|jsx|cts|mts|cjs|mjs|py|pyi|svelte|vue|go|rs|java|kt|kts|php|rb|c|h|cpp|cc|cxx|hpp|cs|dart|json|md|css|html|hubl|sh|yml|yaml|toml)$/i;
+function tokenizeCommand(cmd) {
+  const tokens = [];
+  let cur = "";
+  let quote = null;
+  let hasContent2 = false;
+  const flush = () => {
+    if (hasContent2) tokens.push(cur);
+    cur = "";
+    hasContent2 = false;
+  };
+  for (let i = 0; i < cmd.length; i++) {
+    const ch = cmd[i];
+    if (quote) {
+      if (ch === quote) quote = null;
+      else cur += ch;
+      hasContent2 = true;
+      continue;
+    }
+    if (ch === '"' || ch === "'") {
+      quote = ch;
+      hasContent2 = true;
+      continue;
+    }
+    if (ch === "|" || ch === "&" || ch === ";") {
+      flush();
+      let op = ch;
+      if ((ch === "|" || ch === "&") && cmd[i + 1] === ch) {
+        op += ch;
+        i++;
+      }
+      tokens.push(op);
+      continue;
+    }
+    if (/\s/.test(ch)) {
+      flush();
+      continue;
+    }
+    cur += ch;
+    hasContent2 = true;
+  }
+  flush();
+  return tokens;
+}
+function isOperator(t) {
+  return t === "|" || t === "||" || t === "&&" || t === ";";
+}
+function splitSegments(tokens) {
+  const segs = [];
+  let cur = [];
+  for (const t of tokens) {
+    if (isOperator(t)) {
+      if (cur.length) segs.push(cur);
+      cur = [];
+    } else {
+      cur.push(t);
+    }
+  }
+  if (cur.length) segs.push(cur);
+  return segs;
+}
+function commandTokens(seg) {
+  let i = 0;
+  while (i < seg.length) {
+    const t = seg[i];
+    if (t === "env") {
+      i++;
+      continue;
+    }
+    if (/^[A-Za-z_][A-Za-z0-9_]*=/.test(t)) {
+      i++;
+      continue;
+    }
+    break;
+  }
+  return seg.slice(i);
+}
+function baseCmd(tok) {
+  return (tok.split(/[\\/]/).pop() ?? tok).toLowerCase();
+}
+function classifySegment(seg) {
+  const toks = commandTokens(seg);
+  if (toks.length === 0) return null;
+  const cmd = baseCmd(toks[0]);
+  const rest = toks.slice(1);
+  const flags = rest.filter((a) => a.startsWith("-"));
+  const nonFlags = rest.filter((a) => !a.startsWith("-"));
+  if (SEARCH_TOOLS.has(cmd)) {
+    const pattern = nonFlags[0];
+    if (!pattern) return null;
+    const recursive = flags.some(
+      (f) => f === "-r" || f === "-R" || f === "--recursive" || /^-[a-zA-Z]*[rR]$/.test(f)
+    );
+    const rgLike = cmd === "rg" || cmd === "ripgrep" || cmd === "ag" || cmd === "ack";
+    const hasPathArg = nonFlags.length > 1;
+    if (!rgLike && !recursive && !hasPathArg) return null;
+    return { kind: "search", tool: cmd, query: pattern };
+  }
+  if (READ_TOOLS.has(cmd)) {
+    const file = nonFlags.find((a) => SOURCE_EXT.test(a));
+    if (!file) return null;
+    return { kind: "read", tool: cmd, query: file };
+  }
+  if (LIST_TOOLS.has(cmd)) {
+    const nameIdx = rest.findIndex((a) => a === "-name" || a === "-iname" || a === "-path");
+    const target = nameIdx >= 0 ? rest[nameIdx + 1] ?? null : nonFlags[0] ?? ".";
+    return { kind: "list", tool: cmd, query: target };
+  }
+  return null;
+}
+function classifyBashCommand(command) {
+  if (!command || typeof command !== "string") return null;
+  const tokens = tokenizeCommand(command);
+  if (tokens.length === 0) return null;
+  if (tokens.some((t) => !isOperator(t) && t.includes(">"))) return null;
+  const found = splitSegments(tokens).map(classifySegment).filter((x) => x !== null);
+  if (found.length === 0) return null;
+  const prio = { search: 0, read: 1, list: 2 };
+  found.sort((a, b) => prio[a.kind] - prio[b.kind]);
+  return found[0];
+}
+function graphHasFile(ctx, target) {
+  const base = target.split(/[\\/]/).pop() ?? target;
+  for (const n of ctx.graph.nodes) {
+    if (n.kind !== "file") continue;
+    if (n.path === target || n.path.endsWith(`/${target}`) || n.path.split("/").pop() === base) {
+      return true;
+    }
+  }
+  return false;
+}
+var Q_MAX = 200;
+var CMD_MAX = 300;
+var trunc = (s, max) => s.length > max ? `${s.slice(0, max)}\u2026` : s;
+async function logObservation(ctx, exp, confidence, avoidable, command) {
+  try {
+    await mkdir10(dirname11(ctx.paths.bashLog), { recursive: true });
+    const entry = {
+      ts: (/* @__PURE__ */ new Date()).toISOString(),
+      kind: exp.kind,
+      tool: exp.tool,
+      query: exp.query ? trunc(exp.query, Q_MAX) : null,
+      confidence,
+      avoidable,
+      command: trunc(command, CMD_MAX)
+    };
+    await appendFile4(ctx.paths.bashLog, JSON.stringify(entry) + "\n", "utf8");
+  } catch {
+  }
+}
+async function observeBash(input, ctx) {
+  if (!loadConfig().bashObserve) return;
+  const command = typeof input.command === "string" ? input.command : "";
+  const exp = classifyBashCommand(command);
+  if (!exp) return;
+  let confidence = null;
+  let avoidable = false;
+  if (exp.kind === "search" && exp.query) {
+    if (!looksLikeNonSymbolQuery(exp.query)) {
+      const r = await retrieve(ctx.graph, exp.query);
+      confidence = r.confidence;
+      avoidable = r.confidence !== "low" && r.symbolMatched;
+    }
+  } else if (exp.kind === "read" && exp.query) {
+    avoidable = graphHasFile(ctx, exp.query);
+  }
+  await logObservation(ctx, exp, confidence, avoidable, command);
+}
+
+// src/server/routes/gate.ts
+var BLOCKABLE_TOOLS = /* @__PURE__ */ new Set(["Grep", "Glob"]);
+var RECENT_ACTIVITY_WINDOW_MS = 5 * 60 * 1e3;
+function extractQuery(toolName, input) {
+  if (toolName === "Grep") {
+    const pattern = typeof input.pattern === "string" ? input.pattern : "";
+    const query = typeof input.query === "string" ? input.query : "";
+    return (pattern || query).trim() || null;
+  }
+  if (toolName === "Glob") {
+    const pattern = typeof input.pattern === "string" ? input.pattern : "";
+    return pattern.replace(/[*?/\\.]+/g, " ").trim() || null;
+  }
+  return null;
+}
 function recentlyTouchedMatchesQuery(recentPaths, queryTokens, graph) {
   if (recentPaths.length === 0) return [];
   const recent = new Set(recentPaths);
@@ -3715,7 +3965,7 @@ function recentlyTouchedMatchesQuery(recentPaths, queryTokens, graph) {
 var LOG_REASON_MAX_CHARS = 240;
 async function logDecision(ctx, toolName, query, decision, reason, hintChars) {
   try {
-    await mkdir10(dirname11(ctx.paths.gateLog), { recursive: true });
+    await mkdir11(dirname12(ctx.paths.gateLog), { recursive: true });
     const entry = {
       ts: (/* @__PURE__ */ new Date()).toISOString(),
       tool: toolName,
@@ -3724,7 +3974,7 @@ async function logDecision(ctx, toolName, query, decision, reason, hintChars) {
       reason: reason && reason.length > LOG_REASON_MAX_CHARS ? `${reason.slice(0, LOG_REASON_MAX_CHARS)}\u2026` : reason,
       ...hintChars === void 0 ? {} : { hint_chars: hintChars }
     };
-    await appendFile4(ctx.paths.gateLog, JSON.stringify(entry) + "\n", "utf8");
+    await appendFile5(ctx.paths.gateLog, JSON.stringify(entry) + "\n", "utf8");
   } catch {
   }
 }
@@ -3789,6 +4039,11 @@ async function handleGate(req, ctx) {
   if (!req?.tool_name || typeof req.tool_name !== "string") {
     return { decision: "allow", reason: "no tool_name" };
   }
+  if (req.tool_name === "Bash") {
+    const input2 = req.tool_input && typeof req.tool_input === "object" ? req.tool_input : {};
+    await observeBash(input2, ctx);
+    return { decision: "allow" };
+  }
   if (!BLOCKABLE_TOOLS.has(req.tool_name)) {
     return { decision: "allow" };
   }
@@ -3842,16 +4097,16 @@ async function handleGate(req, ctx) {
 }
 
 // src/server/routes/log.ts
-import { appendFile as appendFile5, mkdir as mkdir11 } from "fs/promises";
-import { dirname as dirname12 } from "path";
+import { appendFile as appendFile6, mkdir as mkdir12 } from "fs/promises";
+import { dirname as dirname13 } 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 mkdir11(dirname12(ctx.paths.tokenLog), { recursive: true });
-  await appendFile5(ctx.paths.tokenLog, JSON.stringify(record) + "\n", "utf8");
+  await mkdir12(dirname13(ctx.paths.tokenLog), { recursive: true });
+  await appendFile6(ctx.paths.tokenLog, JSON.stringify(record) + "\n", "utf8");
   return { ok: true, written_at };
 }
 
@@ -4037,24 +4292,17 @@ async function startServer(paths, options = {}) {
   const app = buildApp(ctx, port);
   const nodeServer = serve({ fetch: app.fetch, port, hostname: "127.0.0.1" });
   await writeFile9(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 {
@@ -4072,6 +4320,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);