@davesheffer/hunch 1.8.0 → 1.8.2

package/dist/extractors/parse.js

@@ -1,62 +1,25 @@
+import { languageFor } from "./languages.js";
 import { loadNativeTreeSitter } from "./nativeTreeSitter.js";
-const { Parser, typescript, tsx } = loadNativeTreeSitter();
-/** Extremely common builtin/array/object/string/promise method names. Member
- *  calls to these (e.g. `arr.map(...)`) must NOT create call edges to unrelated
- *  repo symbols that happen to share the name (DESIGN: keep the graph clean). */
-const BUILTIN_METHODS = new Set([
-    "map", "filter", "forEach", "reduce", "find", "findIndex", "some", "every", "includes",
-    "push", "pop", "shift", "unshift", "slice", "splice", "concat", "join", "split", "flat", "flatMap",
-    "indexOf", "lastIndexOf", "keys", "values", "entries", "sort", "reverse", "fill", "at",
-    "get", "set", "has", "add", "delete", "clear",
-    "then", "catch", "finally", "all", "race", "resolve", "reject",
-    "toString", "valueOf", "toJSON", "hasOwnProperty",
-    "replace", "replaceAll", "trim", "trimStart", "trimEnd", "padStart", "padEnd", "startsWith", "endsWith",
-    "toLowerCase", "toUpperCase", "charAt", "charCodeAt", "substring", "substr", "repeat", "match", "matchAll",
-    "call", "apply", "bind", "test", "exec", "now", "parse", "stringify", "from", "of", "isArray", "assign",
-    "log", "error", "warn", "info", "debug",
-]);
-/** Tree-sitter query capturing every construct we care about in one pass. */
-const QUERY_SRC = `
-  (function_declaration name: (identifier) @fn.name) @fn.def
-  (generator_function_declaration name: (identifier) @fn.name) @fn.def
-  (method_definition name: (property_identifier) @method.name) @method.def
-  (class_declaration name: (type_identifier) @class.name) @class.def
-  (interface_declaration name: (type_identifier) @iface.name) @iface.def
-  (type_alias_declaration name: (type_identifier) @type.name) @type.def
-  (variable_declarator
-     name: (identifier) @arrow.name
-     value: [(arrow_function) (function_expression)]) @arrow.def
-  (import_statement source: (string) @import.src)
-  (call_expression function: (identifier) @call.id)
-  (call_expression function: (member_expression property: (property_identifier) @call.member))
-`;
+const { Parser } = loadNativeTreeSitter();
 const cache = new Map();
-function bundleFor(lang, key) {
-    let b = cache.get(key);
+function bundleFor(spec) {
+    let b = cache.get(spec.grammarKey);
     if (!b) {
         const parser = new Parser();
-        parser.setLanguage(lang);
-        const query = new Parser.Query(lang, QUERY_SRC);
+        const grammar = spec.loadGrammar();
+        parser.setLanguage(grammar);
+        const query = new Parser.Query(grammar, spec.query);
         b = { parser, query };
-        cache.set(key, b);
+        cache.set(spec.grammarKey, b);
     }
     return b;
 }
-function pickLanguage(file) {
-    if (file.endsWith(".tsx") || file.endsWith(".jsx"))
-        return { lang: tsx, key: "tsx" };
-    if (file.endsWith(".ts") || file.endsWith(".mts") || file.endsWith(".cts"))
-        return { lang: typescript, key: "ts" };
-    if (file.endsWith(".js") || file.endsWith(".mjs") || file.endsWith(".cjs"))
-        return { lang: typescript, key: "ts" };
-    return null;
-}
 const STR_QUOTES = /^['"`]|['"`]$/g;
 export function parseSource(file, source) {
-    const picked = pickLanguage(file);
-    if (!picked)
+    const spec = languageFor(file);
+    if (!spec)
         return null;
-    const { parser, query } = bundleFor(picked.lang, picked.key);
+    const { parser, query } = bundleFor(spec);
     // The native binding caps its scratch buffer at 32 KB unless bufferSize is
     // given — without this, any source >= 32768 bytes throws "Invalid argument"
     // and would abort the whole index run. Guard with try/catch as a backstop.
@@ -73,29 +36,27 @@ export function parseSource(file, source) {
     // 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();
-    const defKind = {
-        "fn.def": "function", "method.def": "method", "class.def": "class",
-        "iface.def": "interface", "type.def": "type", "arrow.def": "function",
-    };
-    const nameToDef = {
-        "fn.name": "fn.def", "method.name": "method.def", "class.name": "class.def",
-        "iface.name": "iface.def", "type.name": "type.def", "arrow.name": "arrow.def",
-    };
     for (const cap of query.captures(tree.rootNode)) {
         const cname = cap.name;
         const node = cap.node;
         if (cname.endsWith(".def")) {
-            pendingDefs.set(node.id, { kind: defKind[cname], def: node });
+            // Keep the FIRST classification a node id receives: a query may have
+            // several patterns matching the same node at different specificity
+            // (e.g. a Python method inside a class body matches both a class-nested
+            // "method.def" pattern and a general "fn.def" pattern — Task 4 relies on
+            // this to classify methods correctly without special-casing Python here).
+            if (!pendingDefs.has(node.id))
+                pendingDefs.set(node.id, { kind: spec.defKindOf[cname], def: node });
         }
-        else if (nameToDef[cname]) {
+        else if (spec.nameToDef[cname]) {
             // name capture: find its parent def node id by walking up to the def type
-            const defNode = ascendToDef(node);
+            const defNode = ascendToDef(node, spec.defNodeTypes);
             if (defNode) {
                 const existing = pendingDefs.get(defNode.id);
                 if (existing)
                     existing.name = node.text;
                 else
-                    pendingDefs.set(defNode.id, { kind: defKind[nameToDef[cname]], def: defNode, name: node.text });
+                    pendingDefs.set(defNode.id, { kind: spec.defKindOf[spec.nameToDef[cname]], def: defNode, name: node.text });
             }
         }
         else if (cname === "import.src") {
@@ -106,7 +67,7 @@ export function parseSource(file, source) {
         }
         else if (cname === "call.member") {
             // skip builtin method names to avoid false edges to similarly-named symbols
-            if (!BUILTIN_METHODS.has(node.text))
+            if (!spec.builtinMethods.has(node.text))
                 calls.push({ callee: node.text, atByte: node.startIndex, endByte: node.endIndex, member: true });
         }
     }
@@ -123,15 +84,11 @@ export function parseSource(file, source) {
     symbols.sort((a, b) => a.startByte - b.startByte);
     return { symbols, imports, calls, parseable: !tree.rootNode.hasError };
 }
-/** Walk up to the nearest node whose type is a definition we recognize. */
-function ascendToDef(node) {
-    const defTypes = new Set([
-        "function_declaration", "generator_function_declaration", "method_definition",
-        "class_declaration", "interface_declaration", "type_alias_declaration", "variable_declarator",
-    ]);
+/** Walk up to the nearest node whose type is a definition this language recognizes. */
+function ascendToDef(node, defNodeTypes) {
     let cur = node.parent;
     while (cur) {
-        if (defTypes.has(cur.type))
+        if (defNodeTypes.has(cur.type))
             return cur;
         cur = cur.parent;
     }

package/dist/integrations/claudemd.js

@@ -35,7 +35,8 @@ export function renderHunchSection(store, root) {
     lines.push("- `hunch_context(target_or_task)` — the minimal relevant slice for what you're about to do; a task phrase falls back to the closest graph matches. **Call FIRST.**");
     lines.push("- `hunch_structure(target?)` — the indexed shape of the repo/dir/file/symbol — orient from the graph, not grep rounds.");
     lines.push("- `hunch_runbook(task)` — the proven steps for a recurring task, before re-deriving them.");
-    lines.push("- `hunch now` (CLI) — recent decisions + the live roadmap.");
+    lines.push("- `hunch_escalations()` — the decisions only the HUMAN can make (topic conflicts, candidate/proposed rules, repaired rules needing a re-prove). Normally empty; when it isn't, ASK the user inline — an entry is a question, never an approval.");
+    lines.push("- `hunch now` (CLI) — recent decisions + the live roadmap; `hunch log` — the memory-move timeline (every capture/adopt/supersede/prune/repair, each revertable).");
     lines.push("");
     lines.push("**Before designing / choosing an approach:**");
     lines.push("- `hunch_why(target)` — why a file/symbol is shaped this way (decisions, bugs, constraints) — including what was already REJECTED.");

package/dist/store/embedder.js

@@ -3,7 +3,7 @@
  * "add embeddings once keyword search proves insufficient" upgrade).
  *
  * Embeddings are LOCAL and FREE. Anthropic has no embeddings endpoint and the
- * project is subscription-only (see synthesis/provider.ts), so we run a small
+ * project avoids implicit metered inference (see synthesis/provider.ts), so we run a small
  * sentence-transformer locally via transformers.js. That library is an OPTIONAL
  * dependency, dynamically imported — if it isn't installed, `selectEmbedder()`
  * returns null and the whole feature degrades to pure FTS (the lean-install