cgraphx 2.0.1 → 2.0.3

package/dist/core/code/engine/core/ingestion/languages/dart/scope-resolver.js

@@ -0,0 +1,197 @@
+"use strict";
+/**
+ * Dart `ScopeResolver` registered in `SCOPE_RESOLVERS` and consumed by the
+ * generic `runScopeResolution` orchestrator (RFC #909 Ring 3, issue #939).
+ *
+ * Closest reference: Swift (`swiftScopeResolver`) — both are statically typed,
+ * have no `new` keyword, and model `Type(...)` as a reference to the type.
+ *
+ * ## Dart specifics
+ *
+ *   - **`implements` / `with`.** Dart can implement (and mixes in) ordinary
+ *     classes, so the edge type cannot be decided from the target's symbol
+ *     kind (the generic `preEmitInheritanceEdges` pre-pass routes
+ *     `Interface`/`Trait` → IMPLEMENTS, everything else → EXTENDS). `extends`
+ *     is captured as `@reference.inherits` and rides the generic pre-pass
+ *     (target is a class → EXTENDS); `implements`/`with` are carried as
+ *     `__heritage__:` side-effect imports and emitted here as IMPLEMENTS by
+ *     `emitDartHeritageEdges`. METHOD_IMPLEMENTS then falls out of the shared
+ *     MRO/interface-dispatch phase.
+ *   - **Mixin MRO.** `buildDartMro` augments the EXTENDS chain with mixin /
+ *     interface ancestors (IMPLEMENTS edges) so mixed-in members participate
+ *     in method lookup (PHP/Ruby trait pattern).
+ *   - **No `new`.** `Type(...)` resolves to the Class node
+ *     (`constructorCallTargetsClass`); the cross-file global free-call
+ *     fallback is allowed (`allowGlobalFreeCallFallback`).
+ *   - **Statically typed** → `fieldFallbackOnMethodLookup: false` (the
+ *     field-walk heuristic over-connects when types are reliable).
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.dartScopeResolver = void 0;
+const index_js_1 = require("../../../../../shared/index.js");
+const mro_js_1 = require("../../scope-resolution/passes/mro.js");
+const walkers_js_1 = require("../../scope-resolution/scope/walkers.js");
+const ids_js_1 = require("../../scope-resolution/graph-bridge/ids.js");
+const utils_js_1 = require("../../../../lib/utils.js");
+const dart_js_1 = require("../dart.js");
+const index_js_2 = require("./index.js");
+const heritage_marker_js_1 = require("../../utils/heritage-marker.js");
+const expand_wildcards_js_1 = require("./expand-wildcards.js");
+/**
+ * Resolve a class simple name to a graph id with FILE AFFINITY: prefer a
+ * definition in `preferredFile`, then a workspace-unique match, otherwise
+ * refuse to guess (return undefined). This avoids the cross-file simple-name
+ * collision a global last-write-wins map produces — two files each declaring
+ * `Logger` where one `implements Logger` must bind its OWN file's `Logger`.
+ */
+function pickClassByName(name, preferredFile, defsByName) {
+    const cands = defsByName.get(name);
+    if (cands === undefined || cands.length === 0)
+        return undefined;
+    const sameFile = cands.find((c) => c.filePath === preferredFile);
+    if (sameFile !== undefined)
+        return sameFile.graphId;
+    if (cands.length === 1)
+        return cands[0].graphId;
+    return undefined; // ambiguous across files, none same-file — don't emit a wrong edge
+}
+/**
+ * Emit IMPLEMENTS edges for Dart `implements`/`with` clauses, carried from
+ * `captures.ts` as `__heritage__:<kind>:<base>:<child>` side-effect imports.
+ * The marker lives in the implementing class's `ParsedFile`, so both the child
+ * and base names are resolved with same-file affinity (see `pickClassByName`),
+ * which keeps cross-file same-name classes from collapsing (mirror of Ruby's
+ * `emitRubyMixinEdges`, with the #1951-style file-affinity hardening).
+ */
+function emitDartHeritageEdges(graph, parsedFiles, nodeLookup) {
+    const defsByName = new Map();
+    for (const parsed of parsedFiles) {
+        for (const def of parsed.localDefs) {
+            if (!(0, walkers_js_1.isClassLike)(def.type))
+                continue;
+            const graphId = (0, ids_js_1.resolveDefGraphId)(parsed.filePath, def, nodeLookup);
+            if (graphId === undefined)
+                continue;
+            const simpleName = def.qualifiedName?.split('.').pop() ?? def.qualifiedName ?? '';
+            if (simpleName === '')
+                continue;
+            let list = defsByName.get(simpleName);
+            if (list === undefined) {
+                list = [];
+                defsByName.set(simpleName, list);
+            }
+            list.push({ graphId, filePath: parsed.filePath });
+        }
+    }
+    // Pre-seed with existing IMPLEMENTS edges (reason-qualified) so a class that
+    // both `implements X` and `with X` keeps both distinct edges.
+    const emitted = new Set();
+    for (const rel of graph.iterRelationshipsByType('IMPLEMENTS')) {
+        emitted.add(`${rel.sourceId}->${rel.targetId}:${rel.reason}`);
+    }
+    for (const parsed of parsedFiles) {
+        for (const imp of parsed.parsedImports) {
+            const raw = imp.targetRaw;
+            if (typeof raw !== 'string')
+                continue;
+            const decoded = (0, heritage_marker_js_1.decodeMarker)(raw);
+            if (decoded?.kind !== 'heritage')
+                continue;
+            const parts = decoded.fields;
+            if (parts.length < 3)
+                continue;
+            const [kind, baseName, childName] = parts;
+            const childId = pickClassByName(childName, parsed.filePath, defsByName);
+            const baseId = pickClassByName(baseName, parsed.filePath, defsByName);
+            if (childId === undefined || baseId === undefined || childId === baseId)
+                continue;
+            const key = `${childId}->${baseId}:${kind}`;
+            if (emitted.has(key))
+                continue;
+            emitted.add(key);
+            graph.addRelationship({
+                id: (0, utils_js_1.generateId)('IMPLEMENTS', key),
+                sourceId: childId,
+                targetId: baseId,
+                type: 'IMPLEMENTS',
+                confidence: 0.9,
+                reason: kind,
+            });
+        }
+    }
+}
+/**
+ * Dart MRO: the EXTENDS superclass chain (`defaultLinearize`) augmented with
+ * mixin / interface ancestors discovered via IMPLEMENTS edges, so mixed-in and
+ * interface-default members participate in method lookup. Mixins are appended
+ * after the superclass chain (first-seen approximates Dart linearization for
+ * dispatch purposes).
+ */
+function buildDartMro(graph, parsedFiles, nodeLookup) {
+    const mro = (0, mro_js_1.buildMro)(graph, parsedFiles, nodeLookup, mro_js_1.defaultLinearize);
+    const defIdByGraphId = new Map();
+    for (const parsed of parsedFiles) {
+        for (const def of parsed.localDefs) {
+            if (!(0, walkers_js_1.isClassLike)(def.type))
+                continue;
+            const graphId = (0, ids_js_1.resolveDefGraphId)(parsed.filePath, def, nodeLookup);
+            if (graphId !== undefined)
+                defIdByGraphId.set(graphId, def.nodeId);
+        }
+    }
+    const implsByChild = new Map();
+    for (const rel of graph.iterRelationshipsByType('IMPLEMENTS')) {
+        const child = defIdByGraphId.get(rel.sourceId);
+        const base = defIdByGraphId.get(rel.targetId);
+        if (child === undefined || base === undefined)
+            continue;
+        let set = implsByChild.get(child);
+        if (set === undefined) {
+            set = new Set();
+            implsByChild.set(child, set);
+        }
+        set.add(base);
+    }
+    for (const [childDefId, impls] of implsByChild) {
+        const extendsChain = mro.get(childDefId) ?? [];
+        const seen = new Set(extendsChain);
+        const merged = [...extendsChain];
+        for (const base of impls) {
+            if (!seen.has(base)) {
+                seen.add(base);
+                merged.push(base);
+            }
+        }
+        mro.set(childDefId, merged);
+    }
+    return mro;
+}
+exports.dartScopeResolver = {
+    language: index_js_1.SupportedLanguages.Dart,
+    languageProvider: dart_js_1.dartProvider,
+    importEdgeReason: 'dart-scope: import',
+    resolveImportTarget: (targetRaw, fromFile, allFilePaths) => (0, index_js_2.resolveDartImportTarget)(targetRaw, fromFile, allFilePaths),
+    // Dart `import` is whole-library: every public top-level symbol of the
+    // target enters scope. Enumerating them lets `propagateImportedReturnTypes`
+    // mirror imported functions' return types into the importer.
+    expandsWildcardTo: (targetModuleScope, parsedFiles) => (0, expand_wildcards_js_1.expandDartWildcardNames)(targetModuleScope, parsedFiles),
+    // Dart shadowing: local declarations hide imports.
+    mergeBindings: (existing, incoming) => [...(0, index_js_2.dartMergeBindings)([...existing, ...incoming])],
+    // Adapter: dartArityCompatibility uses (def, callsite); contract is (callsite, def).
+    arityCompatibility: (callsite, def) => (0, index_js_2.dartArityCompatibility)(def, callsite),
+    buildMro: (graph, parsedFiles, nodeLookup) => buildDartMro(graph, parsedFiles, nodeLookup),
+    // Methods/fields are owned by their enclosing class/mixin/extension.
+    populateOwners: (parsed) => (0, walkers_js_1.populateClassOwnedMembers)(parsed),
+    // `super.method()` dispatches through the superclass + mixin chain.
+    isSuperReceiver: (text) => text.trim() === 'super',
+    // `implements` / `with` IMPLEMENTS edges (extends rides the generic
+    // inherits pre-pass; these need an explicit, kind-independent edge type).
+    emitHeritageEdges: (graph, parsedFiles, nodeLookup) => emitDartHeritageEdges(graph, parsedFiles, nodeLookup),
+    // Dart is statically typed — the field-fallback heuristic over-connects.
+    fieldFallbackOnMethodLookup: false,
+    propagatesReturnTypesAcrossImports: true,
+    // No `new`: bare `Foo()` resolves to the type; with cross-file imports the
+    // callee is reachable workspace-wide.
+    allowGlobalFreeCallFallback: true,
+    constructorCallTargetsClass: true,
+};

package/dist/core/code/engine/core/ingestion/languages/dart/signature-bindings.js

@@ -0,0 +1,54 @@
+"use strict";
+/**
+ * Synthesize parameter-type and return-type bindings for a Dart function /
+ * method. Mirror of `languages/swift/signature-bindings.ts`:
+ *
+ *   - Parameter bindings (`@type-binding.parameter`) are anchored on the
+ *     `function_body` node so they land in the (synthesized) Function scope
+ *     — the receiver of `param.method()` resolves against the param's type.
+ *   - The return-type binding (`@type-binding.return`) is anchored on the
+ *     declaration node and carries the function name → return type; the
+ *     `bindingScopeFor` hook hoists it to the Module scope so callers (and
+ *     `propagateImportedReturnTypes`) see `var u = getUser(); u.m()` resolve.
+ *
+ * Reuses `dartMethodConfig.extractParameters/extractName/extractReturnType`,
+ * which descend the `method_signature`/`declaration` wrapper internally.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.synthesizeDartSignatureBindings = synthesizeDartSignatureBindings;
+const ast_helpers_js_1 = require("../../utils/ast-helpers.js");
+const dart_js_1 = require("../../method-extractors/configs/dart.js");
+function buildBindingMatch(anchor, sourceTag, name, typeText) {
+    return {
+        [sourceTag]: (0, ast_helpers_js_1.nodeToCapture)(sourceTag, anchor),
+        '@type-binding.name': (0, ast_helpers_js_1.syntheticCapture)('@type-binding.name', anchor, name),
+        '@type-binding.type': (0, ast_helpers_js_1.syntheticCapture)('@type-binding.type', anchor, typeText),
+    };
+}
+/**
+ * `declNode` is the declaration wrapper. `bodyNode` is the resolved sibling
+ * `function_body` (or `null` for a bodyless/abstract declaration, in which
+ * case only the return binding is emitted).
+ */
+function synthesizeDartSignatureBindings(declNode, bodyNode) {
+    const out = [];
+    if (bodyNode !== null) {
+        const params = dart_js_1.dartMethodConfig.extractParameters?.(declNode) ?? [];
+        for (const p of params) {
+            if (p.type === null || p.name === '')
+                continue;
+            out.push(buildBindingMatch(bodyNode, '@type-binding.parameter', p.name, p.type));
+        }
+    }
+    const returnType = dart_js_1.dartMethodConfig.extractReturnType?.(declNode);
+    const funcName = dart_js_1.dartMethodConfig.extractName?.(declNode);
+    if (funcName !== undefined &&
+        funcName !== '' &&
+        returnType !== undefined &&
+        returnType !== '' &&
+        returnType !== 'void' &&
+        returnType !== 'dynamic') {
+        out.push(buildBindingMatch(declNode, '@type-binding.return', funcName, returnType));
+    }
+    return out;
+}

package/dist/core/code/engine/core/ingestion/languages/dart/simple-hooks.js

@@ -0,0 +1,61 @@
+"use strict";
+/**
+ * Small explicit Dart scope-resolution hooks:
+ *
+ *   - `dartBindingScopeFor` — (1) hoists `@type-binding.return` bindings to
+ *     the Module scope so chain-follow + `propagateImportedReturnTypes` see
+ *     them; (2) hoists function/method/constructor declaration NAMES to the
+ *     enclosing parent scope. The second case is Dart-specific: because
+ *     `function_signature`/`function_body` are siblings, the synthesized
+ *     Function scope starts AT the declaration, so the central auto-hoist
+ *     (which fires only when the declaration anchor range equals the scope
+ *     range) does not trigger; without this the function name would bind
+ *     inside its own body instead of being visible to callers/siblings.
+ *   - `dartImportOwningScope` — imports attach to the Module scope only.
+ *   - `dartReceiverBinding` — the implicit `this`/`super` receiver of a
+ *     Function scope.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.dartBindingScopeFor = dartBindingScopeFor;
+exports.dartImportOwningScope = dartImportOwningScope;
+exports.dartReceiverBinding = dartReceiverBinding;
+const scope_tree_walk_js_1 = require("../../utils/scope-tree-walk.js");
+function dartBindingScopeFor(decl, innermost, tree) {
+    // (1) Return-type bindings hoist to the Module scope.
+    if (decl['@type-binding.return'] !== undefined) {
+        let cur = innermost;
+        while (cur !== undefined && cur.kind !== 'Module') {
+            const parentId = cur.parent;
+            if (parentId === null)
+                break;
+            cur = tree.getScope(parentId);
+        }
+        if (cur !== undefined && cur.kind === 'Module')
+            return cur.id;
+        return null;
+    }
+    // (1b) A field typed from a constructor assigned to it (`r = Outer();` in a
+    // constructor body) must live on the CLASS scope — the assignment sits inside
+    // the constructor's own Function scope, where `typeOfMemberOnClass` never
+    // looks (#2807). Gated on the dedicated marker, never on
+    // `@type-binding.constructor` at large, which also fires for genuine locals.
+    if (decl['@type-binding.dart-field'] !== undefined) {
+        return (0, scope_tree_walk_js_1.walkToScope)(innermost, tree, 'Class');
+    }
+    // (2) Function/method/constructor names are visible in the enclosing scope.
+    if (decl['@declaration.function'] !== undefined ||
+        decl['@declaration.method'] !== undefined ||
+        decl['@declaration.constructor'] !== undefined) {
+        if (innermost.kind === 'Function' && innermost.parent !== null)
+            return innermost.parent;
+    }
+    return null;
+}
+function dartImportOwningScope(_imp, innermost, _tree) {
+    return innermost.kind === 'Module' ? innermost.id : null;
+}
+function dartReceiverBinding(functionScope) {
+    if (functionScope.kind !== 'Function')
+        return null;
+    return functionScope.typeBindings.get('this') ?? functionScope.typeBindings.get('super') ?? null;
+}

package/dist/core/code/engine/core/ingestion/languages/dart.js

@@ -0,0 +1,138 @@
+"use strict";
+/**
+ * Dart Language Provider
+ *
+ * Dart traits:
+ *   - exportChecker: public if no leading underscore
+ *   - Dart SDK imports (dart:*) and external packages are skipped
+ *   - enclosingFunctionFinder: Dart's tree-sitter grammar places function_body
+ *     as a sibling of function_signature/method_signature (not as a child).
+ *     The hook resolves the enclosing function by inspecting the previous sibling.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.dartProvider = void 0;
+const ast_helpers_js_1 = require("../utils/ast-helpers.js");
+const index_js_1 = require("../../../../shared/index.js");
+const generic_js_1 = require("../class-extractors/generic.js");
+const dart_js_1 = require("../class-extractors/configs/dart.js");
+const language_provider_js_1 = require("../language-provider.js");
+const dart_js_2 = require("../type-extractors/dart.js");
+const export_detection_js_1 = require("../export-detection.js");
+const resolver_factory_js_1 = require("../import-resolvers/resolver-factory.js");
+const dart_js_3 = require("../import-resolvers/configs/dart.js");
+const tree_sitter_queries_js_1 = require("../tree-sitter-queries.js");
+const dart_js_4 = require("../cfg/visitors/dart.js");
+const generic_js_2 = require("../field-extractors/generic.js");
+const dart_js_5 = require("../field-extractors/configs/dart.js");
+const generic_js_3 = require("../method-extractors/generic.js");
+const dart_js_6 = require("../method-extractors/configs/dart.js");
+const generic_js_4 = require("../variable-extractors/generic.js");
+const dart_js_7 = require("../variable-extractors/configs/dart.js");
+const generic_js_5 = require("../call-extractors/generic.js");
+const dart_js_8 = require("../call-extractors/configs/dart.js");
+const index_js_2 = require("./dart/index.js");
+const built_ins_js_1 = require("./dart/built-ins.js");
+const extension_type_preprocess_js_1 = require("./dart/extension-type-preprocess.js");
+/**
+ * Resolve the enclosing function from a `function_body` node by looking at its
+ * previous sibling.  In Dart's tree-sitter grammar, function_signature and
+ * function_body are siblings under program or class_body, unlike most languages
+ * where the function declaration wraps both.
+ *
+ * Extracts the function name inline — Dart uses function_signature and
+ * method_signature (which wraps function_signature) as its FUNCTION_NODE_TYPES.
+ */
+const dartEnclosingFunctionFinder = (node) => {
+    if (node.type !== 'function_body')
+        return null;
+    const prev = node.previousSibling;
+    if (!prev || !ast_helpers_js_1.FUNCTION_NODE_TYPES.has(prev.type))
+        return null;
+    // method_signature wraps function_signature — unwrap to reach the name
+    let target = prev;
+    let label = 'Function';
+    if (prev.type === 'method_signature') {
+        label = 'Method';
+        for (let i = 0; i < prev.childCount; i++) {
+            const c = prev.child(i);
+            if (c?.type === 'function_signature') {
+                target = c;
+                break;
+            }
+        }
+    }
+    const funcName = target.childForFieldName?.('name')?.text ?? null;
+    return funcName ? { funcName, label } : null;
+};
+exports.dartProvider = (0, language_provider_js_1.defineLanguage)({
+    id: index_js_1.SupportedLanguages.Dart,
+    extensions: ['.dart'],
+    entryPointPatterns: [
+        /^main$/,
+        /^build$/,
+        /^createState$/,
+        /^initState$/,
+        /^dispose$/,
+        /^didChangeDependencies$/,
+        /^didUpdateWidget$/,
+        /^runApp$/,
+        /^onEvent$/,
+        /^mapEventToState$/,
+    ],
+    astFrameworkPatterns: [
+        {
+            framework: 'flutter',
+            entryPointMultiplier: 2.5,
+            reason: 'flutter-widget',
+            patterns: [
+                'StatelessWidget',
+                'StatefulWidget',
+                'BuildContext',
+                'Widget build',
+                'ChangeNotifier',
+                'GetxController',
+                'Cubit<',
+                'Bloc<',
+                'ConsumerWidget',
+            ],
+        },
+        {
+            framework: 'riverpod',
+            entryPointMultiplier: 2.8,
+            reason: 'riverpod-pattern',
+            patterns: ['@riverpod', 'ref.watch', 'ref.read', 'AsyncNotifier', 'Notifier'],
+        },
+    ],
+    treeSitterQueries: tree_sitter_queries_js_1.DART_QUERIES,
+    preprocessSource: extension_type_preprocess_js_1.preprocessDartExtensionTypes,
+    typeConfig: dart_js_2.typeConfig,
+    exportChecker: export_detection_js_1.dartExportChecker,
+    importResolver: (0, resolver_factory_js_1.createImportResolver)(dart_js_3.dartImportConfig),
+    callExtractor: (0, generic_js_5.createCallExtractor)(dart_js_8.dartCallConfig),
+    fieldExtractor: (0, generic_js_2.createFieldExtractor)(dart_js_5.dartConfig),
+    methodExtractor: (0, generic_js_3.createMethodExtractor)(dart_js_6.dartMethodConfig),
+    variableExtractor: (0, generic_js_4.createVariableExtractor)(dart_js_7.dartVariableConfig),
+    classExtractor: (0, generic_js_1.createClassExtractor)(dart_js_1.dartClassConfig),
+    // ── Dartdoc (`///`) → description (issue #2270) ──
+    descriptionExtractor: (0, ast_helpers_js_1.createLeadingDocDescriptionExtractor)(),
+    enclosingFunctionFinder: dartEnclosingFunctionFinder,
+    builtInNames: built_ins_js_1.DART_BUILT_INS,
+    // ── Scope-based resolution hooks (RFC #909 Ring 3, issue #939) ──────────────
+    // Parsing-side surface consumed by `ScopeExtractor` once per file. The
+    // emit-side `ScopeResolver` lives in `dart/scope-resolver.ts`; the same
+    // function references flow through both interfaces.
+    emitScopeCaptures: index_js_2.emitDartScopeCaptures,
+    // Dart's `ownsReceivers` masks FIELD NAMES a member body rebinds, not `this`
+    // (which Dart binds lexically in every closure form, so there is nothing to
+    // own). See `dartShadowedFieldsCapture` in `dart/captures.ts` for why the
+    // read side needs the mask and what it deliberately does not cover.
+    scopeOwnsReceivers: index_js_2.dartScopeOwnsReceivers,
+    cfgVisitor: (0, dart_js_4.createDartCfgVisitor)(),
+    interpretImport: index_js_2.interpretDartImport,
+    interpretTypeBinding: index_js_2.interpretDartTypeBinding,
+    bindingScopeFor: index_js_2.dartBindingScopeFor,
+    importOwningScope: index_js_2.dartImportOwningScope,
+    receiverBinding: index_js_2.dartReceiverBinding,
+    mergeBindings: (_scope, bindings) => (0, index_js_2.dartMergeBindings)(bindings),
+    arityCompatibility: index_js_2.dartArityCompatibility,
+});

package/dist/core/code/engine/core/ingestion/languages/go/arity-metadata.js

@@ -0,0 +1,71 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.computeGoDeclarationArity = computeGoDeclarationArity;
+exports.computeGoCallArity = computeGoCallArity;
+function computeGoDeclarationArity(node) {
+    const params = node.childForFieldName('parameters');
+    const returnType = extractGoReturnType(node);
+    if (params === null)
+        return returnType === undefined ? {} : { returnType };
+    return {
+        ...computeGoParameterMetadata(params),
+        ...(returnType === undefined ? {} : { returnType }),
+    };
+}
+function computeGoParameterMetadata(params) {
+    let count = 0;
+    let required = 0;
+    const types = [];
+    for (let i = 0; i < params.namedChildCount; i++) {
+        const param = params.namedChild(i);
+        if (param === null)
+            continue;
+        if (param.type === 'parameter_declaration') {
+            const typeNode = param.childForFieldName('type');
+            const typeName = typeNode === null ? '' : typeNode.text;
+            const names = param.namedChildren.filter((c) => c.type === 'identifier');
+            const n = Math.max(1, names.length);
+            for (let j = 0; j < n; j++) {
+                count++;
+                required++;
+                types.push(typeName);
+            }
+        }
+        if (param.type === 'variadic_parameter_declaration') {
+            const typeNode = param.childForFieldName('type');
+            const typeName = typeNode === null ? '...' : `...${typeNode.text}`;
+            count++;
+            types.push(typeName);
+        }
+    }
+    return { parameterCount: count, requiredParameterCount: required, parameterTypes: types };
+}
+function computeGoCallArity(callNode) {
+    const args = callNode.childForFieldName('arguments');
+    if (args === null)
+        return 0;
+    return args.namedChildCount;
+}
+function extractGoReturnType(node) {
+    const result = node.childForFieldName('result');
+    if (result === null)
+        return undefined;
+    if (result.type !== 'parameter_list')
+        return result.text;
+    const returnTypes = [];
+    for (const child of result.namedChildren) {
+        if (child.type !== 'parameter_declaration')
+            continue;
+        const typeNode = child.childForFieldName('type');
+        if (typeNode === null)
+            continue;
+        const names = child.namedChildren.filter((c) => c.type === 'identifier');
+        const n = Math.max(1, names.length);
+        for (let i = 0; i < n; i++) {
+            returnTypes.push(typeNode.text);
+        }
+    }
+    if (returnTypes.length === 0)
+        return undefined;
+    return returnTypes.length === 1 ? returnTypes[0] : `(${returnTypes.join(', ')})`;
+}

package/dist/core/code/engine/core/ingestion/languages/go/arity.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.goArityCompatibility = goArityCompatibility;
+function goArityCompatibility(def, callsite) {
+    const max = def.parameterCount;
+    const min = def.requiredParameterCount;
+    if (max === undefined && min === undefined)
+        return 'unknown';
+    if (!Number.isFinite(callsite.arity) || callsite.arity < 0)
+        return 'unknown';
+    const variadic = def.parameterTypes?.some((t) => t.startsWith('...')) ?? false;
+    if (min !== undefined && callsite.arity < min)
+        return 'incompatible';
+    if (max !== undefined && callsite.arity > max && !variadic)
+        return 'incompatible';
+    return 'compatible';
+}

package/dist/core/code/engine/core/ingestion/languages/go/cache-stats.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.recordGoCacheHit = recordGoCacheHit;
+exports.recordGoCacheMiss = recordGoCacheMiss;
+exports.getGoCaptureCacheStats = getGoCaptureCacheStats;
+exports.resetGoCaptureCacheStats = resetGoCaptureCacheStats;
+let hits = 0;
+let misses = 0;
+function recordGoCacheHit() {
+    hits++;
+}
+function recordGoCacheMiss() {
+    misses++;
+}
+function getGoCaptureCacheStats() {
+    return { hits, misses };
+}
+function resetGoCaptureCacheStats() {
+    hits = 0;
+    misses = 0;
+}