@opencodehub/ingestion 0.1.0

package/dist/providers/resolution/mro.d.ts

@@ -0,0 +1,16 @@
+import type { MroStrategyName } from "../types.js";
+/**
+ * A linearization strategy for a class's method resolution order.
+ *
+ * @param classId          The id of the class being linearized.
+ * @param bases            Direct base class ids in source order.
+ * @param baseLinearizations Lookup function returning a previously computed
+ *                         linearization for any base id. Strategies that do
+ *                         not recurse (e.g. `none`) may ignore it.
+ */
+export interface MroStrategy {
+    readonly name: MroStrategyName;
+    linearize(classId: string, bases: readonly string[], baseLinearizations: (id: string) => readonly string[]): readonly string[];
+}
+export declare function getMroStrategy(name: MroStrategyName): MroStrategy;
+//# sourceMappingURL=mro.d.ts.map

package/dist/providers/resolution/mro.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"mro.d.ts","sourceRoot":"","sources":["../../../src/providers/resolution/mro.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,aAAa,CAAC;AAMnD;;;;;;;;GAQG;AACH,MAAM,WAAW,WAAW;IAC1B,QAAQ,CAAC,IAAI,EAAE,eAAe,CAAC;IAC/B,SAAS,CACP,OAAO,EAAE,MAAM,EACf,KAAK,EAAE,SAAS,MAAM,EAAE,EACxB,kBAAkB,EAAE,CAAC,EAAE,EAAE,MAAM,KAAK,SAAS,MAAM,EAAE,GACpD,SAAS,MAAM,EAAE,CAAC;CACtB;AASD,wBAAgB,cAAc,CAAC,IAAI,EAAE,eAAe,GAAG,WAAW,CAEjE"}

package/dist/providers/resolution/mro.js

@@ -0,0 +1,14 @@
+import { c3Strategy } from "./c3.js";
+import { firstWinsStrategy } from "./first-wins.js";
+import { noneStrategy } from "./none.js";
+import { singleInheritanceStrategy } from "./single-inheritance.js";
+const STRATEGIES = {
+    c3: c3Strategy,
+    "first-wins": firstWinsStrategy,
+    "single-inheritance": singleInheritanceStrategy,
+    none: noneStrategy,
+};
+export function getMroStrategy(name) {
+    return STRATEGIES[name];
+}
+//# sourceMappingURL=mro.js.map

package/dist/providers/resolution/mro.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"mro.js","sourceRoot":"","sources":["../../../src/providers/resolution/mro.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,UAAU,EAAE,MAAM,SAAS,CAAC;AACrC,OAAO,EAAE,iBAAiB,EAAE,MAAM,iBAAiB,CAAC;AACpD,OAAO,EAAE,YAAY,EAAE,MAAM,WAAW,CAAC;AACzC,OAAO,EAAE,yBAAyB,EAAE,MAAM,yBAAyB,CAAC;AAoBpE,MAAM,UAAU,GAAmD;IACjE,EAAE,EAAE,UAAU;IACd,YAAY,EAAE,iBAAiB;IAC/B,oBAAoB,EAAE,yBAAyB;IAC/C,IAAI,EAAE,YAAY;CACnB,CAAC;AAEF,MAAM,UAAU,cAAc,CAAC,IAAqB;IAClD,OAAO,UAAU,CAAC,IAAI,CAAC,CAAC;AAC1B,CAAC"}

package/dist/providers/resolution/none.d.ts

@@ -0,0 +1,3 @@
+import type { MroStrategy } from "./mro.js";
+export declare const noneStrategy: MroStrategy;
+//# sourceMappingURL=none.d.ts.map

package/dist/providers/resolution/none.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"none.d.ts","sourceRoot":"","sources":["../../../src/providers/resolution/none.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,UAAU,CAAC;AAQ5C,eAAO,MAAM,YAAY,EAAE,WAG1B,CAAC"}

package/dist/providers/resolution/none.js

@@ -0,0 +1,11 @@
+// No-op linearization. Used by languages without classical inheritance
+// (Go — struct embedding is not MRO-shaped). Returns the class itself.
+function linearize(classId) {
+    return [classId];
+}
+const NAME = "none";
+export const noneStrategy = {
+    name: NAME,
+    linearize,
+};
+//# sourceMappingURL=none.js.map

package/dist/providers/resolution/none.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"none.js","sourceRoot":"","sources":["../../../src/providers/resolution/none.ts"],"names":[],"mappings":"AAAA,uEAAuE;AACvE,uEAAuE;AAKvE,SAAS,SAAS,CAAC,OAAe;IAChC,OAAO,CAAC,OAAO,CAAC,CAAC;AACnB,CAAC;AAED,MAAM,IAAI,GAAoB,MAAM,CAAC;AAErC,MAAM,CAAC,MAAM,YAAY,GAAgB;IACvC,IAAI,EAAE,IAAI;IACV,SAAS;CACV,CAAC"}

package/dist/providers/resolution/python-all-filter.d.ts

@@ -0,0 +1,25 @@
+import type { ResolutionCandidate } from "./context.js";
+/**
+ * Parse `__all__ = [...]` from a Python source string.
+ *
+ * Supports three syntactic forms in common use:
+ *   __all__ = ["a", "b"]
+ *   __all__ = ('a', 'b')
+ *   __all__ = ["a", "b",]  # trailing comma
+ *
+ * Returns `null` when no recognisable declaration exists, which the
+ * caller treats as "filter is disabled".
+ */
+export declare function parsePythonAll(source: string): readonly string[] | null;
+/**
+ * Filter resolution candidates against a target module's `__all__` list.
+ *
+ * `targetModuleInitPath` is an absolute path to the module's `__init__.py`
+ * (or the module file itself). If the file can't be read we pass candidates
+ * through — degradation is strictly friendlier than rejection.
+ *
+ * `candidateName` is the bare Python identifier being imported (already
+ * stripped of any `module.` prefix).
+ */
+export declare function filterByPythonAll(candidates: readonly ResolutionCandidate[], targetModuleInitPath: string, candidateName: string): readonly ResolutionCandidate[];
+//# sourceMappingURL=python-all-filter.d.ts.map

package/dist/providers/resolution/python-all-filter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"python-all-filter.d.ts","sourceRoot":"","sources":["../../../src/providers/resolution/python-all-filter.ts"],"names":[],"mappings":"AASA,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,cAAc,CAAC;AAExD;;;;;;;;;;GAUG;AACH,wBAAgB,cAAc,CAAC,MAAM,EAAE,MAAM,GAAG,SAAS,MAAM,EAAE,GAAG,IAAI,CAgBvE;AAED;;;;;;;;;GASG;AACH,wBAAgB,iBAAiB,CAC/B,UAAU,EAAE,SAAS,mBAAmB,EAAE,EAC1C,oBAAoB,EAAE,MAAM,EAC5B,aAAa,EAAE,MAAM,GACpB,SAAS,mBAAmB,EAAE,CAWhC"}

package/dist/providers/resolution/python-all-filter.js

@@ -0,0 +1,64 @@
+// __all__ post-processor for wildcard Python imports.
+//
+// Upstream stack-graphs does not honour `__all__` lists; its edge model
+// makes every top-level def reachable from a wildcard import. When a
+// resolution candidate comes in via a wildcard path and the target
+// module has an `__all__` declaration, we filter candidates down to the
+// listed names only. If no `__all__` is declared we pass everything through.
+import { readFileSync } from "node:fs";
+/**
+ * Parse `__all__ = [...]` from a Python source string.
+ *
+ * Supports three syntactic forms in common use:
+ *   __all__ = ["a", "b"]
+ *   __all__ = ('a', 'b')
+ *   __all__ = ["a", "b",]  # trailing comma
+ *
+ * Returns `null` when no recognisable declaration exists, which the
+ * caller treats as "filter is disabled".
+ */
+export function parsePythonAll(source) {
+    // Regex matches the right-hand-side list/tuple literal. We accept single
+    // or double-quoted string entries; bare identifiers and f-strings are
+    // deliberately ignored — they aren't part of the idiomatic pattern.
+    const m = /__all__\s*=\s*[[(]([\s\S]*?)[\])]/m.exec(source);
+    if (m === null)
+        return null;
+    const body = m[1] ?? "";
+    const names = [];
+    const item = /['"]([A-Za-z_][\w]*)['"]/g;
+    let match = item.exec(body);
+    while (match !== null) {
+        const name = match[1];
+        if (name !== undefined)
+            names.push(name);
+        match = item.exec(body);
+    }
+    return names;
+}
+/**
+ * Filter resolution candidates against a target module's `__all__` list.
+ *
+ * `targetModuleInitPath` is an absolute path to the module's `__init__.py`
+ * (or the module file itself). If the file can't be read we pass candidates
+ * through — degradation is strictly friendlier than rejection.
+ *
+ * `candidateName` is the bare Python identifier being imported (already
+ * stripped of any `module.` prefix).
+ */
+export function filterByPythonAll(candidates, targetModuleInitPath, candidateName) {
+    let source;
+    try {
+        source = readFileSync(targetModuleInitPath, "utf8");
+    }
+    catch {
+        return candidates;
+    }
+    const allowed = parsePythonAll(source);
+    if (allowed === null)
+        return candidates;
+    if (!allowed.includes(candidateName))
+        return [];
+    return candidates;
+}
+//# sourceMappingURL=python-all-filter.js.map

package/dist/providers/resolution/python-all-filter.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"python-all-filter.js","sourceRoot":"","sources":["../../../src/providers/resolution/python-all-filter.ts"],"names":[],"mappings":"AAAA,sDAAsD;AACtD,EAAE;AACF,wEAAwE;AACxE,qEAAqE;AACrE,mEAAmE;AACnE,wEAAwE;AACxE,6EAA6E;AAE7E,OAAO,EAAE,YAAY,EAAE,MAAM,SAAS,CAAC;AAGvC;;;;;;;;;;GAUG;AACH,MAAM,UAAU,cAAc,CAAC,MAAc;IAC3C,yEAAyE;IACzE,sEAAsE;IACtE,oEAAoE;IACpE,MAAM,CAAC,GAAG,oCAAoC,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC;IAC5D,IAAI,CAAC,KAAK,IAAI;QAAE,OAAO,IAAI,CAAC;IAC5B,MAAM,IAAI,GAAG,CAAC,CAAC,CAAC,CAAC,IAAI,EAAE,CAAC;IACxB,MAAM,KAAK,GAAa,EAAE,CAAC;IAC3B,MAAM,IAAI,GAAG,2BAA2B,CAAC;IACzC,IAAI,KAAK,GAA2B,IAAI,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;IACpD,OAAO,KAAK,KAAK,IAAI,EAAE,CAAC;QACtB,MAAM,IAAI,GAAG,KAAK,CAAC,CAAC,CAAC,CAAC;QACtB,IAAI,IAAI,KAAK,SAAS;YAAE,KAAK,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;QACzC,KAAK,GAAG,IAAI,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;IAC1B,CAAC;IACD,OAAO,KAAK,CAAC;AACf,CAAC;AAED;;;;;;;;;GASG;AACH,MAAM,UAAU,iBAAiB,CAC/B,UAA0C,EAC1C,oBAA4B,EAC5B,aAAqB;IAErB,IAAI,MAAc,CAAC;IACnB,IAAI,CAAC;QACH,MAAM,GAAG,YAAY,CAAC,oBAAoB,EAAE,MAAM,CAAC,CAAC;IACtD,CAAC;IAAC,MAAM,CAAC;QACP,OAAO,UAAU,CAAC;IACpB,CAAC;IACD,MAAM,OAAO,GAAG,cAAc,CAAC,MAAM,CAAC,CAAC;IACvC,IAAI,OAAO,KAAK,IAAI;QAAE,OAAO,UAAU,CAAC;IACxC,IAAI,CAAC,OAAO,CAAC,QAAQ,CAAC,aAAa,CAAC;QAAE,OAAO,EAAE,CAAC;IAChD,OAAO,UAAU,CAAC;AACpB,CAAC"}

package/dist/providers/resolution/resolver-strategy.d.ts

@@ -0,0 +1,42 @@
+import type { LanguageProvider } from "../types.js";
+import type { ResolutionCandidate, ResolutionQuery, SymbolIndex } from "./context.js";
+/**
+ * Seam for alternative resolution backends.
+ *
+ * The MVP ships the three-tier walker as the default. v1 added the Python
+ * `stack-graphs` strategy; v2 extends it to the TS family. Both per-language
+ * implementations register under the same public name (`"stack-graphs"`);
+ * the `stackGraphsRouter` below dispatches per query based on
+ * `provider.id`, so a language provider can opt in just by setting
+ * `resolverStrategyName: "stack-graphs"`.
+ */
+export interface ResolverStrategy {
+    readonly name: string;
+    resolve(q: ResolutionQuery, index: SymbolIndex): ResolutionCandidate[];
+}
+export declare const defaultResolver: ResolverStrategy;
+/**
+ * Dispatch to the per-language stack-graphs backend by provider id. Providers
+ * outside the supported set fall through to the three-tier walker. Keeping
+ * the dispatch here means each language can evolve its own builder/cache
+ * without other languages paying any cost at query time.
+ */
+export declare const stackGraphsRouter: ResolverStrategy;
+/**
+ * Registry of all known resolver strategies keyed by the name that a
+ * language provider can opt into. Keeping this as a Record keeps misuses
+ * visible at type level.
+ */
+export declare const RESOLVER_STRATEGIES: Readonly<Record<string, ResolverStrategy>>;
+/**
+ * Resolve the strategy to use for a given language provider.
+ *
+ * Providers may expose an optional `resolverStrategyName` hook. If absent
+ * — or the referenced strategy isn't registered — we return the default
+ * walker. This lets new strategies ship incrementally without a breaking
+ * type-level change on every provider.
+ */
+export declare function getResolver(provider: Pick<LanguageProvider, "id"> & {
+    readonly resolverStrategyName?: string;
+}): ResolverStrategy;
+//# sourceMappingURL=resolver-strategy.d.ts.map

package/dist/providers/resolution/resolver-strategy.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"resolver-strategy.d.ts","sourceRoot":"","sources":["../../../src/providers/resolution/resolver-strategy.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,aAAa,CAAC;AACpD,OAAO,KAAK,EAAE,mBAAmB,EAAE,eAAe,EAAE,WAAW,EAAE,MAAM,cAAc,CAAC;AAKtF;;;;;;;;;GASG;AACH,MAAM,WAAW,gBAAgB;IAC/B,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,OAAO,CAAC,CAAC,EAAE,eAAe,EAAE,KAAK,EAAE,WAAW,GAAG,mBAAmB,EAAE,CAAC;CACxE;AAED,eAAO,MAAM,eAAe,EAAE,gBAG7B,CAAC;AAEF;;;;;GAKG;AACH,eAAO,MAAM,iBAAiB,EAAE,gBAU/B,CAAC;AAEF;;;;GAIG;AACH,eAAO,MAAM,mBAAmB,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,gBAAgB,CAAC,CAG1E,CAAC;AAEF;;;;;;;GAOG;AACH,wBAAgB,WAAW,CACzB,QAAQ,EAAE,IAAI,CAAC,gBAAgB,EAAE,IAAI,CAAC,GAAG;IAAE,QAAQ,CAAC,oBAAoB,CAAC,EAAE,MAAM,CAAA;CAAE,GAClF,gBAAgB,CAKlB"}

package/dist/providers/resolution/resolver-strategy.js

@@ -0,0 +1,50 @@
+import { resolve } from "./context.js";
+import { stackGraphsPythonResolver } from "./stack-graphs-python.js";
+import { stackGraphsTsResolver } from "./stack-graphs-ts.js";
+export const defaultResolver = {
+    name: "three-tier-default",
+    resolve,
+};
+/**
+ * Dispatch to the per-language stack-graphs backend by provider id. Providers
+ * outside the supported set fall through to the three-tier walker. Keeping
+ * the dispatch here means each language can evolve its own builder/cache
+ * without other languages paying any cost at query time.
+ */
+export const stackGraphsRouter = {
+    name: "stack-graphs",
+    resolve(q, index) {
+        const id = q.provider.id;
+        if (id === "python")
+            return stackGraphsPythonResolver.resolve(q, index);
+        if (id === "typescript" || id === "tsx" || id === "javascript") {
+            return stackGraphsTsResolver.resolve(q, index);
+        }
+        return defaultResolver.resolve(q, index);
+    },
+};
+/**
+ * Registry of all known resolver strategies keyed by the name that a
+ * language provider can opt into. Keeping this as a Record keeps misuses
+ * visible at type level.
+ */
+export const RESOLVER_STRATEGIES = {
+    "three-tier-default": defaultResolver,
+    "stack-graphs": stackGraphsRouter,
+};
+/**
+ * Resolve the strategy to use for a given language provider.
+ *
+ * Providers may expose an optional `resolverStrategyName` hook. If absent
+ * — or the referenced strategy isn't registered — we return the default
+ * walker. This lets new strategies ship incrementally without a breaking
+ * type-level change on every provider.
+ */
+export function getResolver(provider) {
+    const requested = provider.resolverStrategyName;
+    if (requested === undefined)
+        return defaultResolver;
+    const strategy = RESOLVER_STRATEGIES[requested];
+    return strategy ?? defaultResolver;
+}
+//# sourceMappingURL=resolver-strategy.js.map

package/dist/providers/resolution/resolver-strategy.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"resolver-strategy.js","sourceRoot":"","sources":["../../../src/providers/resolution/resolver-strategy.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,OAAO,EAAE,MAAM,cAAc,CAAC;AACvC,OAAO,EAAE,yBAAyB,EAAE,MAAM,0BAA0B,CAAC;AACrE,OAAO,EAAE,qBAAqB,EAAE,MAAM,sBAAsB,CAAC;AAiB7D,MAAM,CAAC,MAAM,eAAe,GAAqB;IAC/C,IAAI,EAAE,oBAAoB;IAC1B,OAAO;CACR,CAAC;AAEF;;;;;GAKG;AACH,MAAM,CAAC,MAAM,iBAAiB,GAAqB;IACjD,IAAI,EAAE,cAAc;IACpB,OAAO,CAAC,CAAC,EAAE,KAAK;QACd,MAAM,EAAE,GAAG,CAAC,CAAC,QAAQ,CAAC,EAAE,CAAC;QACzB,IAAI,EAAE,KAAK,QAAQ;YAAE,OAAO,yBAAyB,CAAC,OAAO,CAAC,CAAC,EAAE,KAAK,CAAC,CAAC;QACxE,IAAI,EAAE,KAAK,YAAY,IAAI,EAAE,KAAK,KAAK,IAAI,EAAE,KAAK,YAAY,EAAE,CAAC;YAC/D,OAAO,qBAAqB,CAAC,OAAO,CAAC,CAAC,EAAE,KAAK,CAAC,CAAC;QACjD,CAAC;QACD,OAAO,eAAe,CAAC,OAAO,CAAC,CAAC,EAAE,KAAK,CAAC,CAAC;IAC3C,CAAC;CACF,CAAC;AAEF;;;;GAIG;AACH,MAAM,CAAC,MAAM,mBAAmB,GAA+C;IAC7E,oBAAoB,EAAE,eAAe;IACrC,cAAc,EAAE,iBAAiB;CAClC,CAAC;AAEF;;;;;;;GAOG;AACH,MAAM,UAAU,WAAW,CACzB,QAAmF;IAEnF,MAAM,SAAS,GAAG,QAAQ,CAAC,oBAAoB,CAAC;IAChD,IAAI,SAAS,KAAK,SAAS;QAAE,OAAO,eAAe,CAAC;IACpD,MAAM,QAAQ,GAAG,mBAAmB,CAAC,SAAS,CAAC,CAAC;IAChD,OAAO,QAAQ,IAAI,eAAe,CAAC;AACrC,CAAC"}

package/dist/providers/resolution/single-inheritance.d.ts

@@ -0,0 +1,3 @@
+import type { MroStrategy } from "./mro.js";
+export declare const singleInheritanceStrategy: MroStrategy;
+//# sourceMappingURL=single-inheritance.d.ts.map

package/dist/providers/resolution/single-inheritance.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"single-inheritance.d.ts","sourceRoot":"","sources":["../../../src/providers/resolution/single-inheritance.ts"],"names":[],"mappings":"AAMA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,UAAU,CAAC;AAsB5C,eAAO,MAAM,yBAAyB,EAAE,WAGvC,CAAC"}

package/dist/providers/resolution/single-inheritance.js

@@ -0,0 +1,21 @@
+// Single-inheritance linearization for Java / C# / Kotlin. Walks the single
+// parent chain by concatenating the first (and only) base's linearization.
+// Throws if more than one base is supplied — callers must route interface
+// resolution through a separate mechanism, not this strategy.
+function linearize(classId, bases, baseLinearizations) {
+    if (bases.length > 1) {
+        throw new Error(`single-inheritance strategy received ${bases.length} bases for ${classId}; ` +
+            "this language does not support multiple inheritance.");
+    }
+    const parent = bases[0];
+    if (parent === undefined) {
+        return [classId];
+    }
+    return [classId, ...baseLinearizations(parent)];
+}
+const NAME = "single-inheritance";
+export const singleInheritanceStrategy = {
+    name: NAME,
+    linearize,
+};
+//# sourceMappingURL=single-inheritance.js.map

package/dist/providers/resolution/single-inheritance.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"single-inheritance.js","sourceRoot":"","sources":["../../../src/providers/resolution/single-inheritance.ts"],"names":[],"mappings":"AAAA,4EAA4E;AAC5E,2EAA2E;AAC3E,0EAA0E;AAC1E,8DAA8D;AAK9D,SAAS,SAAS,CAChB,OAAe,EACf,KAAwB,EACxB,kBAAqD;IAErD,IAAI,KAAK,CAAC,MAAM,GAAG,CAAC,EAAE,CAAC;QACrB,MAAM,IAAI,KAAK,CACb,wCAAwC,KAAK,CAAC,MAAM,cAAc,OAAO,IAAI;YAC3E,sDAAsD,CACzD,CAAC;IACJ,CAAC;IACD,MAAM,MAAM,GAAG,KAAK,CAAC,CAAC,CAAC,CAAC;IACxB,IAAI,MAAM,KAAK,SAAS,EAAE,CAAC;QACzB,OAAO,CAAC,OAAO,CAAC,CAAC;IACnB,CAAC;IACD,OAAO,CAAC,OAAO,EAAE,GAAG,kBAAkB,CAAC,MAAM,CAAC,CAAC,CAAC;AAClD,CAAC;AAED,MAAM,IAAI,GAAoB,oBAAoB,CAAC;AAEnD,MAAM,CAAC,MAAM,yBAAyB,GAAgB;IACpD,IAAI,EAAE,IAAI;IACV,SAAS;CACV,CAAC"}

package/dist/providers/resolution/stack-graphs/__fixtures__/mock-tree.d.ts

@@ -0,0 +1,16 @@
+import type { MinimalTsTree } from "../node-edge-builder.js";
+export interface Pos {
+    readonly row: number;
+    readonly column: number;
+}
+export interface MockNodeSpec {
+    readonly type: string;
+    readonly text?: string;
+    readonly start?: Pos;
+    readonly end?: Pos;
+    readonly namedChildren?: readonly MockNodeSpec[];
+    /** Named "fields" (accessed via childForFieldName). */
+    readonly fields?: Readonly<Record<string, MockNodeSpec>>;
+}
+export declare function mockTree(root: MockNodeSpec): MinimalTsTree;
+//# sourceMappingURL=mock-tree.d.ts.map

package/dist/providers/resolution/stack-graphs/__fixtures__/mock-tree.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"mock-tree.d.ts","sourceRoot":"","sources":["../../../../../src/providers/resolution/stack-graphs/__fixtures__/mock-tree.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAiB,aAAa,EAAE,MAAM,yBAAyB,CAAC;AAE5E,MAAM,WAAW,GAAG;IAClB,QAAQ,CAAC,GAAG,EAAE,MAAM,CAAC;IACrB,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;CACzB;AAED,MAAM,WAAW,YAAY;IAC3B,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,IAAI,CAAC,EAAE,MAAM,CAAC;IACvB,QAAQ,CAAC,KAAK,CAAC,EAAE,GAAG,CAAC;IACrB,QAAQ,CAAC,GAAG,CAAC,EAAE,GAAG,CAAC;IACnB,QAAQ,CAAC,aAAa,CAAC,EAAE,SAAS,YAAY,EAAE,CAAC;IACjD,uDAAuD;IACvD,QAAQ,CAAC,MAAM,CAAC,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,YAAY,CAAC,CAAC,CAAC;CAC1D;AA8CD,wBAAgB,QAAQ,CAAC,IAAI,EAAE,YAAY,GAAG,aAAa,CAE1D"}

package/dist/providers/resolution/stack-graphs/__fixtures__/mock-tree.js

@@ -0,0 +1,50 @@
+// Lightweight mock of the tree-sitter Parser.SyntaxNode surface we consume.
+// Only the handful of methods the builder calls are implemented; the rest
+// throw. Fixture trees are hand-assembled in tests.
+class MockNode {
+    spec;
+    _namedChildren;
+    _fields;
+    constructor(spec) {
+        this.spec = spec;
+        this._namedChildren = (spec.namedChildren ?? []).map((c) => new MockNode(c));
+        const fields = new Map();
+        if (spec.fields !== undefined) {
+            for (const [k, v] of Object.entries(spec.fields)) {
+                fields.set(k, new MockNode(v));
+            }
+        }
+        this._fields = fields;
+    }
+    get type() {
+        return this.spec.type;
+    }
+    get text() {
+        return this.spec.text ?? "";
+    }
+    get startPosition() {
+        return this.spec.start ?? { row: 0, column: 0 };
+    }
+    get endPosition() {
+        return this.spec.end ?? this.startPosition;
+    }
+    get childCount() {
+        return this._namedChildren.length;
+    }
+    child(index) {
+        return this._namedChildren[index] ?? null;
+    }
+    childForFieldName(name) {
+        return this._fields.get(name) ?? null;
+    }
+    get namedChildCount() {
+        return this._namedChildren.length;
+    }
+    namedChild(index) {
+        return this._namedChildren[index] ?? null;
+    }
+}
+export function mockTree(root) {
+    return { rootNode: new MockNode(root) };
+}
+//# sourceMappingURL=mock-tree.js.map

package/dist/providers/resolution/stack-graphs/__fixtures__/mock-tree.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"mock-tree.js","sourceRoot":"","sources":["../../../../../src/providers/resolution/stack-graphs/__fixtures__/mock-tree.ts"],"names":[],"mappings":"AAAA,4EAA4E;AAC5E,0EAA0E;AAC1E,oDAAoD;AAmBpD,MAAM,QAAQ;IAIiB;IAHZ,cAAc,CAAsB;IACpC,OAAO,CAAgC;IAExD,YAA6B,IAAkB;QAAlB,SAAI,GAAJ,IAAI,CAAc;QAC7C,IAAI,CAAC,cAAc,GAAG,CAAC,IAAI,CAAC,aAAa,IAAI,EAAE,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,IAAI,QAAQ,CAAC,CAAC,CAAC,CAAC,CAAC;QAC7E,MAAM,MAAM,GAAG,IAAI,GAAG,EAAoB,CAAC;QAC3C,IAAI,IAAI,CAAC,MAAM,KAAK,SAAS,EAAE,CAAC;YAC9B,KAAK,MAAM,CAAC,CAAC,EAAE,CAAC,CAAC,IAAI,MAAM,CAAC,OAAO,CAAC,IAAI,CAAC,MAAM,CAAC,EAAE,CAAC;gBACjD,MAAM,CAAC,GAAG,CAAC,CAAC,EAAE,IAAI,QAAQ,CAAC,CAAC,CAAC,CAAC,CAAC;YACjC,CAAC;QACH,CAAC;QACD,IAAI,CAAC,OAAO,GAAG,MAAM,CAAC;IACxB,CAAC;IAED,IAAI,IAAI;QACN,OAAO,IAAI,CAAC,IAAI,CAAC,IAAI,CAAC;IACxB,CAAC;IACD,IAAI,IAAI;QACN,OAAO,IAAI,CAAC,IAAI,CAAC,IAAI,IAAI,EAAE,CAAC;IAC9B,CAAC;IACD,IAAI,aAAa;QACf,OAAO,IAAI,CAAC,IAAI,CAAC,KAAK,IAAI,EAAE,GAAG,EAAE,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,CAAC;IAClD,CAAC;IACD,IAAI,WAAW;QACb,OAAO,IAAI,CAAC,IAAI,CAAC,GAAG,IAAI,IAAI,CAAC,aAAa,CAAC;IAC7C,CAAC;IACD,IAAI,UAAU;QACZ,OAAO,IAAI,CAAC,cAAc,CAAC,MAAM,CAAC;IACpC,CAAC;IACD,KAAK,CAAC,KAAa;QACjB,OAAO,IAAI,CAAC,cAAc,CAAC,KAAK,CAAC,IAAI,IAAI,CAAC;IAC5C,CAAC;IACD,iBAAiB,CAAC,IAAY;QAC5B,OAAO,IAAI,CAAC,OAAO,CAAC,GAAG,CAAC,IAAI,CAAC,IAAI,IAAI,CAAC;IACxC,CAAC;IACD,IAAI,eAAe;QACjB,OAAO,IAAI,CAAC,cAAc,CAAC,MAAM,CAAC;IACpC,CAAC;IACD,UAAU,CAAC,KAAa;QACtB,OAAO,IAAI,CAAC,cAAc,CAAC,KAAK,CAAC,IAAI,IAAI,CAAC;IAC5C,CAAC;CACF;AAED,MAAM,UAAU,QAAQ,CAAC,IAAkB;IACzC,OAAO,EAAE,QAAQ,EAAE,IAAI,QAAQ,CAAC,IAAI,CAAC,EAAE,CAAC;AAC1C,CAAC"}

package/dist/providers/resolution/stack-graphs/glue.d.ts

@@ -0,0 +1,15 @@
+import { type MinimalTsTree } from "./node-edge-builder.js";
+import { type ParsedTsg } from "./rule-parser.js";
+import type { PartialPathResult, ReferenceQuery, StackGraph, TsgRule } from "./types.js";
+/** Parse the rule file text once. Safe to call repeatedly. */
+export declare function loadRules(source: string): ParsedTsg;
+/** For tests: clear the memoized rule cache. */
+export declare function resetRulesForTests(): void;
+/**
+ * Build one stack-graph per file up front. Callers normally feed in every
+ * Python file in the index so cross-module resolution can hop through ROOT.
+ */
+export declare function buildAllStackGraphs(files: ReadonlyMap<string, MinimalTsTree>, rules: readonly TsgRule[]): ReadonlyMap<string, StackGraph>;
+/** Resolve a single reference, returning path results and truncation info. */
+export declare function resolveViaStackGraphs(query: ReferenceQuery, graphs: ReadonlyMap<string, StackGraph>): PartialPathResult;
+//# sourceMappingURL=glue.d.ts.map

package/dist/providers/resolution/stack-graphs/glue.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"glue.d.ts","sourceRoot":"","sources":["../../../../src/providers/resolution/stack-graphs/glue.ts"],"names":[],"mappings":"AAOA,OAAO,EAAmB,KAAK,aAAa,EAAE,MAAM,wBAAwB,CAAC;AAE7E,OAAO,EAAE,KAAK,SAAS,EAAY,MAAM,kBAAkB,CAAC;AAC5D,OAAO,KAAK,EAAE,iBAAiB,EAAE,cAAc,EAAE,UAAU,EAAE,OAAO,EAAE,MAAM,YAAY,CAAC;AASzF,8DAA8D;AAC9D,wBAAgB,SAAS,CAAC,MAAM,EAAE,MAAM,GAAG,SAAS,CAInD;AAED,gDAAgD;AAChD,wBAAgB,kBAAkB,IAAI,IAAI,CAEzC;AAED;;;GAGG;AACH,wBAAgB,mBAAmB,CACjC,KAAK,EAAE,WAAW,CAAC,MAAM,EAAE,aAAa,CAAC,EACzC,KAAK,EAAE,SAAS,OAAO,EAAE,GACxB,WAAW,CAAC,MAAM,EAAE,UAAU,CAAC,CAMjC;AAED,8EAA8E;AAC9E,wBAAgB,qBAAqB,CACnC,KAAK,EAAE,cAAc,EACrB,MAAM,EAAE,WAAW,CAAC,MAAM,EAAE,UAAU,CAAC,GACtC,iBAAiB,CAOnB"}

package/dist/providers/resolution/stack-graphs/glue.js

@@ -0,0 +1,44 @@
+// Glue layer that wires rule-parser → builder → engine into one entry point.
+//
+// Exposed as a small function set so the per-language resolver strategy can
+// build graphs lazily per file and hand them to the partial-path engine as
+// references get resolved. Nothing here knows about the ResolverStrategy
+// interface — that lives in `stack-graphs-python.ts`.
+import { buildStackGraph } from "./node-edge-builder.js";
+import { resolveReference } from "./partial-path-engine.js";
+import { parseTsg } from "./rule-parser.js";
+const RULES = { parsed: null };
+/** Parse the rule file text once. Safe to call repeatedly. */
+export function loadRules(source) {
+    if (RULES.parsed !== null)
+        return RULES.parsed;
+    RULES.parsed = parseTsg(source);
+    return RULES.parsed;
+}
+/** For tests: clear the memoized rule cache. */
+export function resetRulesForTests() {
+    RULES.parsed = null;
+}
+/**
+ * Build one stack-graph per file up front. Callers normally feed in every
+ * Python file in the index so cross-module resolution can hop through ROOT.
+ */
+export function buildAllStackGraphs(files, rules) {
+    const out = new Map();
+    for (const [file, tree] of files) {
+        out.set(file, buildStackGraph(file, tree, rules));
+    }
+    return out;
+}
+/** Resolve a single reference, returning path results and truncation info. */
+export function resolveViaStackGraphs(query, graphs) {
+    const graph = graphs.get(query.file);
+    if (graph === undefined)
+        return { results: [], truncated: false };
+    const key = `${query.line}:${query.column}`;
+    const refNodeId = graph.referenceIndex.get(key);
+    if (refNodeId === undefined)
+        return { results: [], truncated: false };
+    return resolveReference(graphs, query.file, refNodeId);
+}
+//# sourceMappingURL=glue.js.map

package/dist/providers/resolution/stack-graphs/glue.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"glue.js","sourceRoot":"","sources":["../../../../src/providers/resolution/stack-graphs/glue.ts"],"names":[],"mappings":"AAAA,6EAA6E;AAC7E,EAAE;AACF,4EAA4E;AAC5E,2EAA2E;AAC3E,yEAAyE;AACzE,sDAAsD;AAEtD,OAAO,EAAE,eAAe,EAAsB,MAAM,wBAAwB,CAAC;AAC7E,OAAO,EAAE,gBAAgB,EAAE,MAAM,0BAA0B,CAAC;AAC5D,OAAO,EAAkB,QAAQ,EAAE,MAAM,kBAAkB,CAAC;AAQ5D,MAAM,KAAK,GAAc,EAAE,MAAM,EAAE,IAAI,EAAE,CAAC;AAE1C,8DAA8D;AAC9D,MAAM,UAAU,SAAS,CAAC,MAAc;IACtC,IAAI,KAAK,CAAC,MAAM,KAAK,IAAI;QAAE,OAAO,KAAK,CAAC,MAAM,CAAC;IAC/C,KAAK,CAAC,MAAM,GAAG,QAAQ,CAAC,MAAM,CAAC,CAAC;IAChC,OAAO,KAAK,CAAC,MAAM,CAAC;AACtB,CAAC;AAED,gDAAgD;AAChD,MAAM,UAAU,kBAAkB;IAChC,KAAK,CAAC,MAAM,GAAG,IAAI,CAAC;AACtB,CAAC;AAED;;;GAGG;AACH,MAAM,UAAU,mBAAmB,CACjC,KAAyC,EACzC,KAAyB;IAEzB,MAAM,GAAG,GAAG,IAAI,GAAG,EAAsB,CAAC;IAC1C,KAAK,MAAM,CAAC,IAAI,EAAE,IAAI,CAAC,IAAI,KAAK,EAAE,CAAC;QACjC,GAAG,CAAC,GAAG,CAAC,IAAI,EAAE,eAAe,CAAC,IAAI,EAAE,IAAI,EAAE,KAAK,CAAC,CAAC,CAAC;IACpD,CAAC;IACD,OAAO,GAAG,CAAC;AACb,CAAC;AAED,8EAA8E;AAC9E,MAAM,UAAU,qBAAqB,CACnC,KAAqB,EACrB,MAAuC;IAEvC,MAAM,KAAK,GAAG,MAAM,CAAC,GAAG,CAAC,KAAK,CAAC,IAAI,CAAC,CAAC;IACrC,IAAI,KAAK,KAAK,SAAS;QAAE,OAAO,EAAE,OAAO,EAAE,EAAE,EAAE,SAAS,EAAE,KAAK,EAAE,CAAC;IAClE,MAAM,GAAG,GAAG,GAAG,KAAK,CAAC,IAAI,IAAI,KAAK,CAAC,MAAM,EAAE,CAAC;IAC5C,MAAM,SAAS,GAAG,KAAK,CAAC,cAAc,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC;IAChD,IAAI,SAAS,KAAK,SAAS;QAAE,OAAO,EAAE,OAAO,EAAE,EAAE,EAAE,SAAS,EAAE,KAAK,EAAE,CAAC;IACtE,OAAO,gBAAgB,CAAC,MAAM,EAAE,KAAK,CAAC,IAAI,EAAE,SAAS,CAAC,CAAC;AACzD,CAAC"}

package/dist/providers/resolution/stack-graphs/node-edge-builder.d.ts

@@ -0,0 +1,30 @@
+import type { StackGraph, TsgRule } from "./types.js";
+/**
+ * Minimal view of a tree-sitter node — duck-typed so we can pass either a
+ * real `Parser.SyntaxNode` from tree-sitter or a test fixture. Only the
+ * fields we use are declared; that lets fixtures omit the dozens of other
+ * properties.
+ */
+export interface MinimalTsNode {
+    readonly type: string;
+    readonly text: string;
+    readonly startPosition: {
+        readonly row: number;
+        readonly column: number;
+    };
+    readonly endPosition: {
+        readonly row: number;
+        readonly column: number;
+    };
+    readonly childCount: number;
+    child(index: number): MinimalTsNode | null;
+    childForFieldName(name: string): MinimalTsNode | null;
+    readonly namedChildCount: number;
+    namedChild(index: number): MinimalTsNode | null;
+}
+export interface MinimalTsTree {
+    readonly rootNode: MinimalTsNode;
+}
+/** Build a graph for a single Python file. */
+export declare function buildStackGraph(file: string, tree: MinimalTsTree, rules: readonly TsgRule[]): StackGraph;
+//# sourceMappingURL=node-edge-builder.d.ts.map

package/dist/providers/resolution/stack-graphs/node-edge-builder.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"node-edge-builder.d.ts","sourceRoot":"","sources":["../../../../src/providers/resolution/stack-graphs/node-edge-builder.ts"],"names":[],"mappings":"AAuBA,OAAO,KAAK,EAEV,UAAU,EAIV,OAAO,EACR,MAAM,YAAY,CAAC;AAEpB;;;;;GAKG;AACH,MAAM,WAAW,aAAa;IAC5B,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,aAAa,EAAE;QAAE,QAAQ,CAAC,GAAG,EAAE,MAAM,CAAC;QAAC,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAA;KAAE,CAAC;IAC1E,QAAQ,CAAC,WAAW,EAAE;QAAE,QAAQ,CAAC,GAAG,EAAE,MAAM,CAAC;QAAC,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAA;KAAE,CAAC;IACxE,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAC;IAC5B,KAAK,CAAC,KAAK,EAAE,MAAM,GAAG,aAAa,GAAG,IAAI,CAAC;IAC3C,iBAAiB,CAAC,IAAI,EAAE,MAAM,GAAG,aAAa,GAAG,IAAI,CAAC;IACtD,QAAQ,CAAC,eAAe,EAAE,MAAM,CAAC;IACjC,UAAU,CAAC,KAAK,EAAE,MAAM,GAAG,aAAa,GAAG,IAAI,CAAC;CACjD;AAED,MAAM,WAAW,aAAa;IAC5B,QAAQ,CAAC,QAAQ,EAAE,aAAa,CAAC;CAClC;AA4DD,8CAA8C;AAC9C,wBAAgB,eAAe,CAC7B,IAAI,EAAE,MAAM,EACZ,IAAI,EAAE,aAAa,EACnB,KAAK,EAAE,SAAS,OAAO,EAAE,GACxB,UAAU,CAgCZ"}