@davesheffer/hunch 1.14.0 → 1.15.0

package/dist/extractors/indexer.js

@@ -8,7 +8,8 @@
  * `indexRepo` persists that exact scan into the JSON source of truth; its caller
  * then runs HunchStore.reindex() to refresh the SQLite index.
  */
-import { dirname, posix } from "node:path";
+import { readFileSync } from "node:fs";
+import { dirname, join, posix } from "node:path";
 import { parseSource, attributeCalls } from "./parse.js";
 import { symbolId, componentId, edgeId, sha1 } from "../core/ids.js";
 import { externalImportNodeId, externalPackage } from "../core/externalImports.js";
@@ -135,9 +136,15 @@ export function scanRepo(store, root, opts = {}) {
     // JS/TS resolver and look unimported.
     const hasSrcLayout = [...fileSymbols.keys()].some((f) => f.startsWith("src/"));
     const pyRoots = hasSrcLayout ? ["", "src"] : [""];
-    const resolveImportTarget = (file, spec) => languageFor(file)?.id === "python"
-        ? resolvePythonImport(file, spec, fileSymbols, pyRoots)
-        : resolveImport(file, spec, fileSymbols);
+    const goModule = readGoModulePath(root);
+    const resolveImportTarget = (file, spec) => {
+        const langId = languageFor(file)?.id;
+        if (langId === "python")
+            return resolvePythonImport(file, spec, fileSymbols, pyRoots);
+        if (langId === "go")
+            return resolveGoImport(spec, fileSymbols, goModule);
+        return resolveImport(file, spec, fileSymbols);
+    };
     const importedFiles = new Map(perFileImports.map(({ file, imports }) => [
         file,
         new Set(imports.map((specifier) => resolveImportTarget(file, specifier)).filter((target) => !!target)),
@@ -353,6 +360,48 @@ function resolvePythonImport(fromFile, spec, fileSymbols, pyRoots) {
     const modulePath = baseDir ? `${baseDir}/${tailPath}` : tailPath;
     return firstExistingPyModule(modulePath, fileSymbols);
 }
+/** The `module` path declared in the repo's go.mod, or null. A resolution HINT
+ *  only (it widens depends_on edge coverage); reading it best-effort from the
+ *  filesystem never gates a scan. */
+function readGoModulePath(root) {
+    try {
+        const match = /^module\s+(\S+)/m.exec(readFileSync(join(root, "go.mod"), "utf8"));
+        return match ? match[1] : null;
+    }
+    catch {
+        return null;
+    }
+}
+/** Lexicographically-first tracked .go file whose directory is exactly `dir`
+ *  ("" = repo root) — a Go import names a PACKAGE (directory), so any file in it
+ *  identifies the right component for a depends_on edge. */
+function firstGoFileInDir(dir, fileSymbols) {
+    let best = null;
+    for (const f of fileSymbols.keys()) {
+        if (!f.endsWith(".go"))
+            continue;
+        const d = toPosix(dirname(f));
+        const matches = dir === "" ? d === "." : d === dir;
+        if (matches && (!best || f < best))
+            best = f;
+    }
+    return best;
+}
+/** Resolve a Go import path to a tracked file. Sibling to resolvePythonImport():
+ *  an in-module import is the go.mod module path plus the package directory, so
+ *  strip the declared module prefix and look the directory up exactly; with no
+ *  go.mod, try the path as a repo-relative directory. Anything else (stdlib,
+ *  external modules) resolves to null — no suffix guessing, a wrong depends_on
+ *  edge is worse than a missing one. */
+function resolveGoImport(spec, fileSymbols, goModule) {
+    if (goModule) {
+        if (spec === goModule)
+            return firstGoFileInDir("", fileSymbols);
+        if (spec.startsWith(`${goModule}/`))
+            return firstGoFileInDir(spec.slice(goModule.length + 1), fileSymbols);
+    }
+    return firstGoFileInDir(spec, fileSymbols);
+}
 /** Derive components from the directory layout: the directory immediately under
  *  `src/` (or the top-level dir) groups files into a module component. */
 function deriveComponents(symbols) {

package/dist/extractors/languages.js

@@ -125,7 +125,55 @@ const PYTHON = {
     nameToDef: { "fn.name": "fn.def", "method.name": "method.def", "class.name": "class.def" },
     builtinMethods: PY_BUILTIN_METHODS,
 };
-export const LANGUAGES = [TYPESCRIPT, TSX, PYTHON];
+const GO_QUERY = `
+  (function_declaration name: (identifier) @fn.name) @fn.def
+  (method_declaration name: (field_identifier) @method.name) @method.def
+  ;; Specific type_spec shapes FIRST: parse.ts keeps the first classification a
+  ;; node id receives (same mechanism the Python class patterns rely on), so a
+  ;; struct/interface matches its specific pattern before the generic @type.def.
+  (type_spec name: (type_identifier) @struct.name type: (struct_type)) @struct.def
+  (type_spec name: (type_identifier) @iface.name type: (interface_type)) @iface.def
+  (type_spec name: (type_identifier) @type.name) @type.def
+  ;; \`type X = Y\` is a distinct type_alias node, not a type_spec.
+  (type_alias name: (type_identifier) @type.name) @type.def
+  (import_spec path: [(interpreted_string_literal) (raw_string_literal)] @import.src)
+  (call_expression function: (identifier) @call.id)
+  (call_expression function: (selector_expression field: (field_identifier) @call.member))
+`;
+/** In Go every package-qualified call (fmt.Println, strings.Split, t.Errorf) is a
+ *  selector_expression and therefore lands in @call.member — the DOMINANT call form.
+ *  This allowlist filters the highest-frequency stdlib/testing method+function names
+ *  so they never create false edges to same-named repo symbols; repo-specific member
+ *  calls (s.Run(), h.Handle()) pass through and resolve conservatively like TS/PY. */
+const GO_BUILTIN_METHODS = new Set([
+    "Error", "String", "Read", "Write", "Close", "Len", "Cap", "Reset", "Bytes", "Text",
+    "Scan", "Next", "Err", "Lock", "Unlock", "RLock", "RUnlock", "Done", "Add", "Wait",
+    "Print", "Printf", "Println", "Sprintf", "Fprintf", "Errorf", "Fatal", "Fatalf", "Fatalln",
+    "Log", "Logf", "Helper", "Run", "Parallel", "Skip", "Skipf", "Cleanup",
+    "Get", "Set", "Delete", "Load", "Store", "Range", "Value", "Context", "Deadline",
+    "Marshal", "Unmarshal", "Encode", "Decode", "Parse", "Format", "Sub", "Before", "After",
+    "Join", "Split", "Contains", "Replace", "ReplaceAll", "TrimSpace", "ToLower", "ToUpper",
+    "HasPrefix", "HasSuffix", "WriteString", "ReadString", "ReadAll", "Copy", "New", "Now",
+    "Since", "Sleep", "Unix", "Exec", "Query", "QueryRow", "Begin", "Commit", "Rollback",
+]);
+const GO = {
+    id: "go",
+    extensions: [".go"],
+    grammarKey: "go",
+    loadGrammar: () => loadNativeTreeSitter().go,
+    query: GO_QUERY,
+    defNodeTypes: new Set(["function_declaration", "method_declaration", "type_spec", "type_alias"]),
+    defKindOf: {
+        "fn.def": "function", "method.def": "method", "struct.def": "class",
+        "iface.def": "interface", "type.def": "type",
+    },
+    nameToDef: {
+        "fn.name": "fn.def", "method.name": "method.def", "struct.name": "struct.def",
+        "iface.name": "iface.def", "type.name": "type.def",
+    },
+    builtinMethods: GO_BUILTIN_METHODS,
+};
+export const LANGUAGES = [TYPESCRIPT, TSX, PYTHON, GO];
 export const CODE_EXTENSIONS = [...new Set(LANGUAGES.flatMap((l) => l.extensions))];
 export function languageFor(file) {
     for (const lang of LANGUAGES) {

package/dist/extractors/nativeTreeSitter.js

@@ -4,7 +4,7 @@ import { tmpdir } from "node:os";
 import { basename, dirname, join } from "node:path";
 const runtimeRequire = createRequire(import.meta.url);
 const COPY_PREFIX = "hunch-tree-sitter-";
-const NATIVE_PACKAGES = ["tree-sitter", "tree-sitter-typescript", "tree-sitter-python"];
+const NATIVE_PACKAGES = ["tree-sitter", "tree-sitter-typescript", "tree-sitter-python", "tree-sitter-go"];
 let runtime = null;
 function processIsAlive(pid) {
     if (pid === process.pid)
@@ -69,7 +69,7 @@ export function loadNativeTreeSitter() {
     // underscores (tree_sitter_runtime_binding.node, tree_sitter_python_binding.node,
     // …). Missing the underscore names let an already-loaded source-built addon slip
     // past this guard and defeat the file-lock isolation entirely (issue #52).
-    const preloaded = Object.keys(runtimeRequire.cache).filter((path) => /(?:tree-sitter(?:-typescript|-python)?|tree_sitter(?:_[a-z]+)*_binding)\.node$/.test(path)
+    const preloaded = Object.keys(runtimeRequire.cache).filter((path) => /(?:tree-sitter(?:-typescript|-python|-go)?|tree_sitter(?:_[a-z]+)*_binding)\.node$/.test(path)
         && !new RegExp(`(?:^|[\\\\/])${COPY_PREFIX}\\d+-`).test(path));
     if (preloaded.length) {
         throw new Error(`tree-sitter native addon was loaded before Hunch could isolate it: ${preloaded.join(", ")}`);
@@ -87,7 +87,8 @@ export function loadNativeTreeSitter() {
         const Parser = runtimeRequire("tree-sitter");
         const languages = runtimeRequire("tree-sitter-typescript");
         const python = runtimeRequire("tree-sitter-python");
-        runtime = { Parser, typescript: languages.typescript, tsx: languages.tsx, python };
+        const go = runtimeRequire("tree-sitter-go");
+        runtime = { Parser, typescript: languages.typescript, tsx: languages.tsx, python, go };
     }
     catch (error) {
         try {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@davesheffer/hunch",
-  "version": "1.14.0",
+  "version": "1.15.0",
   "mcpName": "io.github.davesheffer/hunch",
   "license": "Apache-2.0",
   "author": "Dave Sheffer <dave.sheffer1@gmail.com>",
@@ -74,6 +74,7 @@
     "@modelcontextprotocol/sdk": "^1.29.0",
     "commander": "^15.0.0",
     "tree-sitter": "0.21.1",
+    "tree-sitter-go": "^0.23.4",
     "tree-sitter-python": "^0.23.2",
     "tree-sitter-typescript": "^0.23.2",
     "zod": "^4.4.3"

package/server.json

@@ -7,13 +7,13 @@
     "source": "github"
   },
   "websiteUrl": "https://hunch-pi.vercel.app",
-  "version": "1.14.0",
+  "version": "1.15.0",
   "packages": [
     {
       "registryType": "npm",
       "registryBaseUrl": "https://registry.npmjs.org",
       "identifier": "@davesheffer/hunch",
-      "version": "1.14.0",
+      "version": "1.15.0",
       "runtimeHint": "npx",
       "packageArguments": [
         {