@davesheffer/hunch 1.41.0 → 1.41.2

package/dist/extractors/languages.d.ts

@@ -42,12 +42,19 @@ export interface LanguageSpec {
     /** Ancestor shapes in which an ERROR node is a known limitation of THIS grammar
      *  rather than a real syntax error. parse.ts forgives an error only when some
      *  ancestor has type `node` AND that ancestor's own parent has type `parentIs` —
-     *  the pair is what keeps the tolerance narrow. Omit for a language with no known
-     *  grammar false positives; that spec then stays strictly fail-closed. */
+     *  the pair is what keeps the tolerance narrow. `textPattern`, when present,
+     *  must also match that ancestor's text. Omit for a language with no
+     *  known grammar false positives; that spec then stays strictly fail-closed. */
     toleratedErrorScopes?: ReadonlyArray<{
         readonly node: string;
         readonly parentIs: string;
+        readonly textPattern?: RegExp;
     }>;
+    /** Optional same-length recovery used only when the original syntax tree is
+     *  not parseable. A recovered tree may classify structure, but parse.ts reads
+     *  every captured value from the original source at the tree's unchanged
+     *  offsets. Keep replacements syntax-equivalent outside the grammar defect. */
+    parseErrorRecovery?: (source: string) => string;
     /** Patterns whose presence anywhere in the source mean "this isn't actually
      *  {id} text yet — it's a template that renders to {id} later" (Go/Jinja/Helm
      *  delimiters in a .yaml file, e.g.). parse.ts still runs the real parse — a

package/dist/extractors/languages.js

@@ -81,6 +81,19 @@ const TSX = {
     extensions: [".tsx", ".jsx"],
     grammarKey: "tsx",
     loadGrammar: () => loadNativeTreeSitter().tsx,
+    // tree-sitter-javascript rejects a bare ampersand in JSX text even though JSX
+    // accepts it (tree-sitter-javascript#366). The ERROR is a direct jsx_element
+    // child and its text begins at the ampersand. Require both facts plus text that
+    // cannot cross into a tag or expression; real JSX errors beside it remain fail-closed.
+    toleratedErrorScopes: [
+        ...TS_SHARED.toleratedErrorScopes,
+        { node: "ERROR", parentIs: "jsx_element", textPattern: /^&[^<>{}]*$/u },
+    ],
+    // More than one bare ampersand can make the grammar collapse the entire TSX
+    // tree instead of emitting the narrow ERROR above. `|` is accepted as JSX
+    // text and has the same length; in JS/TS syntax it preserves ampersand
+    // operators' arity, so malformed expressions remain malformed on the retry.
+    parseErrorRecovery: (source) => source.replaceAll("&", "|"),
 };
 const PY_QUERY = `
   (class_definition

package/dist/extractors/parse.js

@@ -56,11 +56,35 @@ export function parseSource(file, source, opts = {}) {
             throw error;
         return null;
     }
+    let parseable = isParseable(tree.rootNode, spec);
+    let usingRecoveredTree = false;
+    if (!parseable && spec.parseErrorRecovery) {
+        const recoveredSource = spec.parseErrorRecovery(source);
+        // Offsets from the recovery tree are used against the original source below.
+        // Refuse a misconfigured recovery rather than corrupt captured names/text.
+        if (recoveredSource.length === source.length) {
+            try {
+                const recoveredTree = parser.parse(recoveredSource, undefined, { bufferSize: Math.max(32 * 1024, recoveredSource.length * 2 + 1024) });
+                if (isParseable(recoveredTree.rootNode, spec)) {
+                    tree = recoveredTree;
+                    parseable = true;
+                    usingRecoveredTree = true;
+                }
+            }
+            catch (error) {
+                if (opts.throwOnParseError)
+                    throw error;
+            }
+        }
+    }
     const symbols = [];
     const imports = [];
     const calls = [];
     const relations = [];
     let namespace = null;
+    const originalText = (node) => usingRecoveredTree
+        ? source.slice(node.startIndex, node.endIndex)
+        : node.text;
     // group captures by their enclosing @*.def via a quick pass: we record names
     // keyed by the def node, then emit a symbol per def.
     const pendingDefs = new Map();
@@ -82,30 +106,32 @@ export function parseSource(file, source, opts = {}) {
             if (defNode) {
                 const existing = pendingDefs.get(defNode.id);
                 if (existing)
-                    existing.name = node.text;
+                    existing.name = originalText(node);
                 else
-                    pendingDefs.set(defNode.id, { kind: spec.defKindOf[spec.nameToDef[cname]], def: defNode, name: node.text });
+                    pendingDefs.set(defNode.id, { kind: spec.defKindOf[spec.nameToDef[cname]], def: defNode, name: originalText(node) });
             }
             if (cname === "namespace.name")
-                namespace = node.text;
+                namespace = originalText(node);
         }
         else if (cname === "import.src") {
-            imports.push(node.text.replace(STR_QUOTES, ""));
+            imports.push(originalText(node).replace(STR_QUOTES, ""));
         }
         else if (cname === "call.id") {
-            if (!spec.builtinFunctions?.has(node.text)) {
-                calls.push({ callee: node.text, atByte: node.startIndex, endByte: node.endIndex, member: false });
+            const text = originalText(node);
+            if (!spec.builtinFunctions?.has(text)) {
+                calls.push({ callee: text, atByte: node.startIndex, endByte: node.endIndex, member: false });
             }
         }
         else if (cname === "call.member") {
             // skip builtin method names to avoid false edges to similarly-named symbols
-            if (!spec.builtinMethods.has(node.text))
-                calls.push({ callee: node.text, atByte: node.startIndex, endByte: node.endIndex, member: true });
+            const text = originalText(node);
+            if (!spec.builtinMethods.has(text))
+                calls.push({ callee: text, atByte: node.startIndex, endByte: node.endIndex, member: true });
         }
         else if (spec.relationKindOf?.[cname]) {
             const relation = spec.relationKindOf[cname];
             relations.push({
-                target: node.text,
+                target: originalText(node),
                 atByte: node.startIndex,
                 endByte: node.endIndex,
                 edgeType: relation.edgeType,
@@ -121,7 +147,7 @@ export function parseSource(file, source, opts = {}) {
         symbols.push({
             name: resolvedName, kind,
             startByte: def.startIndex, endByte: def.endIndex, loc,
-            bodyText: def.text.slice(0, MAX_BODY_TEXT_CHARS),
+            bodyText: originalText(def).slice(0, MAX_BODY_TEXT_CHARS),
         });
     }
     // Every other successfully-parsed YAML file gets at least a file-root symbol
@@ -141,7 +167,7 @@ export function parseSource(file, source, opts = {}) {
         });
     }
     symbols.sort((a, b) => a.startByte - b.startByte);
-    return { symbols, imports, calls, relations, namespace, parseable: templated || isParseable(tree.rootNode, spec) };
+    return { symbols, imports, calls, relations, namespace, parseable: templated || parseable };
 }
 /** True when every ERROR/MISSING node in the tree sits in an ancestor shape this
  *  language declares as a known grammar limitation (LanguageSpec.toleratedErrorScopes).
@@ -177,9 +203,11 @@ function isParseable(root, spec) {
     return ok;
 }
 function inToleratedScope(node, scopes) {
-    for (let ancestor = node.parent; ancestor; ancestor = ancestor.parent) {
+    for (let ancestor = node; ancestor; ancestor = ancestor.parent) {
         for (const scope of scopes) {
-            if (ancestor.type === scope.node && ancestor.parent?.type === scope.parentIs)
+            if (ancestor.type === scope.node
+                && ancestor.parent?.type === scope.parentIs
+                && (!scope.textPattern || ancestor.text.search(scope.textPattern) !== -1))
                 return true;
         }
     }

package/dist/store/changeLedger.js

@@ -170,8 +170,14 @@ export function mergeLedgers(base, ours, theirs) {
         seen.set(k, e);
         order.push(e);
     } };
-    for (const e of base?.events ?? [])
-        add(e);
+    const ourIdentities = new Set(ours.events.map(eventIdentity));
+    const theirIdentities = new Set(theirs.events.map(eventIdentity));
+    // Base is a merge ancestor, not a source of history both clones have compacted away.
+    for (const e of base?.events ?? []) {
+        const key = eventIdentity(e);
+        if (ourIdentities.has(key) || theirIdentities.has(key) || (e.seq > ours.floor_seq && e.seq > theirs.floor_seq))
+            add(e);
+    }
     for (const e of ours.events)
         add(e);
     for (const e of theirs.events)
@@ -180,7 +186,6 @@ export function mergeLedgers(base, ours, theirs) {
     // side 1 iff theirs holds it and neither ours nor base does. Deciding by object identity
     // (`includes`) would instead put anything ours compacted away — base's object, which `add`
     // keeps — after its same-`at` siblings and silently reorder a batch both sides already had.
-    const ourIdentities = new Set(ours.events.map(eventIdentity));
     const baseIdentities = new Set((base?.events ?? []).map(eventIdentity));
     const theirsOnly = (e) => {
         const k = eventIdentity(e);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@davesheffer/hunch",
-  "version": "1.41.0",
+  "version": "1.41.2",
   "mcpName": "io.github.davesheffer/hunch",
   "license": "Apache-2.0",
   "author": "Dave Sheffer <dave.sheffer1@gmail.com>",

package/server.json

@@ -7,13 +7,13 @@
     "source": "github"
   },
   "websiteUrl": "https://www.hunchmemory.com",
-  "version": "1.41.0",
+  "version": "1.41.2",
   "packages": [
     {
       "registryType": "npm",
       "registryBaseUrl": "https://registry.npmjs.org",
       "identifier": "@davesheffer/hunch",
-      "version": "1.41.0",
+      "version": "1.41.2",
       "runtimeHint": "npx",
       "packageArguments": [
         {