@jefuriiij/synthra 0.9.0 → 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"),
@@ -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"),
@@ -3716,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;
@@ -3747,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);
@@ -3779,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,
@@ -3788,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 {
   }
 }
@@ -3853,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" };
   }
@@ -3906,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 };
 }