@opensip-cli/graph-adapter-common 0.1.0

package/dist/index.d.ts

@@ -0,0 +1,26 @@
+/**
+ * @opensip-cli/graph-adapter-common — shared scaffolding for the
+ * tree-sitter graph language adapters (graph-go, graph-java,
+ * graph-python, graph-rust).
+ *
+ * This is a *helper layer for implementing* the engine's
+ * `GraphLanguageAdapter` contract, not a change to it. It sits downstream
+ * of `@opensip-cli/graph` (the engine) and upstream of the four
+ * tree-sitter adapters:
+ *
+ *   core → … → graph (engine) → graph-adapter-common → graph-{go,java,python,rust}
+ *
+ * It exports `createX` factories that return values; the adapter composes
+ * them. It exports NO `adapter` / `metadata` — it is a library, not a
+ * discoverable graph adapter (its package.json deliberately omits
+ * `opensipTools.kind`). `graph-typescript` (TS-compiler-backed, not
+ * tree-sitter) shares none of this and must not depend on it.
+ */
+export { createDiscover, type TreeSitterDiscoverConfig } from './discover.js';
+export { type TreeSitterParsedFile, type TreeSitterParsedProject } from './parse.js';
+export { createParseProjectFromAdapter } from './parse-from-adapter.js';
+export { hashConfig, makeConfigCacheKey } from './cache-key.js';
+export { skipToEndOfLine, skipBlockComment } from './body-digest.js';
+export { isReturnValueDiscarded } from './return-discarded.js';
+export { record, makeFileClassifier, type FileClassifier, type FileClassifierConfig, runWalk, type RunWalkParams, type WalkSinks, synthesizeModuleInit, type SynthesizeModuleInitParams, buildNameIndex, nameOf, childrenOf, namedChildrenOf, } from './walk.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;GAiBG;AAEH,OAAO,EAAE,cAAc,EAAE,KAAK,wBAAwB,EAAE,MAAM,eAAe,CAAC;AAE9E,OAAO,EAAE,KAAK,oBAAoB,EAAE,KAAK,uBAAuB,EAAE,MAAM,YAAY,CAAC;AAErF,OAAO,EAAE,6BAA6B,EAAE,MAAM,yBAAyB,CAAC;AAExE,OAAO,EAAE,UAAU,EAAE,kBAAkB,EAAE,MAAM,gBAAgB,CAAC;AAEhE,OAAO,EAAE,eAAe,EAAE,gBAAgB,EAAE,MAAM,kBAAkB,CAAC;AAErE,OAAO,EAAE,sBAAsB,EAAE,MAAM,uBAAuB,CAAC;AAE/D,OAAO,EACL,MAAM,EACN,kBAAkB,EAClB,KAAK,cAAc,EACnB,KAAK,oBAAoB,EACzB,OAAO,EACP,KAAK,aAAa,EAClB,KAAK,SAAS,EACd,oBAAoB,EACpB,KAAK,0BAA0B,EAC/B,cAAc,EACd,MAAM,EACN,UAAU,EACV,eAAe,GAChB,MAAM,WAAW,CAAC"}

package/dist/index.js

@@ -0,0 +1,25 @@
+/**
+ * @opensip-cli/graph-adapter-common — shared scaffolding for the
+ * tree-sitter graph language adapters (graph-go, graph-java,
+ * graph-python, graph-rust).
+ *
+ * This is a *helper layer for implementing* the engine's
+ * `GraphLanguageAdapter` contract, not a change to it. It sits downstream
+ * of `@opensip-cli/graph` (the engine) and upstream of the four
+ * tree-sitter adapters:
+ *
+ *   core → … → graph (engine) → graph-adapter-common → graph-{go,java,python,rust}
+ *
+ * It exports `createX` factories that return values; the adapter composes
+ * them. It exports NO `adapter` / `metadata` — it is a library, not a
+ * discoverable graph adapter (its package.json deliberately omits
+ * `opensipTools.kind`). `graph-typescript` (TS-compiler-backed, not
+ * tree-sitter) shares none of this and must not depend on it.
+ */
+export { createDiscover } from './discover.js';
+export { createParseProjectFromAdapter } from './parse-from-adapter.js';
+export { hashConfig, makeConfigCacheKey } from './cache-key.js';
+export { skipToEndOfLine, skipBlockComment } from './body-digest.js';
+export { isReturnValueDiscarded } from './return-discarded.js';
+export { record, makeFileClassifier, runWalk, synthesizeModuleInit, buildNameIndex, nameOf, childrenOf, namedChildrenOf, } from './walk.js';
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;GAiBG;AAEH,OAAO,EAAE,cAAc,EAAiC,MAAM,eAAe,CAAC;AAI9E,OAAO,EAAE,6BAA6B,EAAE,MAAM,yBAAyB,CAAC;AAExE,OAAO,EAAE,UAAU,EAAE,kBAAkB,EAAE,MAAM,gBAAgB,CAAC;AAEhE,OAAO,EAAE,eAAe,EAAE,gBAAgB,EAAE,MAAM,kBAAkB,CAAC;AAErE,OAAO,EAAE,sBAAsB,EAAE,MAAM,uBAAuB,CAAC;AAE/D,OAAO,EACL,MAAM,EACN,kBAAkB,EAGlB,OAAO,EAGP,oBAAoB,EAEpB,cAAc,EACd,MAAM,EACN,UAAU,EACV,eAAe,GAChB,MAAM,WAAW,CAAC"}

package/dist/parse-from-adapter.d.ts

@@ -0,0 +1,24 @@
+/**
+ * `parseProject` driver that sources each file's parse from a
+ * `LanguageAdapter` (ADR-0010) instead of an inline grammar-bound parser.
+ * It is byte-for-byte equivalent to `createTreeSitterParseProject`'s loop —
+ * same read, same `ParseError` messages, same `hasError` "record but keep the
+ * partial tree" behavior, same completion log — but the per-file parse is
+ * `adapter.parse(source, path)`. This is what lets the graph Python adapter
+ * consume `@opensip-cli/lang-python` so there is one parser per language.
+ *
+ * Total over `input.files` per invariant I-7: every file either parses or
+ * surfaces in `parseErrors`. The adapter's `parse` is synchronous (its grammar
+ * loads at module top level), so `parseProject` stays synchronous.
+ */
+import type { TreeSitterParsedProject } from './parse.js';
+import type { LanguageAdapter } from '@opensip-cli/core';
+import type { ParseInput, ParseOutput } from '@opensip-cli/graph';
+import type { ParsedFile } from '@opensip-cli/tree-sitter';
+/**
+ * Build a graph `parseProject` from a tree-sitter-backed `LanguageAdapter`
+ * (one whose `parse` returns the `{ tree, source }` `ParsedFile` shape). The
+ * adapter's `id` is the `graph:parse:<id>` log-tag suffix.
+ */
+export declare function createParseProjectFromAdapter(adapter: LanguageAdapter<ParsedFile>): (input: ParseInput) => ParseOutput<TreeSitterParsedProject>;
+//# sourceMappingURL=parse-from-adapter.d.ts.map

package/dist/parse-from-adapter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"parse-from-adapter.d.ts","sourceRoot":"","sources":["../src/parse-from-adapter.ts"],"names":[],"mappings":"AACA;;;;;;;;;;;;GAYG;AAOH,OAAO,KAAK,EAAwB,uBAAuB,EAAE,MAAM,YAAY,CAAC;AAChF,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,mBAAmB,CAAC;AACzD,OAAO,KAAK,EAAE,UAAU,EAAE,WAAW,EAAc,MAAM,oBAAoB,CAAC;AAC9E,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,0BAA0B,CAAC;AAE3D;;;;GAIG;AACH,wBAAgB,6BAA6B,CAC3C,OAAO,EAAE,eAAe,CAAC,UAAU,CAAC,GACnC,CAAC,KAAK,EAAE,UAAU,KAAK,WAAW,CAAC,uBAAuB,CAAC,CA2D7D"}

package/dist/parse-from-adapter.js

@@ -0,0 +1,81 @@
+// @fitness-ignore-file unbounded-memory -- reads source files one at a time; per-file memory bounded by source size (tree-sitter constraint)
+/**
+ * `parseProject` driver that sources each file's parse from a
+ * `LanguageAdapter` (ADR-0010) instead of an inline grammar-bound parser.
+ * It is byte-for-byte equivalent to `createTreeSitterParseProject`'s loop —
+ * same read, same `ParseError` messages, same `hasError` "record but keep the
+ * partial tree" behavior, same completion log — but the per-file parse is
+ * `adapter.parse(source, path)`. This is what lets the graph Python adapter
+ * consume `@opensip-cli/lang-python` so there is one parser per language.
+ *
+ * Total over `input.files` per invariant I-7: every file either parses or
+ * surfaces in `parseErrors`. The adapter's `parse` is synchronous (its grammar
+ * loads at module top level), so `parseProject` stays synchronous.
+ */
+import { readFileSync } from 'node:fs';
+import { relative } from 'node:path';
+import { logger } from '@opensip-cli/core';
+/**
+ * Build a graph `parseProject` from a tree-sitter-backed `LanguageAdapter`
+ * (one whose `parse` returns the `{ tree, source }` `ParsedFile` shape). The
+ * adapter's `id` is the `graph:parse:<id>` log-tag suffix.
+ */
+export function createParseProjectFromAdapter(adapter) {
+    const module = `graph:parse:${adapter.id}`;
+    return function parseProject(input) {
+        const files = new Map();
+        const parseErrors = [];
+        for (const path of input.files) {
+            let source;
+            /* v8 ignore start */
+            try {
+                source = readFileSync(path, 'utf8');
+            }
+            catch (error) {
+                parseErrors.push({
+                    filePath: relative(input.projectDirAbs, path),
+                    message: `read failed: ${error instanceof Error ? error.message : String(error)}`,
+                });
+                continue;
+            }
+            /* v8 ignore stop */
+            let parsed;
+            /* v8 ignore start */
+            try {
+                parsed = adapter.parse(source, path);
+            }
+            catch (error) {
+                parseErrors.push({
+                    filePath: relative(input.projectDirAbs, path),
+                    message: error instanceof Error ? error.message : String(error),
+                });
+                continue;
+            }
+            /* v8 ignore stop */
+            /* v8 ignore start */
+            if (parsed === null) {
+                parseErrors.push({
+                    filePath: relative(input.projectDirAbs, path),
+                    message: 'tree-sitter returned no tree',
+                });
+                continue;
+            }
+            /* v8 ignore stop */
+            if (parsed.tree.rootNode.hasError) {
+                parseErrors.push({
+                    filePath: relative(input.projectDirAbs, path),
+                    message: 'tree-sitter reported syntax errors; partial tree retained',
+                });
+            }
+            files.set(path, parsed);
+        }
+        logger.info({
+            evt: 'graph.parse.complete',
+            module,
+            files: files.size,
+            parseErrors: parseErrors.length,
+        });
+        return { project: { files }, parseErrors };
+    };
+}
+//# sourceMappingURL=parse-from-adapter.js.map

package/dist/parse-from-adapter.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"parse-from-adapter.js","sourceRoot":"","sources":["../src/parse-from-adapter.ts"],"names":[],"mappings":"AAAA,6IAA6I;AAC7I;;;;;;;;;;;;GAYG;AAEH,OAAO,EAAE,YAAY,EAAE,MAAM,SAAS,CAAC;AACvC,OAAO,EAAE,QAAQ,EAAE,MAAM,WAAW,CAAC;AAErC,OAAO,EAAE,MAAM,EAAE,MAAM,mBAAmB,CAAC;AAO3C;;;;GAIG;AACH,MAAM,UAAU,6BAA6B,CAC3C,OAAoC;IAEpC,MAAM,MAAM,GAAG,eAAe,OAAO,CAAC,EAAE,EAAE,CAAC;IAE3C,OAAO,SAAS,YAAY,CAAC,KAAiB;QAC5C,MAAM,KAAK,GAAG,IAAI,GAAG,EAAgC,CAAC;QACtD,MAAM,WAAW,GAAiB,EAAE,CAAC;QAErC,KAAK,MAAM,IAAI,IAAI,KAAK,CAAC,KAAK,EAAE,CAAC;YAC/B,IAAI,MAAc,CAAC;YACnB,qBAAqB;YACrB,IAAI,CAAC;gBACH,MAAM,GAAG,YAAY,CAAC,IAAI,EAAE,MAAM,CAAC,CAAC;YACtC,CAAC;YAAC,OAAO,KAAK,EAAE,CAAC;gBACf,WAAW,CAAC,IAAI,CAAC;oBACf,QAAQ,EAAE,QAAQ,CAAC,KAAK,CAAC,aAAa,EAAE,IAAI,CAAC;oBAC7C,OAAO,EAAE,gBAAgB,KAAK,YAAY,KAAK,CAAC,CAAC,CAAC,KAAK,CAAC,OAAO,CAAC,CAAC,CAAC,MAAM,CAAC,KAAK,CAAC,EAAE;iBAClF,CAAC,CAAC;gBACH,SAAS;YACX,CAAC;YACD,oBAAoB;YACpB,IAAI,MAAyB,CAAC;YAC9B,qBAAqB;YACrB,IAAI,CAAC;gBACH,MAAM,GAAG,OAAO,CAAC,KAAK,CAAC,MAAM,EAAE,IAAI,CAAC,CAAC;YACvC,CAAC;YAAC,OAAO,KAAK,EAAE,CAAC;gBACf,WAAW,CAAC,IAAI,CAAC;oBACf,QAAQ,EAAE,QAAQ,CAAC,KAAK,CAAC,aAAa,EAAE,IAAI,CAAC;oBAC7C,OAAO,EAAE,KAAK,YAAY,KAAK,CAAC,CAAC,CAAC,KAAK,CAAC,OAAO,CAAC,CAAC,CAAC,MAAM,CAAC,KAAK,CAAC;iBAChE,CAAC,CAAC;gBACH,SAAS;YACX,CAAC;YACD,oBAAoB;YACpB,qBAAqB;YACrB,IAAI,MAAM,KAAK,IAAI,EAAE,CAAC;gBACpB,WAAW,CAAC,IAAI,CAAC;oBACf,QAAQ,EAAE,QAAQ,CAAC,KAAK,CAAC,aAAa,EAAE,IAAI,CAAC;oBAC7C,OAAO,EAAE,8BAA8B;iBACxC,CAAC,CAAC;gBACH,SAAS;YACX,CAAC;YACD,oBAAoB;YACpB,IAAI,MAAM,CAAC,IAAI,CAAC,QAAQ,CAAC,QAAQ,EAAE,CAAC;gBAClC,WAAW,CAAC,IAAI,CAAC;oBACf,QAAQ,EAAE,QAAQ,CAAC,KAAK,CAAC,aAAa,EAAE,IAAI,CAAC;oBAC7C,OAAO,EAAE,2DAA2D;iBACrE,CAAC,CAAC;YACL,CAAC;YACD,KAAK,CAAC,GAAG,CAAC,IAAI,EAAE,MAAM,CAAC,CAAC;QAC1B,CAAC;QAED,MAAM,CAAC,IAAI,CAAC;YACV,GAAG,EAAE,sBAAsB;YAC3B,MAAM;YACN,KAAK,EAAE,KAAK,CAAC,IAAI;YACjB,WAAW,EAAE,WAAW,CAAC,MAAM;SAChC,CAAC,CAAC;QAEH,OAAO,EAAE,OAAO,EAAE,EAAE,KAAK,EAAE,EAAE,WAAW,EAAE,CAAC;IAC7C,CAAC,CAAC;AACJ,CAAC"}

package/dist/parse.d.ts

@@ -0,0 +1,24 @@
+/**
+ * Parsed-project type surface for the tree-sitter graph adapters.
+ *
+ * ADR-0010 (rollout complete): all four tree-sitter adapters (python, rust, go,
+ * java) now parse via their `@opensip-cli/lang-*` package through
+ * `createParseProjectFromAdapter` (see ./parse-from-adapter.ts). The former
+ * grammar-bound `createTreeSitterParseProject` driver — and its `Parser.init()`
+ * seam — have been removed; this module is reduced to the two nominal types the
+ * adapters and the walk/resolve scaffolding still share. The parsed-file shape
+ * is sourced from the canonical substrate so graph-adapter-common no longer
+ * depends on `web-tree-sitter`.
+ */
+import type { ParsedFile } from '@opensip-cli/tree-sitter';
+/**
+ * The parsed-file shape every tree-sitter adapter uses: the parse tree plus the
+ * original source text (held so body slices can be extracted for hashing
+ * without re-parsing). Identical to the substrate's `ParsedFile`.
+ */
+export type TreeSitterParsedFile = ParsedFile;
+/** A parsed tree-sitter project: map of absolute file path → parsed file. */
+export interface TreeSitterParsedProject<F extends TreeSitterParsedFile = TreeSitterParsedFile> {
+    readonly files: ReadonlyMap<string, F>;
+}
+//# sourceMappingURL=parse.d.ts.map

package/dist/parse.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"parse.d.ts","sourceRoot":"","sources":["../src/parse.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AAEH,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,0BAA0B,CAAC;AAE3D;;;;GAIG;AACH,MAAM,MAAM,oBAAoB,GAAG,UAAU,CAAC;AAE9C,6EAA6E;AAC7E,MAAM,WAAW,uBAAuB,CAAC,CAAC,SAAS,oBAAoB,GAAG,oBAAoB;IAC5F,QAAQ,CAAC,KAAK,EAAE,WAAW,CAAC,MAAM,EAAE,CAAC,CAAC,CAAC;CACxC"}

package/dist/parse.js

@@ -0,0 +1,14 @@
+/**
+ * Parsed-project type surface for the tree-sitter graph adapters.
+ *
+ * ADR-0010 (rollout complete): all four tree-sitter adapters (python, rust, go,
+ * java) now parse via their `@opensip-cli/lang-*` package through
+ * `createParseProjectFromAdapter` (see ./parse-from-adapter.ts). The former
+ * grammar-bound `createTreeSitterParseProject` driver — and its `Parser.init()`
+ * seam — have been removed; this module is reduced to the two nominal types the
+ * adapters and the walk/resolve scaffolding still share. The parsed-file shape
+ * is sourced from the canonical substrate so graph-adapter-common no longer
+ * depends on `web-tree-sitter`.
+ */
+export {};
+//# sourceMappingURL=parse.js.map

package/dist/parse.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"parse.js","sourceRoot":"","sources":["../src/parse.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG"}

package/dist/return-discarded.d.ts

@@ -0,0 +1,22 @@
+/**
+ * Shared "is the return value discarded?" predicate for the tree-sitter
+ * adapters.
+ *
+ * The base shape is byte-identical across the adapters whose call sites
+ * only ever discard via a bare `expression_statement` (Java, Rust): a
+ * call expression's return value is discarded when the call is the entire
+ * expression of an enclosing `expression_statement`. Parenthesized
+ * wrappers are transparent and walked through.
+ *
+ * Adapters with extra discard shapes (Go's `go`/`defer` statements,
+ * Python's `await` wrapper) keep their own variant — only the common
+ * Java/Rust form lives here.
+ */
+import type { Node } from '@opensip-cli/tree-sitter';
+/**
+ * The call's return value is discarded when the call expression is the
+ * entire expression of an enclosing `expression_statement`.
+ * `parenthesized_expression` wrappers are transparent.
+ */
+export declare function isReturnValueDiscarded(node: Node): boolean;
+//# sourceMappingURL=return-discarded.d.ts.map

package/dist/return-discarded.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"return-discarded.d.ts","sourceRoot":"","sources":["../src/return-discarded.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AAEH,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,0BAA0B,CAAC;AAErD;;;;GAIG;AACH,wBAAgB,sBAAsB,CAAC,IAAI,EAAE,IAAI,GAAG,OAAO,CAU1D"}

package/dist/return-discarded.js

@@ -0,0 +1,31 @@
+/**
+ * Shared "is the return value discarded?" predicate for the tree-sitter
+ * adapters.
+ *
+ * The base shape is byte-identical across the adapters whose call sites
+ * only ever discard via a bare `expression_statement` (Java, Rust): a
+ * call expression's return value is discarded when the call is the entire
+ * expression of an enclosing `expression_statement`. Parenthesized
+ * wrappers are transparent and walked through.
+ *
+ * Adapters with extra discard shapes (Go's `go`/`defer` statements,
+ * Python's `await` wrapper) keep their own variant — only the common
+ * Java/Rust form lives here.
+ */
+/**
+ * The call's return value is discarded when the call expression is the
+ * entire expression of an enclosing `expression_statement`.
+ * `parenthesized_expression` wrappers are transparent.
+ */
+export function isReturnValueDiscarded(node) {
+    let parent = node.parent;
+    while (parent) {
+        if (parent.type === 'parenthesized_expression') {
+            parent = parent.parent;
+            continue;
+        }
+        return parent.type === 'expression_statement';
+    }
+    return false;
+}
+//# sourceMappingURL=return-discarded.js.map

package/dist/return-discarded.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"return-discarded.js","sourceRoot":"","sources":["../src/return-discarded.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AAIH;;;;GAIG;AACH,MAAM,UAAU,sBAAsB,CAAC,IAAU;IAC/C,IAAI,MAAM,GAAgB,IAAI,CAAC,MAAM,CAAC;IACtC,OAAO,MAAM,EAAE,CAAC;QACd,IAAI,MAAM,CAAC,IAAI,KAAK,0BAA0B,EAAE,CAAC;YAC/C,MAAM,GAAG,MAAM,CAAC,MAAM,CAAC;YACvB,SAAS;QACX,CAAC;QACD,OAAO,MAAM,CAAC,IAAI,KAAK,sBAAsB,CAAC;IAChD,CAAC;IACD,OAAO,KAAK,CAAC;AACf,CAAC"}

package/dist/walk.d.ts

@@ -0,0 +1,108 @@
+/**
+ * Shared walk scaffolding for the tree-sitter adapters.
+ *
+ * The actual node traversal (`visit` / `walkFile`) is language-specific
+ * and stays in each adapter. What is duplicated — and moves here — is:
+ *
+ *   - `record(out, occ)`            — the occurrence-sink append.
+ *   - `makeFileClassifier(...)`     — the regex-parameterized
+ *                                     `isTestFile` / `isGeneratedFile`
+ *                                     predicates.
+ *   - `runWalk({ input, walkFile })`— the `walkProject` driver skeleton:
+ *                                     allocate the output sinks, filter +
+ *                                     sort `input.files`, per-file
+ *                                     try/catch → `ParseError`.
+ *   - `synthesizeModuleInit(...)`   — the module-init `FunctionOccurrence`
+ *                                     skeleton (top-level-text join →
+ *                                     `digestSyntheticBody` → occurrence).
+ *                                     The `qualifiedName` shape differs per
+ *                                     language and is passed in.
+ */
+import { nameOf, childrenOf, namedChildrenOf } from '@opensip-cli/tree-sitter';
+import type { TreeSitterParsedFile, TreeSitterParsedProject } from './parse.js';
+import type { BodyDigest, CallSiteRecord, DependencySiteRecord, FunctionOccurrence, WalkInput, WalkOutput } from '@opensip-cli/graph';
+/** Append an occurrence into the by-simple-name occurrence sink. */
+export declare function record(out: Record<string, FunctionOccurrence[]>, occ: FunctionOccurrence): void;
+/** Regex inputs for the shared file classifier. */
+export interface FileClassifierConfig {
+    /** Matches a test file by name (e.g. `*_test.go`, `*Test.java`). */
+    readonly testRe: RegExp;
+    /** Matches a generated / build-output path. */
+    readonly generatedRe: RegExp;
+    /**
+     * Optional path-based test matcher (e.g. `src/test/`, `tests/`). When
+     * present, a file is a test file if EITHER `testPathRe` or `testRe`
+     * matches. Go omits this (the `_test.go` name convention is exact);
+     * java/python/rust supply it.
+     */
+    readonly testPathRe?: RegExp;
+}
+/** The bound file-classification predicates. */
+export interface FileClassifier {
+    readonly isTestFile: (rel: string) => boolean;
+    readonly isGeneratedFile: (rel: string) => boolean;
+}
+/** Builds `isTestFile` / `isGeneratedFile` bound to the given regexes. */
+export declare function makeFileClassifier(config: FileClassifierConfig): FileClassifier;
+/**
+ * The three output accumulators a per-file walk appends into. Grouping
+ * them keeps `walkFile` (and the adapter `visit` helpers that thread
+ * them) under the wide-function parameter budget, and names the cohesive
+ * "walk output" concept the driver allocates once per project.
+ */
+export interface WalkSinks {
+    /** By-simple-name occurrence sink (the engine's `out` map). */
+    readonly occurrences: Record<string, FunctionOccurrence[]>;
+    /** Flat list of call sites discovered across the file. */
+    readonly callSites: CallSiteRecord[];
+    /** Flat list of dependency (import) sites discovered across the file. */
+    readonly dependencySites: DependencySiteRecord[];
+}
+/** Inputs to the shared `walkProject` driver. */
+export interface RunWalkParams<P extends TreeSitterParsedProject> {
+    readonly input: WalkInput<P>;
+    /**
+     * The adapter's per-file walk: visits one file's AST and pushes
+     * occurrences / call sites / dependency sites into the supplied sinks.
+     */
+    readonly walkFile: (absPath: string, file: P['files'] extends ReadonlyMap<string, infer F> ? F : never, projectDirAbs: string, sinks: WalkSinks) => void;
+}
+/**
+ * Drives `walkProject`: allocate the output sinks, iterate
+ * `input.files` (filtered to parsed files, sorted for I-1 determinism),
+ * and run `walkFile` per file with a try/catch that records a
+ * `ParseError` on failure.
+ */
+export declare function runWalk<P extends TreeSitterParsedProject>(params: RunWalkParams<P>): WalkOutput;
+/** Inputs to the shared module-init occurrence builder. */
+export interface SynthesizeModuleInitParams<F extends TreeSitterParsedFile> {
+    readonly file: F;
+    readonly filePathProjectRel: string;
+    readonly inTestFile: boolean;
+    readonly definedInGenerated: boolean;
+    /** The adapter's synthetic-body digest (same normalization as real bodies). */
+    readonly digestSyntheticBody: (text: string) => BodyDigest;
+    /**
+     * The fully-built `qualifiedName` for the synthetic `<module-init>`
+     * occurrence — language-specific (extension strip + separator differ:
+     * `pkg/file.<module-init>` for go, `a.b.<module-init>` for python,
+     * `a::b::<module-init>` for rust, …). Computed by the adapter.
+     */
+    readonly qualifiedName: string;
+}
+/**
+ * Build the synthetic `<module-init>` `FunctionOccurrence`: hash the
+ * file's top-level statement-text concatenation and assemble the
+ * occurrence with the adapter-supplied `qualifiedName`.
+ */
+export declare function synthesizeModuleInit<F extends TreeSitterParsedFile>(params: SynthesizeModuleInitParams<F>): FunctionOccurrence;
+export { nameOf, childrenOf, namedChildrenOf };
+/**
+ * Build a simple-name → bodyHash[] index from the walk's occurrence map.
+ * Skips synthetic names (those starting with `<`); only real names are
+ * resolution targets. Language-agnostic (operates on the engine's
+ * `FunctionOccurrence` record), so it is shared by every resolver that
+ * needs it (go / java / python; rust resolves differently).
+ */
+export declare function buildNameIndex(functions: Readonly<Record<string, readonly FunctionOccurrence[]>>): ReadonlyMap<string, readonly string[]>;
+//# sourceMappingURL=walk.d.ts.map

package/dist/walk.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"walk.d.ts","sourceRoot":"","sources":["../src/walk.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;GAmBG;AAKH,OAAO,EAAE,MAAM,EAAE,UAAU,EAAE,eAAe,EAAE,MAAM,0BAA0B,CAAC;AAE/E,OAAO,KAAK,EAAE,oBAAoB,EAAE,uBAAuB,EAAE,MAAM,YAAY,CAAC;AAChF,OAAO,KAAK,EACV,UAAU,EACV,cAAc,EACd,oBAAoB,EACpB,kBAAkB,EAElB,SAAS,EACT,UAAU,EACX,MAAM,oBAAoB,CAAC;AAK5B,oEAAoE;AACpE,wBAAgB,MAAM,CAAC,GAAG,EAAE,MAAM,CAAC,MAAM,EAAE,kBAAkB,EAAE,CAAC,EAAE,GAAG,EAAE,kBAAkB,GAAG,IAAI,CAI/F;AAID,mDAAmD;AACnD,MAAM,WAAW,oBAAoB;IACnC,oEAAoE;IACpE,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;IACxB,+CAA+C;IAC/C,QAAQ,CAAC,WAAW,EAAE,MAAM,CAAC;IAC7B;;;;;OAKG;IACH,QAAQ,CAAC,UAAU,CAAC,EAAE,MAAM,CAAC;CAC9B;AAED,gDAAgD;AAChD,MAAM,WAAW,cAAc;IAC7B,QAAQ,CAAC,UAAU,EAAE,CAAC,GAAG,EAAE,MAAM,KAAK,OAAO,CAAC;IAC9C,QAAQ,CAAC,eAAe,EAAE,CAAC,GAAG,EAAE,MAAM,KAAK,OAAO,CAAC;CACpD;AAED,0EAA0E;AAC1E,wBAAgB,kBAAkB,CAAC,MAAM,EAAE,oBAAoB,GAAG,cAAc,CAS/E;AAID;;;;;GAKG;AACH,MAAM,WAAW,SAAS;IACxB,+DAA+D;IAC/D,QAAQ,CAAC,WAAW,EAAE,MAAM,CAAC,MAAM,EAAE,kBAAkB,EAAE,CAAC,CAAC;IAC3D,0DAA0D;IAC1D,QAAQ,CAAC,SAAS,EAAE,cAAc,EAAE,CAAC;IACrC,yEAAyE;IACzE,QAAQ,CAAC,eAAe,EAAE,oBAAoB,EAAE,CAAC;CAClD;AAED,iDAAiD;AACjD,MAAM,WAAW,aAAa,CAAC,CAAC,SAAS,uBAAuB;IAC9D,QAAQ,CAAC,KAAK,EAAE,SAAS,CAAC,CAAC,CAAC,CAAC;IAC7B;;;OAGG;IACH,QAAQ,CAAC,QAAQ,EAAE,CACjB,OAAO,EAAE,MAAM,EACf,IAAI,EAAE,CAAC,CAAC,OAAO,CAAC,SAAS,WAAW,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,GAAG,CAAC,GAAG,KAAK,EACjE,aAAa,EAAE,MAAM,EACrB,KAAK,EAAE,SAAS,KACb,IAAI,CAAC;CACX;AAED;;;;;GAKG;AACH,wBAAgB,OAAO,CAAC,CAAC,SAAS,uBAAuB,EAAE,MAAM,EAAE,aAAa,CAAC,CAAC,CAAC,GAAG,UAAU,CAyC/F;AAID,2DAA2D;AAC3D,MAAM,WAAW,0BAA0B,CAAC,CAAC,SAAS,oBAAoB;IACxE,QAAQ,CAAC,IAAI,EAAE,CAAC,CAAC;IACjB,QAAQ,CAAC,kBAAkB,EAAE,MAAM,CAAC;IACpC,QAAQ,CAAC,UAAU,EAAE,OAAO,CAAC;IAC7B,QAAQ,CAAC,kBAAkB,EAAE,OAAO,CAAC;IACrC,+EAA+E;IAC/E,QAAQ,CAAC,mBAAmB,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,UAAU,CAAC;IAC3D;;;;;OAKG;IACH,QAAQ,CAAC,aAAa,EAAE,MAAM,CAAC;CAChC;AAED;;;;GAIG;AACH,wBAAgB,oBAAoB,CAAC,CAAC,SAAS,oBAAoB,EACjE,MAAM,EAAE,0BAA0B,CAAC,CAAC,CAAC,GACpC,kBAAkB,CAiCpB;AAWD,OAAO,EAAE,MAAM,EAAE,UAAU,EAAE,eAAe,EAAE,CAAC;AAI/C;;;;;;GAMG;AACH,wBAAgB,cAAc,CAC5B,SAAS,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,SAAS,kBAAkB,EAAE,CAAC,CAAC,GACjE,WAAW,CAAC,MAAM,EAAE,SAAS,MAAM,EAAE,CAAC,CAUxC"}

package/dist/walk.js

@@ -0,0 +1,141 @@
+/**
+ * Shared walk scaffolding for the tree-sitter adapters.
+ *
+ * The actual node traversal (`visit` / `walkFile`) is language-specific
+ * and stays in each adapter. What is duplicated — and moves here — is:
+ *
+ *   - `record(out, occ)`            — the occurrence-sink append.
+ *   - `makeFileClassifier(...)`     — the regex-parameterized
+ *                                     `isTestFile` / `isGeneratedFile`
+ *                                     predicates.
+ *   - `runWalk({ input, walkFile })`— the `walkProject` driver skeleton:
+ *                                     allocate the output sinks, filter +
+ *                                     sort `input.files`, per-file
+ *                                     try/catch → `ParseError`.
+ *   - `synthesizeModuleInit(...)`   — the module-init `FunctionOccurrence`
+ *                                     skeleton (top-level-text join →
+ *                                     `digestSyntheticBody` → occurrence).
+ *                                     The `qualifiedName` shape differs per
+ *                                     language and is passed in.
+ */
+import { relative } from 'node:path';
+import { withSpan } from '@opensip-cli/core';
+import { nameOf, childrenOf, namedChildrenOf } from '@opensip-cli/tree-sitter';
+// ── output helpers ────────────────────────────────────────────────
+/** Append an occurrence into the by-simple-name occurrence sink. */
+export function record(out, occ) {
+    const list = out[occ.simpleName];
+    if (list)
+        list.push(occ);
+    else
+        out[occ.simpleName] = [occ];
+}
+/** Builds `isTestFile` / `isGeneratedFile` bound to the given regexes. */
+export function makeFileClassifier(config) {
+    const { testRe, generatedRe, testPathRe } = config;
+    return {
+        isTestFile: testPathRe === undefined
+            ? (rel) => testRe.test(rel)
+            : (rel) => testPathRe.test(rel) || testRe.test(rel),
+        isGeneratedFile: (rel) => generatedRe.test(rel),
+    };
+}
+/**
+ * Drives `walkProject`: allocate the output sinks, iterate
+ * `input.files` (filtered to parsed files, sorted for I-1 determinism),
+ * and run `walkFile` per file with a try/catch that records a
+ * `ParseError` on failure.
+ */
+export function runWalk(params) {
+    const { input, walkFile } = params;
+    const occurrences = Object.create(null);
+    const callSites = [];
+    const dependencySites = [];
+    const parseErrors = [];
+    const sinks = { occurrences, callSites, dependencySites };
+    const sortedPaths = [...input.files].filter((p) => input.project.files.has(p)).sort();
+    return withSpan('opensip-cli-graph', 'graph.walk', () => {
+        for (const path of sortedPaths) {
+            const file = input.project.files.get(path);
+            if (!file)
+                continue;
+            try {
+                walkFile(path, file, input.projectDirAbs, sinks);
+            }
+            catch (error) {
+                parseErrors.push({
+                    filePath: relative(input.projectDirAbs, path),
+                    message: error instanceof Error ? error.message : String(error),
+                });
+            }
+        }
+        return { occurrences, callSites, dependencySites, parseErrors };
+    }, {
+        'graph.walk.file_count': sortedPaths.length,
+    });
+}
+/**
+ * Build the synthetic `<module-init>` `FunctionOccurrence`: hash the
+ * file's top-level statement-text concatenation and assemble the
+ * occurrence with the adapter-supplied `qualifiedName`.
+ */
+export function synthesizeModuleInit(params) {
+    const { file, filePathProjectRel, inTestFile, definedInGenerated, digestSyntheticBody, qualifiedName, } = params;
+    const root = file.tree.rootNode;
+    const topLevelText = childrenOf(root)
+        .map((c) => file.source.slice(c.startIndex, c.endIndex))
+        .join('\n');
+    const digest = digestSyntheticBody(`${filePathProjectRel}\n${topLevelText}`);
+    return {
+        bodyHash: digest.hash,
+        bodySize: digest.size,
+        simpleName: `<module-init:${filePathProjectRel}>`,
+        qualifiedName,
+        filePath: filePathProjectRel,
+        line: 1,
+        column: 0,
+        endLine: root.endPosition.row + 1,
+        kind: 'module-init',
+        params: [],
+        returnType: null,
+        enclosingClass: null,
+        decorators: [],
+        visibility: 'module-local',
+        inTestFile,
+        definedInGenerated,
+        calls: [],
+    };
+}
+// ── node helpers ──────────────────────────────────────────────────
+// `nameOf` / `childrenOf` / `namedChildrenOf` now live in the canonical
+// grammar-agnostic substrate `@opensip-cli/tree-sitter` (ADR-0010). They
+// are re-exported here so the graph adapters' existing imports from
+// `@opensip-cli/graph-adapter-common` are unchanged. (Imported, not just
+// re-exported, because `synthesizeModuleInit` above uses `childrenOf`
+// internally — a plain `export…from` would not bind it in scope.)
+// eslint-disable-next-line unicorn/prefer-export-from -- childrenOf is also used internally; the import binding is required
+export { nameOf, childrenOf, namedChildrenOf };
+// ── resolver helper ───────────────────────────────────────────────
+/**
+ * Build a simple-name → bodyHash[] index from the walk's occurrence map.
+ * Skips synthetic names (those starting with `<`); only real names are
+ * resolution targets. Language-agnostic (operates on the engine's
+ * `FunctionOccurrence` record), so it is shared by every resolver that
+ * needs it (go / java / python; rust resolves differently).
+ */
+export function buildNameIndex(functions) {
+    const out = new Map();
+    for (const [name, occs] of Object.entries(functions)) {
+        if (!occs)
+            continue;
+        if (name.startsWith('<'))
+            continue;
+        const list = out.get(name) ?? [];
+        for (const o of occs)
+            list.push(o.bodyHash);
+        if (list.length > 0)
+            out.set(name, list);
+    }
+    return out;
+}
+//# sourceMappingURL=walk.js.map

package/dist/walk.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"walk.js","sourceRoot":"","sources":["../src/walk.ts"],"names":[],"mappings":"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"}

package/package.json

@@ -0,0 +1,49 @@
+{
+  "name": "@opensip-cli/graph-adapter-common",
+  "version": "0.1.0",
+  "license": "Apache-2.0",
+  "description": "Shared scaffolding for the tree-sitter graph language adapters (go, java, python, rust)",
+  "keywords": [
+    "opensip-cli",
+    "static-analysis",
+    "code-quality",
+    "call-graph",
+    "tree-sitter"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/opensip-ai/opensip-cli.git",
+    "directory": "packages/graph/graph-adapter-common"
+  },
+  "homepage": "https://github.com/opensip-ai/opensip-cli",
+  "bugs": {
+    "url": "https://github.com/opensip-ai/opensip-cli/issues"
+  },
+  "type": "module",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": "./dist/index.js"
+  },
+  "files": [
+    "dist",
+    "LICENSE",
+    "NOTICE"
+  ],
+  "dependencies": {
+    "glob": "^13.0.0",
+    "@opensip-cli/core": "0.1.0",
+    "@opensip-cli/graph": "0.1.0",
+    "@opensip-cli/tree-sitter": "0.1.0"
+  },
+  "devDependencies": {
+    "@types/node": "^24.13.2",
+    "vitest": "^4.1.8"
+  },
+  "scripts": {
+    "build": "tsc",
+    "test": "vitest run --passWithNoTests",
+    "typecheck": "tsc --noEmit",
+    "clean": "rm -rf dist"
+  }
+}