@davesheffer/hunch 1.17.0 → 1.18.0

package/dist/extractors/indexer.js

@@ -11,6 +11,7 @@
 import { readFileSync } from "node:fs";
 import { dirname, join, posix } from "node:path";
 import { parseSource, attributeCalls } from "./parse.js";
+import { extractHelmDirectives } from "./helm.js";
 import { symbolId, componentId, edgeId, sha1 } from "../core/ids.js";
 import { externalImportNodeId, externalPackage } from "../core/externalImports.js";
 import { resolveRelativeImport } from "../core/relativeImports.js";
@@ -54,12 +55,22 @@ export function scanRepo(store, root, opts = {}) {
     const symbols = [];
     const nameIndex = new Map(); // symbol name -> [symbol ids]
     const fileSymbols = new Map(); // file -> symbol ids (in-file resolution)
-    const fileStartByteId = new Map(); // file -> (symbol startByte -> id)
+    const fileSymbolIndexId = new Map(); // file -> (symbol index in parsed.symbols -> id)
     const perFileCalls = [];
     const perFileImports = [];
     // Batched per-file git metrics (churn + last commit) in TWO `git log` spawns
     // total, instead of two per file — the dominant cost of indexing a large repo.
     const rels = files.map((file) => file.path);
+    const chartRootFor = nearestChartRoot(rels);
+    const chartFiles = new Map();
+    for (const path of rels) {
+        if (languageFor(path)?.id !== "yaml")
+            continue;
+        const chartRoot = chartRootFor(path);
+        if (chartRoot === null)
+            continue;
+        (chartFiles.get(chartRoot) ?? chartFiles.set(chartRoot, []).get(chartRoot)).push(path);
+    }
     const gitMeta = useGit ? fileGitMetrics(root, rels, opts.churn === false ? 0 : 90) : null;
     let skipped = 0;
     const issues = [];
@@ -100,20 +111,29 @@ export function scanRepo(store, root, opts = {}) {
             issues.push({ path: rel, code: "parse_failed", detail: `${rel} contains syntax errors and cannot prove a complete semantic graph` });
             continue;
         }
+        const chartRoot = languageFor(rel)?.id === "yaml" ? chartRootFor(rel) : null;
+        // Explicit null check, not truthiness: a chart rooted at the repo root
+        // itself resolves to "" (empty string), which is a valid chart scope but
+        // JS-falsy — `if (chartRoot)` would silently skip every repo-root chart.
+        if (chartRoot !== null) {
+            const helm = extractHelmDirectives(src);
+            parsed.symbols = [...parsed.symbols, ...helm.symbols].sort((a, b) => a.startByte - b.startByte);
+            parsed.calls = [...parsed.calls, ...helm.calls];
+        }
         const m = gitMeta?.get(rel);
         const churn = opts.churn === false ? (preservedChurn.get(rel) ?? 0) : (m?.churn ?? 0);
         const last = m?.lastCommit ?? "";
         const idsInFile = [];
-        const startByteId = new Map();
+        const symbolIndexId = new Map();
         const idCounts = new Map(); // disambiguate same (file,name,kind)
-        for (const ps of parsed.symbols) {
+        for (const [index, ps] of parsed.symbols.entries()) {
             const base = symbolId(rel, ps.name, ps.kind);
             const n = idCounts.get(base) ?? 0;
             idCounts.set(base, n + 1);
             // parse() returns symbols sorted by start byte, so the ordinal is stable
             const id = n === 0 ? base : `${base}_${n}`;
             idsInFile.push(id);
-            startByteId.set(ps.startByte, id);
+            symbolIndexId.set(index, id);
             (nameIndex.get(ps.name) ?? nameIndex.set(ps.name, []).get(ps.name)).push(id);
             symbols.push({
                 id, file: rel, name: ps.name, kind: ps.kind,
@@ -124,16 +144,16 @@ export function scanRepo(store, root, opts = {}) {
             });
         }
         fileSymbols.set(rel, idsInFile);
-        fileStartByteId.set(rel, startByteId);
+        fileSymbolIndexId.set(rel, symbolIndexId);
         perFileCalls.push({ file: rel, bySym: attributeCalls(parsed) });
         perFileImports.push({ file: rel, imports: parsed.imports });
     }
     const byId = new Map(symbols.map((s) => [s.id, s]));
-    // Language-aware import resolution, shared by the call-resolution "was this
-    // name actually imported?" gate (below) and the depends_on edge derivation
-    // (pass 3): a Python cross-file call/import must resolve through the same
-    // relative/absolute Python rules as everything else, not silently fail the
-    // JS/TS resolver and look unimported.
+    // Language-aware import resolution (resolveImportTarget), used by both the
+    // call-resolution gate below (via importedFiles) and the depends_on edge
+    // derivation in pass 3 directly: a Python cross-file call/import must
+    // resolve through the same relative/absolute Python rules as everything
+    // else, not silently fail the JS/TS resolver and look unimported.
     const hasSrcLayout = [...fileSymbols.keys()].some((f) => f.startsWith("src/"));
     const pyRoots = hasSrcLayout ? ["", "src"] : [""];
     const goModule = readGoModulePath(root);
@@ -145,10 +165,17 @@ export function scanRepo(store, root, opts = {}) {
             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)),
-    ]));
+    const importedFiles = new Map(perFileImports.map(({ file, imports }) => {
+        const targets = new Set(imports.map((specifier) => resolveImportTarget(file, specifier)).filter((target) => !!target));
+        const chartRoot = languageFor(file)?.id === "yaml" ? chartRootFor(file) : null;
+        // Explicit null check, not truthiness — see the matching comment above on
+        // the per-file Helm merge step: a repo-root chart's scope is "", not null.
+        if (chartRoot !== null)
+            for (const sibling of chartFiles.get(chartRoot) ?? [])
+                if (sibling !== file)
+                    targets.add(sibling);
+        return [file, targets];
+    }));
     // ---- pass 2: resolve calls -> symbol-level edges -------------------------
     const edges = [];
     const edgeSeen = new Set();
@@ -159,10 +186,14 @@ export function scanRepo(store, root, opts = {}) {
         edges.push(e);
     };
     for (const { file, bySym } of perFileCalls) {
-        const sbToId = fileStartByteId.get(file) ?? new Map();
-        for (const [callerStartByte, callees] of bySym) {
-            // resolve caller by its stable byte-offset identity (not name)
-            const callerId = sbToId.get(callerStartByte);
+        // Most languages leave this unset and get "calls" — YAML's alias->anchor
+        // references aren't function calls, so its LanguageSpec declares "references".
+        const edgeType = languageFor(file)?.referenceEdgeType ?? "calls";
+        const indexToId = fileSymbolIndexId.get(file) ?? new Map();
+        for (const [callerIndex, callees] of bySym) {
+            // resolve caller by its stable position in parsed.symbols (not startByte —
+            // startByte is not unique across symbols; see attributeCalls's doc comment)
+            const callerId = indexToId.get(callerIndex);
             if (!callerId)
                 continue;
             const callerName = byId.get(callerId)?.name ?? "?";
@@ -178,17 +209,21 @@ export function scanRepo(store, root, opts = {}) {
                         continue;
                 }
                 addEdge({
-                    id: edgeId(callerId, calleeId, "calls"),
-                    from: callerId, to: calleeId, type: "calls",
-                    reason: `${callerName} calls ${calleeName}`, strength: 0.8,
+                    schema: "hunch.edge/1",
+                    id: edgeId(callerId, calleeId, edgeType),
+                    from: callerId, to: calleeId, type: edgeType,
+                    reason: `${callerName} ${edgeType} ${calleeName}`, strength: 0.8,
                     provenance: extracted(0.8, [file]),
+                    environment: null,
+                    metadata: {},
                 });
             }
         }
     }
-    // fan-in / fan-out from resolved call edges
+    // fan-in / fan-out from resolved call/reference edges
+    const CALL_LIKE_EDGE_TYPES = new Set(["calls", "references"]);
     for (const e of edges) {
-        if (e.type !== "calls")
+        if (!CALL_LIKE_EDGE_TYPES.has(e.type))
             continue;
         const from = byId.get(e.from);
         const to = byId.get(e.to);
@@ -218,10 +253,13 @@ export function scanRepo(store, root, opts = {}) {
                 if (!toCmp || toCmp === fromCmp)
                     continue;
                 addEdge({
+                    schema: "hunch.edge/1",
                     id: edgeId(fromCmp, toCmp, "depends_on"),
                     from: fromCmp, to: toCmp, type: "depends_on",
                     reason: `${file} imports ${target}`, strength: 0.6,
                     provenance: extracted(0.9, [`${file}:imports:${spec}`]),
+                    environment: null,
+                    metadata: {},
                 });
                 continue;
             }
@@ -232,10 +270,13 @@ export function scanRepo(store, root, opts = {}) {
                 continue;
             for (const anchor of anchors) {
                 addEdge({
+                    schema: "hunch.edge/1",
                     id: edgeId(anchor, external, "imports"),
                     from: anchor, to: external, type: "imports",
                     reason: `${file} imports external package ${dependency}`, strength: 1,
                     provenance: extracted(1, [`${file}:imports:${spec}`]),
+                    environment: null,
+                    metadata: {},
                 });
             }
         }
@@ -291,6 +332,31 @@ export function indexRepo(store, root, opts = {}) {
     return scan.result;
 }
 // ---- helpers --------------------------------------------------------------
+/** Nearest-ancestor Chart.yaml lookup, memoized per directory: walks a file's
+ *  own directory upward through the tracked-file set until it finds
+ *  `<dir>/Chart.yaml`, or returns null if the file isn't under any chart.
+ *  Nested subcharts (their own Chart.yaml under charts/<name>/) resolve to
+ *  their OWN chart root, not the parent's. This is a conservative
+ *  approximation, not full Helm semantics: Helm's template namespace is
+ *  actually release-global, so a parent chart can legitimately include a
+ *  subchart's define — nearest-ancestor scoping will miss that edge rather
+ *  than fabricate a wrong one. No test currently covers the nested
+ *  charts/<sub>/Chart.yaml case — tracked as issue #42. */
+function nearestChartRoot(rels) {
+    const tracked = new Set(rels);
+    const cache = new Map();
+    const resolveDir = (dir) => {
+        if (cache.has(dir))
+            return cache.get(dir);
+        const chartYaml = dir ? `${dir}/Chart.yaml` : "Chart.yaml";
+        const result = tracked.has(chartYaml)
+            ? dir
+            : dir === "" ? null : resolveDir(dir.includes("/") ? dir.slice(0, dir.lastIndexOf("/")) : "");
+        cache.set(dir, result);
+        return result;
+    };
+    return (file) => resolveDir(file.includes("/") ? file.slice(0, file.lastIndexOf("/")) : "");
+}
 /** Resolve a callee name to a symbol id: prefer same-file, otherwise require a
  * unique symbol in a statically imported local file. A unique repository-wide
  * name is not evidence of a binding: callback parameters and built-ins often
@@ -414,12 +480,22 @@ function deriveComponents(symbols) {
     const out = [];
     for (const [dir, fileSet] of groups) {
         const name = dir.split("/").filter(Boolean).pop() ?? dir;
+        // root-level files (dir === ".") have no directory to glob under — list them
+        // exactly rather than emitting "./**", which normalizes to a match-everything
+        // glob (issue #34). A single "*" glob was rejected too: it matches root files
+        // correctly under pathMatchesGlob, but globPrefix("*") is "" and owns() skips
+        // empty prefixes, so the wiki would again own nothing for this component —
+        // the exact failure mode this fix closes. Don't "simplify" this back to a
+        // glob without re-checking both matchers agree. As a consequence, this
+        // component only covers root files present (and symbol-bearing) at the last
+        // index — unlike directory components, a new root file isn't owned until reindex.
+        const paths = dir === "." ? [...fileSet].sort() : [dir.endsWith("/") ? dir + "**" : dir + "/**"];
         out.push({
             id: componentId(dir),
             kind: "module",
             name: capitalize(name),
             responsibility: "",
-            paths: [dir.endsWith("/") ? dir + "**" : dir + "/**"],
+            paths,
             status: "active",
             owners: [],
             fragility: 0,