@jefuriiij/synthra 0.1.19 → 0.1.21

package/CHANGELOG.md

@@ -7,6 +7,57 @@ For older versions, see [GitHub Releases](https://github.com/jefuriiij/synthra/r
 
 ---
 
+## [0.1.21] — 2026-06-06
+
+### Added
+
+- **HubL (HubSpot CMS) symbol extraction for `.html` and `.hubl` files.**
+  Previously `.html` files were content-indexed only — keyword search and
+  whole-file reads, no symbol-level granularity. On HubSpot projects this
+  meant the graph contributed nothing: zero `graph_continue`/`graph_read`
+  calls resolved to symbol slices all session. Now `.html` and `.hubl` files
+  run through a new **regex-based** parser (`parsers/hubl.ts`; there is no
+  tree-sitter grammar for HubL):
+  - `{% macro name(args) %}` → extracted as a `function` symbol
+  - `{% block name %}` → extracted as a `component` symbol
+  - `{% include / extends / import / from "path" %}` → import edges (relative
+    paths resolve to local templates; `.html`/`.hubl` added to the resolver's
+    extension list)
+
+  Plain HTML with no HubL tags is unaffected — the parser yields zero symbols
+  and zero imports, identical to before. No API, protocol, or policy-block
+  change. Roadmap item #12.
+
+---
+
+## [0.1.20] — 2026-06-06
+
+### Fixed
+
+- **Gate (Moat) no longer blocks Grep/Glob queries the graph cannot answer with a symbol.**
+  Previously, the PreToolUse gate blocked whenever retrieval confidence was `medium` or `high`,
+  but confidence is driven by keyword and path hits too — not only by symbol matches. This meant
+  literal/attribute/CSS-selector patterns (`data-tour=`, `class=`, `: 100%`, `.filter-bar`,
+  `<div>`) and path-only Globs were blocked and redirected to `graph_read`, which has no symbol
+  slice to return for those queries, so Claude fell back to Grep or a whole-file Read anyway —
+  a wasted round-trip. Found across multiple dogfood sessions including well-indexed Svelte
+  repos. Two new guards close the gap:
+  - **Query-shape pre-filter** — Grep patterns that target markup, CSS, attributes, or string
+    literals are allowed through up front, before the retrieval step runs.
+  - **Symbol-hit requirement** — the gate now only blocks when retrieval matched a symbol whose
+    name the query mentions exactly. `RetrievalResult` gained a `symbolMatched` flag; the scorer
+    exposes `exactSym`.
+
+  Net effect: genuine symbol lookups still block (verified: `fetchWith429Retry`,
+  `MAX_ROWS_PER_TABLE`, `verifyPin`, `SOCKET_AUTH_SECRET`, `seedCredentials`); queries that
+  could never have been answered by the graph now allow through without the wasted redirect.
+  No API, protocol, or policy-block change — purely server-side gate behavior.
+
+- **Gate and rank test coverage added** (`tests/gate.test.ts`, `tests/rank.test.ts`).
+  Chips at the v0.2 backlog item to fill vitest tests beyond `it.todo` placeholders.
+
+---
+
 ## [0.1.19] — 2026-06-01
 
 ### Changed

package/dist/cli/index.js

@@ -18,7 +18,7 @@ var init_package = __esm({
   "package.json"() {
     package_default = {
       name: "@jefuriiij/synthra",
-      version: "0.1.19",
+      version: "0.1.21",
       publishConfig: {
         access: "public"
       },
@@ -2170,7 +2170,7 @@ function extractKeywords(content, _ext) {
 }
 
 // src/scanner/extract.ts
-var RESOLVE_EXTS = [".ts", ".tsx", ".js", ".jsx", ".mjs", ".cjs", ".py", ".svelte", ".vue", ".dart"];
+var RESOLVE_EXTS = [".ts", ".tsx", ".js", ".jsx", ".mjs", ".cjs", ".py", ".svelte", ".vue", ".dart", ".html", ".hubl"];
 var INDEX_FILES = ["index.ts", "index.tsx", "index.js", "index.jsx", "__init__.py"];
 function fileId(relPath) {
   return `file:${relPath}`;
@@ -2574,6 +2574,57 @@ async function parseGo(f, source) {
   );
 }
 
+// src/scanner/parsers/hubl.ts
+var MACRO_RE = /\{%-?\s*macro\s+([A-Za-z_]\w*)\s*\(([^)]*)\)/g;
+var ENDMACRO_RE = /\{%-?\s*endmacro\b/g;
+var BLOCK_RE = /\{%-?\s*block\s+([A-Za-z_]\w*)/g;
+var ENDBLOCK_RE = /\{%-?\s*endblock\b/g;
+var IMPORT_RE = /\{%-?\s*(?:include|extends|import|from)\s+["']([^"']+)["']/g;
+function lineAt(source, index) {
+  return source.slice(0, index).split(/\r?\n/).length;
+}
+function endLineAfter(source, fromIndex, endRe, startLine) {
+  endRe.lastIndex = fromIndex;
+  const m = endRe.exec(source);
+  return m ? lineAt(source, m.index) : startLine;
+}
+function parseHubL(f, source) {
+  const symbols = [];
+  const imports = [];
+  for (const m of source.matchAll(MACRO_RE)) {
+    const name = m[1];
+    if (!name) continue;
+    const args = (m[2] ?? "").trim();
+    const start = m.index ?? 0;
+    const startLine = lineAt(source, start);
+    symbols.push({
+      name,
+      kind: "function",
+      startLine,
+      endLine: endLineAfter(source, start + m[0].length, ENDMACRO_RE, startLine),
+      signature: `macro ${name}(${args})`
+    });
+  }
+  for (const m of source.matchAll(BLOCK_RE)) {
+    const name = m[1];
+    if (!name) continue;
+    const start = m.index ?? 0;
+    const startLine = lineAt(source, start);
+    symbols.push({
+      name,
+      kind: "component",
+      startLine,
+      endLine: endLineAfter(source, start + m[0].length, ENDBLOCK_RE, startLine),
+      signature: `block ${name}`
+    });
+  }
+  for (const m of source.matchAll(IMPORT_RE)) {
+    const spec = m[1];
+    if (spec) imports.push(spec);
+  }
+  return { file: f, source, symbols, imports: Array.from(new Set(imports)), calls: [] };
+}
+
 // src/scanner/parsers/java.ts
 var QUERY6 = `
 (class_declaration name: (identifier) @class.name) @class
@@ -3012,6 +3063,9 @@ async function parseFile(f) {
       return parseSvelte(f, source);
     case ".vue":
       return parseVue(f, source);
+    case ".html":
+    case ".hubl":
+      return parseHubL(f, source);
     case ".go":
       return parseGo(f, source);
     case ".rs":
@@ -3623,10 +3677,12 @@ function scoreFiles(inputs) {
     }
     const symbols = symbolsByFile.get(file.path) ?? [];
     let symHits = 0;
+    let exactSym = 0;
     for (const sym of symbols) {
       const name = sym.name.toLowerCase();
       if (qTokens.has(name)) {
         symHits += 3;
+        exactSym += 1;
       } else {
         for (const t of qTokens) {
           if (name.includes(t) || t.includes(name)) {
@@ -3651,7 +3707,7 @@ function scoreFiles(inputs) {
       score2 += 5;
       reasons.push("seed");
     }
-    scored.push({ file, score: score2, reasons });
+    scored.push({ file, score: score2, reasons, symHits, exactSym });
   }
   const positivePaths = new Set(scored.filter((s) => s.score > 0).map((s) => s.file.path));
   if (positivePaths.size > 0) {
@@ -3686,7 +3742,8 @@ async function retrieve(graph, query, options = {}) {
     return {
       files: [],
       confidence: "low",
-      reason: qTokens.length === 0 ? "empty query" : "empty graph"
+      reason: qTokens.length === 0 ? "empty query" : "empty graph",
+      symbolMatched: false
     };
   }
   const rankInputs = {
@@ -3702,10 +3759,13 @@ async function retrieve(graph, query, options = {}) {
     return {
       files: [],
       confidence: "low",
-      reason: `no matches for ${JSON.stringify(qTokens)}`
+      reason: `no matches for ${JSON.stringify(qTokens)}`,
+      symbolMatched: false
     };
   }
-  const top = positive.slice(0, topK).map((s) => s.file);
+  const topScored = positive.slice(0, topK);
+  const top = topScored.map((s) => s.file);
+  const symbolMatched = topScored.some((s) => s.exactSym > 0);
   const topScore = positive[0]?.score ?? 0;
   const secondScore = positive[1]?.score ?? 0;
   let confidence;
@@ -3717,7 +3777,8 @@ async function retrieve(graph, query, options = {}) {
   return {
     files: top,
     confidence,
-    reason: `top: ${reasons}`
+    reason: `top: ${reasons}`,
+    symbolMatched
   };
 }
 
@@ -4552,6 +4613,16 @@ function extractQuery(toolName, input) {
   }
   return null;
 }
+function looksLikeNonSymbolQuery(pattern) {
+  if (/<\/?[a-zA-Z]/.test(pattern)) return true;
+  if (/[a-zA-Z][\w-]*-[\w-]*\s*=/.test(pattern)) return true;
+  if (/\{/.test(pattern)) return true;
+  if (/\\\.[a-zA-Z]/.test(pattern)) return true;
+  if (/:\s*\d/.test(pattern) || /\d(?:px|rem|em|vh|vw)\b/.test(pattern) || /\d%/.test(pattern)) {
+    return true;
+  }
+  return false;
+}
 function recentlyTouchedMatchesQuery(recentPaths, queryTokens) {
   const matches = [];
   for (const path of recentPaths) {
@@ -4593,6 +4664,14 @@ async function handleGate(req, ctx) {
     await logDecision(ctx, req.tool_name, null, res2.decision, res2.reason);
     return res2;
   }
+  if (req.tool_name === "Grep" && looksLikeNonSymbolQuery(query)) {
+    const res2 = {
+      decision: "allow",
+      reason: `"${query}" targets markup/CSS/attributes, not code symbols \u2014 letting Grep through (the graph indexes symbols).`
+    };
+    await logDecision(ctx, req.tool_name, query, res2.decision, res2.reason);
+    return res2;
+  }
   const retrieval = await retrieve(ctx.graph, query);
   if (retrieval.confidence === "low") {
     const res2 = {
@@ -4613,6 +4692,14 @@ async function handleGate(req, ctx) {
     await logDecision(ctx, req.tool_name, query, res2.decision, res2.reason);
     return res2;
   }
+  if (!retrieval.symbolMatched) {
+    const res2 = {
+      decision: "allow",
+      reason: `confidence=${retrieval.confidence} but only keyword/path matched (no symbol the query names) \u2014 graph_read can't slice it, letting ${req.tool_name} through.`
+    };
+    await logDecision(ctx, req.tool_name, query, res2.decision, res2.reason);
+    return res2;
+  }
   const top = retrieval.files.slice(0, 3).map((f) => f.path).join(", ");
   const res = {
     decision: "block",