@jefuriiij/synthra 0.9.0 → 0.11.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"),
@@ -2341,6 +2342,10 @@ function loadConfig() {
     // 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"),
@@ -3101,11 +3106,14 @@ var TOOLS = [
   },
   {
     name: "blast_radius",
-    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.",
+    description: "See what could break before an edit. A bare file target returns all files that depend on it transitively via imports, tests, and call edges. A 'file::symbol' target returns the exact caller SYMBOLS that transitively call it (name \u2192 file:line) plus the test files guarding the impact \u2014 the precise rename-safety view. Call edges are name-resolved (precise within a file, unique-name across files).",
     inputSchema: {
       type: "object",
       properties: {
-        target: { type: "string", description: "File path or 'file::symbol' notation." },
+        target: {
+          type: "string",
+          description: "File path (file-level dependents) or 'file::symbol' (caller symbols)."
+        },
         depth: { type: "number", description: "Max hops to traverse. Default 3." }
       },
       required: ["target"]
@@ -3156,7 +3164,8 @@ function blastRadius(args, ctx) {
   const targetRaw = typeof args?.target === "string" ? args.target.trim() : "";
   const maxDepth = typeof args?.depth === "number" && args.depth > 0 ? Math.floor(args.depth) : 3;
   if (!targetRaw) return errorContent("blast_radius: 'target' (string) is required");
-  const filePath = targetRaw.split("::", 1)[0]?.trim() ?? targetRaw;
+  if (targetRaw.includes("::")) return blastRadiusSymbol(targetRaw, maxDepth, ctx);
+  const filePath = 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();
@@ -3211,6 +3220,92 @@ _(no dependents \u2014 file is isolated)_`);
   }
   return textContent(lines.join("\n"));
 }
+function blastRadiusSymbol(targetRaw, maxDepth, ctx) {
+  const [rawFile, rawSym] = targetRaw.split("::", 2);
+  const filePath = (rawFile ?? "").trim();
+  const symName = (rawSym ?? "").trim();
+  if (!symName) return errorContent("blast_radius: 'file::symbol' target needs a symbol name");
+  const resolved = resolveFileTarget(ctx.graph, filePath);
+  if ("ambiguous" in resolved) {
+    const shown = resolved.ambiguous.slice(0, 5).join(", ");
+    return errorContent(
+      `blast_radius: '${filePath}' matches multiple files (${shown}). Pass a longer path.`
+    );
+  }
+  if ("none" in resolved) return errorContent(`blast_radius: file not in graph: ${filePath}`);
+  const fileNode = resolved.node;
+  const symbol = ctx.graph.nodes.find(
+    (n) => n.kind === "symbol" && n.file === fileNode.path && n.name === symName
+  );
+  if (!symbol)
+    return errorContent(`blast_radius: symbol '${symName}' not found in ${fileNode.path}`);
+  const callersBySym = /* @__PURE__ */ new Map();
+  for (const e of ctx.graph.edges) {
+    if (e.kind !== "calls" || e.from === e.to) continue;
+    const list = callersBySym.get(e.to) ?? [];
+    list.push(e.from);
+    callersBySym.set(e.to, list);
+  }
+  const symById = /* @__PURE__ */ new Map();
+  for (const n of ctx.graph.nodes) if (n.kind === "symbol") symById.set(n.id, n);
+  const visited = /* @__PURE__ */ new Set([symbol.id]);
+  const hits = [];
+  let frontier = [symbol.id];
+  for (let d = 1; d <= maxDepth; d++) {
+    const next = [];
+    for (const cur of frontier) {
+      for (const fromId of callersBySym.get(cur) ?? []) {
+        if (visited.has(fromId)) continue;
+        visited.add(fromId);
+        next.push(fromId);
+        const s = symById.get(fromId);
+        if (s) hits.push({ name: s.name, file: s.file, line: s.start_line, depth: d });
+      }
+    }
+    frontier = next;
+    if (next.length === 0) break;
+  }
+  const header = `# Blast radius for ${fileNode.path}::${symbol.name}  (callers, depth \u2264 ${maxDepth})`;
+  if (hits.length === 0) {
+    const tline2 = testsCoveringLine(ctx.graph, [fileNode.path]);
+    return textContent(
+      `${header}
+
+_(no callers \u2014 safe to rename)_${tline2 ? `
+
+${tline2}` : ""}`
+    );
+  }
+  hits.sort((a, b) => a.depth - b.depth || a.file.localeCompare(b.file) || a.line - b.line);
+  const lines = [header, "", `${hits.length} caller symbol(s):`];
+  for (const h of hits) lines.push(`- **depth ${h.depth}** \`${h.name}\` \u2192 ${h.file}:${h.line}`);
+  const tline = testsCoveringLine(ctx.graph, [fileNode.path, ...hits.map((h) => h.file)]);
+  if (tline) {
+    lines.push("");
+    lines.push(tline);
+  }
+  return textContent(lines.join("\n"));
+}
+function testsCoveringLine(graph, filePaths) {
+  const fileByPath = /* @__PURE__ */ new Map();
+  for (const n of graph.nodes) if (n.kind === "file") fileByPath.set(n.path, n);
+  const seen = /* @__PURE__ */ new Set();
+  const tests = [];
+  for (const p of new Set(filePaths)) {
+    const fn = fileByPath.get(p);
+    if (!fn) continue;
+    for (const t of findTestsForFile(graph, fn)) {
+      if (!seen.has(t.path)) {
+        seen.add(t.path);
+        tests.push(t.path);
+      }
+    }
+  }
+  if (tests.length === 0) return "";
+  const shown = tests.slice(0, TESTS_MAX_FILES);
+  const omitted = tests.length - shown.length;
+  return `Tests covering the impact: ${shown.join(" \xB7 ")}${omitted > 0 ? ` \u2026+${omitted} more` : ""}`;
+}
 var LIKELY_ENTRY_PATTERNS = [
   /(?:^|\/)main\.[a-z0-9_]+$/i,
   /(?:^|\/)index\.[a-z0-9_]+$/i,
@@ -3288,6 +3383,7 @@ function resolveFileTarget(graph, filePath) {
 var DEPS_SIG_MAX = 140;
 var DEPS_MAX_CALLEES = 10;
 var DEPS_MAX_CALLERS = 12;
+var TESTS_MAX_FILES = 6;
 function buildDepsFooter(symbol, graph, maxChars = loadConfig().readDepsMaxChars) {
   const symById = /* @__PURE__ */ new Map();
   for (const n of graph.nodes) if (n.kind === "symbol") symById.set(n.id, n);
@@ -3351,6 +3447,21 @@ function buildDepsFooter(symbol, graph, maxChars = loadConfig().readDepsMaxChars
   }
   return lines.join("\n");
 }
+function buildTestsFooter(symbol, graph) {
+  const fileNode = graph.nodes.find(
+    (n) => n.kind === "file" && n.path === symbol.file
+  );
+  if (!fileNode) return "";
+  const tests = findTestsForFile(graph, fileNode);
+  if (tests.length > 0) {
+    const shown = tests.slice(0, TESTS_MAX_FILES).map((t) => t.path);
+    const omitted = tests.length - shown.length;
+    const more = omitted > 0 ? ` \u2026+${omitted} more` : "";
+    return `Tests (file-level): ${shown.join(" \xB7 ")}${more}  \u2014 run after editing`;
+  }
+  if (isLikelyEntry(symbol.file)) return "";
+  return "Tests: none linked to this file.";
+}
 async function graphRead(args, ctx) {
   const target = typeof args?.target === "string" ? args.target : "";
   if (!target) return errorContent("graph_read: 'target' (string) is required");
@@ -3394,10 +3505,15 @@ ${fileNode.content}`);
 
 ---
 ${deps}` : "";
+  const tests = buildTestsFooter(symbol, ctx.graph);
+  const testsBlock = tests ? `
+
+---
+${tests}` : "";
   return textContent(
     `# ${fileNode.path}::${symbol.name}  (L${symbol.start_line}-${symbol.end_line})
 
-${body}${depsBlock}${editHint}`
+${body}${depsBlock}${testsBlock}${editHint}`
   );
 }
 var editedFiles = /* @__PURE__ */ new Set();
@@ -3716,22 +3832,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;
@@ -3747,6 +3855,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);
@@ -3779,7 +4076,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,
@@ -3788,7 +4085,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 {
   }
 }
@@ -3853,6 +4150,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" };
   }
@@ -3906,16 +4208,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 };
 }