cgraphx 2.0.2 → 2.0.3

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

@@ -0,0 +1,263 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.rubyScopeResolver = void 0;
+const index_js_1 = require("../../../../../shared/index.js");
+const mro_js_1 = require("../../scope-resolution/passes/mro.js");
+const ruby_js_1 = require("../ruby.js");
+const index_js_2 = require("./index.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 heritage_marker_js_1 = require("../../utils/heritage-marker.js");
+/**
+ * #1991: resolve a BARE mixin reference (`include Loggable`) to a nested module by
+ * the INCLUDING class's lexical scope — Ruby looks up a constant in the innermost
+ * enclosing scope first. For owner `App.S`, try `App.Loggable`, then walk outward.
+ * Returns undefined if no enclosing-scope-qualified module exists.
+ */
+function qualifyMixinByOwnerScope(mixinName, ownerName, graphIdByName) {
+    let prefix = ownerName;
+    let dot = prefix.lastIndexOf('.');
+    while (dot !== -1) {
+        prefix = prefix.slice(0, dot);
+        const g = graphIdByName.get(`${prefix}.${mixinName}`);
+        if (g !== undefined)
+            return g;
+        dot = prefix.lastIndexOf('.');
+    }
+    return undefined;
+}
+function emitRubyMixinEdges(graph, parsedFiles, nodeLookup) {
+    const graphIdByName = new Map();
+    // Secondary tail -> graphId map. The `__heritage__` marker carries the mixin
+    // TARGET as the bare written name (`arg.text`, e.g. `Loggable`), not its full
+    // qualifiedName, so a nested mixin module included by its short name misses the
+    // full-qn map. We first resolve it lexically by the including class's enclosing
+    // scope (`qualifyMixinByOwnerScope`); this tail map is the last resort. A genuine
+    // same-tail collision is mapped to `null` so we REFUSE to guess (#1991) rather
+    // than the old first-wins, which cross-wired App::Loggable / Web::Loggable.
+    const graphIdByTail = 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) {
+                // Key by the FULL qualified name (`Outer.Inner`), NOT the simple tail.
+                // Same-tail nested classes (`Outer::Inner` + `Other::Inner`) otherwise
+                // collapse onto one `Inner` key (last-wins) and cross-wire their mixin /
+                // attr_accessor owners (#1982). The `__heritage__`/`__property__` markers
+                // carry the full qualified owner name in lockstep (see ruby/captures.ts).
+                const fullName = def.qualifiedName ?? '';
+                if (fullName.length > 0) {
+                    graphIdByName.set(fullName, graphId);
+                    const dot = fullName.lastIndexOf('.');
+                    const tail = dot === -1 ? fullName : fullName.slice(dot + 1);
+                    if (tail.length > 0) {
+                        const existingTail = graphIdByTail.get(tail);
+                        if (existingTail === undefined)
+                            graphIdByTail.set(tail, graphId);
+                        else if (existingTail !== null && existingTail !== graphId)
+                            graphIdByTail.set(tail, null); // same-tail collision — refuse to guess
+                    }
+                }
+            }
+        }
+    }
+    const emitted = new Set();
+    // Pre-seed with existing IMPLEMENTS edges to avoid duplicates when the
+    // parse-worker path already produced heritage (worker path for repos
+    // with >= 15 files).
+    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 decoded = (0, heritage_marker_js_1.decodeMarker)(imp.targetRaw);
+            if (decoded?.kind !== 'heritage')
+                continue;
+            const parts = decoded.fields;
+            if (parts.length < 3)
+                continue;
+            const [kind, mixinName, className] = parts;
+            const classGraphId = graphIdByName.get(className);
+            // Owner stays full-qn. The mixin target may be written by short name and miss
+            // the full-qn map; resolve it lexically by the including class's enclosing
+            // scope (`App::S` + `Loggable` -> `App::Loggable`), then fall back to the tail
+            // map ONLY when unambiguous — never first-wins on a collision (#1982/#1991).
+            const mixinGraphId = graphIdByName.get(mixinName) ??
+                qualifyMixinByOwnerScope(mixinName, className, graphIdByName) ??
+                graphIdByTail.get(mixinName) ??
+                undefined;
+            if (classGraphId === undefined || mixinGraphId === undefined)
+                continue;
+            const edgeKey = `${classGraphId}->${mixinGraphId}:${kind}`;
+            if (emitted.has(edgeKey))
+                continue;
+            emitted.add(edgeKey);
+            graph.addRelationship({
+                id: (0, utils_js_1.generateId)('IMPLEMENTS', edgeKey),
+                sourceId: classGraphId,
+                targetId: mixinGraphId,
+                type: 'IMPLEMENTS',
+                confidence: 0.85,
+                reason: kind,
+            });
+        }
+    }
+    // Emit Property nodes + HAS_PROPERTY edges from __property__:... imports.
+    // Skip if the parse-worker already created the property (worker path merges
+    // Property nodes into the graph before scope-resolution runs).
+    const existingProps = new Set();
+    for (const rel of graph.iterRelationshipsByType('HAS_PROPERTY')) {
+        const targetNode = graph.getNode(rel.targetId);
+        if (targetNode !== undefined) {
+            existingProps.add(`${rel.sourceId}->prop:${targetNode.properties.name}`);
+        }
+    }
+    for (const parsed of parsedFiles) {
+        for (const imp of parsed.parsedImports) {
+            const decoded = (0, heritage_marker_js_1.decodeMarker)(imp.targetRaw);
+            if (decoded?.kind !== 'property')
+                continue;
+            const parts = decoded.fields;
+            if (parts.length < 3)
+                continue;
+            const [_attrKind, propName, className] = parts;
+            const classGraphId = graphIdByName.get(className);
+            if (classGraphId === undefined || propName === undefined)
+                continue;
+            const edgeKey = `${classGraphId}->prop:${propName}`;
+            if (emitted.has(edgeKey) || existingProps.has(edgeKey))
+                continue;
+            emitted.add(edgeKey);
+            const propId = (0, utils_js_1.generateId)('Property', `${parsed.filePath}:${className}.${propName}`);
+            graph.addNode({
+                id: propId,
+                label: 'Property',
+                properties: { name: propName, filePath: parsed.filePath },
+            });
+            graph.addRelationship({
+                id: (0, utils_js_1.generateId)('HAS_PROPERTY', edgeKey),
+                sourceId: classGraphId,
+                targetId: propId,
+                type: 'HAS_PROPERTY',
+                confidence: 0.9,
+                reason: 'attr',
+            });
+        }
+    }
+}
+function buildRubyMro(graph, parsedFiles, nodeLookup) {
+    // Step 1: EXTENDS chain via the generic MRO builder (direct class inheritance).
+    const baseMro = (0, mro_js_1.buildMro)(graph, parsedFiles, nodeLookup, mro_js_1.defaultLinearize);
+    // Step 2: Build defId ↔ graphId bridge for class-like defs.
+    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);
+        }
+    }
+    // Step 3: Collect IMPLEMENTS edges, partitioned by reason.
+    const prependByChild = new Map();
+    const includeByChild = new Map();
+    for (const rel of graph.iterRelationshipsByType('IMPLEMENTS')) {
+        const childDefId = defIdByGraphId.get(rel.sourceId);
+        const parentDefId = defIdByGraphId.get(rel.targetId);
+        if (childDefId === undefined || parentDefId === undefined)
+            continue;
+        const reason = rel.reason;
+        if (reason === 'prepend') {
+            let list = prependByChild.get(childDefId);
+            if (list === undefined) {
+                list = [];
+                prependByChild.set(childDefId, list);
+            }
+            list.push(parentDefId);
+        }
+        else if (reason === 'include') {
+            let list = includeByChild.get(childDefId);
+            if (list === undefined) {
+                list = [];
+                includeByChild.set(childDefId, list);
+            }
+            list.push(parentDefId);
+        }
+    }
+    // Step 4: Reorder MRO per Ruby semantics.
+    // Order: prepend (reversed) → direct extends chain → include (reversed).
+    // `extend` is excluded — it belongs to singleton dispatch only (the
+    // instance-ancestry walk drops extend entries).
+    // Reversed because Ruby declaration order means last-declared wins
+    // (prepend B; prepend A → B checked before A).
+    for (const defId of defIdByGraphId.values()) {
+        const extendsChain = baseMro.get(defId) ?? [];
+        const prepends = prependByChild.get(defId);
+        const includes = includeByChild.get(defId);
+        if (prepends === undefined && includes === undefined)
+            continue;
+        const reordered = [];
+        if (prepends !== undefined) {
+            for (let i = prepends.length - 1; i >= 0; i--)
+                reordered.push(prepends[i]);
+        }
+        reordered.push(...extendsChain);
+        if (includes !== undefined) {
+            for (let i = includes.length - 1; i >= 0; i--)
+                reordered.push(includes[i]);
+        }
+        baseMro.set(defId, reordered);
+    }
+    return baseMro;
+}
+/**
+ * Enumerate all names exported from a target module scope's file.
+ * Ruby's `require` / `require_relative` are wildcard imports — they bring
+ * every top-level def (class, module, method, constant) from the target
+ * file into the importer's scope. Without this hook the finalize pass
+ * cannot materialize individual bindings from wildcard imports, which
+ * blocks `propagateImportedReturnTypes` from mirroring return-type
+ * typeBindings across files.
+ */
+function expandRubyWildcardNames(targetModuleScope, parsedFiles) {
+    const target = parsedFiles.find((p) => p.moduleScope === targetModuleScope);
+    if (target === undefined)
+        return [];
+    const seen = new Set();
+    const names = [];
+    for (const def of target.localDefs) {
+        const qn = def.qualifiedName;
+        if (qn === undefined || qn.length === 0)
+            continue;
+        const name = qn.split('.').pop() ?? qn;
+        if (name === '')
+            continue;
+        if (seen.has(name))
+            continue;
+        seen.add(name);
+        names.push(name);
+    }
+    return names;
+}
+exports.rubyScopeResolver = {
+    // Construction is a selector on the class: `Service.new.do_work` (#2708).
+    constructionSyntax: { selector: 'new' },
+    language: index_js_1.SupportedLanguages.Ruby,
+    languageProvider: ruby_js_1.rubyProvider,
+    importEdgeReason: 'ruby-scope: import',
+    resolveImportTarget: (targetRaw, fromFile, allFilePaths, resolutionConfig) => (0, index_js_2.resolveRubyImportTarget)(targetRaw, fromFile, allFilePaths, resolutionConfig),
+    expandsWildcardTo: (targetModuleScope, parsedFiles) => expandRubyWildcardNames(targetModuleScope, parsedFiles),
+    mergeBindings: (existing, incoming, scopeId) => (0, index_js_2.rubyMergeBindings)(existing, incoming, scopeId),
+    arityCompatibility: (callsite, def) => (0, index_js_2.rubyArityCompatibility)(def, callsite),
+    buildMro: (graph, parsedFiles, nodeLookup) => buildRubyMro(graph, parsedFiles, nodeLookup),
+    populateOwners: (parsed) => (0, walkers_js_1.populateClassOwnedMembers)(parsed),
+    isSuperReceiver: (text) => text.trim() === 'super',
+    emitHeritageEdges: (graph, parsedFiles, nodeLookup) => emitRubyMixinEdges(graph, parsedFiles, nodeLookup),
+    fieldFallbackOnMethodLookup: true,
+    propagatesReturnTypesAcrossImports: true,
+    allowGlobalFreeCallFallback: true,
+};

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

@@ -0,0 +1,68 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.rubyBindingScopeFor = rubyBindingScopeFor;
+exports.rubyImportOwningScope = rubyImportOwningScope;
+exports.rubyReceiverBinding = rubyReceiverBinding;
+exports.rubyFunctionDefinitionLabel = rubyFunctionDefinitionLabel;
+const scope_tree_walk_js_1 = require("../../utils/scope-tree-walk.js");
+function rubyBindingScopeFor(decl, innermost, tree) {
+    // Keep self typeBindings in the method's Function scope so
+    // populateClassOwnedMembers can match Method defs to their receiver types.
+    if (decl['@type-binding.self'] !== undefined) {
+        return innermost.id;
+    }
+    // `@ivar = Foo.new` in `initialize` (or any method) declares a FIELD of the
+    // enclosing class, so its type binding belongs on the Class scope — the only
+    // place `typeOfMemberOnClass` reads it. Left on the method's own Function
+    // scope it would be invisible to every other method (#2807).
+    //
+    // Gated on the marker that pattern emits, never on `@type-binding.constructor`
+    // at large: that capture also fires for `x = Foo.new` locals, and hoisting
+    // those to the class would leak a method local into every sibling method.
+    //
+    // Reaching this hook already means the write is an INSTANCE write. `Capture`
+    // carries only name/range/text — no AST node — so this hook cannot ask whose
+    // `self` owns the ivar; `isRubyInstanceIvarWrite` (captures.ts) answers that
+    // upstream and discards the binding entirely whenever `self` is anything but
+    // an instance of the enclosing lexical class — the class object itself
+    // (`def self.x`, `class << self`, the class body), or whatever object a block
+    // receiver rebinds it to (`class_eval`, `Class.new`, `instance_eval`, …).
+    // None of those reach an instance, so none may be published as its field.
+    if (decl['@type-binding.ivar-field'] !== undefined) {
+        return (0, scope_tree_walk_js_1.walkToScope)(innermost, tree, 'Class');
+    }
+    return null;
+}
+/**
+ * Ruby `require` / `include` inside a function or class body should attach
+ * at that scope, not module scope.
+ */
+function rubyImportOwningScope(_imp, innermost, _tree) {
+    if (innermost.kind === 'Function' || innermost.kind === 'Class') {
+        return innermost.id;
+    }
+    return null;
+}
+function rubyReceiverBinding(functionScope) {
+    if (functionScope.kind !== 'Function')
+        return null;
+    return functionScope.typeBindings.get('self') ?? null;
+}
+/**
+ * Reclassify top-level `def` as `'Method'` when it appears inside a
+ * `class` or `module` body. Stand-alone defs remain `'Function'`.
+ */
+function rubyFunctionDefinitionLabel(functionNode, defaultLabel) {
+    if (defaultLabel !== 'Function')
+        return defaultLabel;
+    let ancestor = functionNode.parent;
+    while (ancestor) {
+        if (ancestor.type === 'program')
+            break;
+        if (ancestor.type === 'class' || ancestor.type === 'module') {
+            return 'Method';
+        }
+        ancestor = ancestor.parent;
+    }
+    return 'Function';
+}

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

@@ -0,0 +1,215 @@
+"use strict";
+/**
+ * Ruby language provider.
+ *
+ * Ruby uses wildcard import semantics (require/require_relative bring
+ * everything into scope). Ruby has SPECIAL call routing via routeRubyCall
+ * to handle require, include/extend (heritage), and attr_accessor/
+ * attr_reader/attr_writer (property definitions) as call expressions.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.rubyProvider = void 0;
+const index_js_1 = require("../../../../shared/index.js");
+const generic_js_1 = require("../class-extractors/generic.js");
+const ruby_js_1 = require("../class-extractors/configs/ruby.js");
+const language_provider_js_1 = require("../language-provider.js");
+const ast_helpers_js_1 = require("../utils/ast-helpers.js");
+const ruby_js_2 = require("../type-extractors/ruby.js");
+const call_routing_js_1 = require("../call-routing.js");
+const export_detection_js_1 = require("../export-detection.js");
+const resolver_factory_js_1 = require("../import-resolvers/resolver-factory.js");
+const ruby_js_3 = require("../import-resolvers/configs/ruby.js");
+const tree_sitter_queries_js_1 = require("../tree-sitter-queries.js");
+const generic_js_2 = require("../field-extractors/generic.js");
+const ruby_js_4 = require("../field-extractors/configs/ruby.js");
+const generic_js_3 = require("../method-extractors/generic.js");
+const ruby_js_5 = require("../method-extractors/configs/ruby.js");
+const generic_js_4 = require("../variable-extractors/generic.js");
+const ruby_js_6 = require("../variable-extractors/configs/ruby.js");
+const generic_js_5 = require("../call-extractors/generic.js");
+const ruby_js_7 = require("../call-extractors/configs/ruby.js");
+const ruby_js_8 = require("../cfg/visitors/ruby.js");
+const index_js_2 = require("./ruby/index.js");
+/**
+ * Ruby label override. Applied to:
+ *   - `definition.module` captures in the structure phase — remaps to `Trait`
+ *     so Ruby modules are registered in the class-like type registry and are
+ *     therefore resolvable by `lookupClassByName` during mixin heritage
+ *     resolution (`include`/`extend`/`prepend`).
+ *   - `definition.function` captures — Ruby has no bare "function" construct
+ *     (top-level `def` is a method on `main`); return the default so generic
+ *     logic continues to apply.
+ *
+ * Returning `null` means "skip this definition"; we never do that here.
+ */
+const rubyLabelOverride = (_node, defaultLabel) => {
+    if (defaultLabel === 'Module')
+        return 'Trait';
+    return defaultLabel;
+};
+/** Ruby method/singleton_method: extract name from 'name' field, label as Method. */
+const rubyExtractFunctionName = (node) => {
+    if (node.type !== 'method' && node.type !== 'singleton_method')
+        return null;
+    let nameNode = node.childForFieldName?.('name');
+    if (!nameNode) {
+        for (let i = 0; i < node.childCount; i++) {
+            const c = node.child(i);
+            if (c?.type === 'identifier') {
+                nameNode = c;
+                break;
+            }
+        }
+    }
+    return { funcName: nameNode?.text ?? null, label: 'Method' };
+};
+const BUILT_INS = new Set([
+    'puts',
+    'p',
+    'pp',
+    'raise',
+    'fail',
+    'require',
+    'require_relative',
+    'load',
+    'autoload',
+    'include',
+    'extend',
+    'prepend',
+    'attr_accessor',
+    'attr_reader',
+    'attr_writer',
+    'public',
+    'private',
+    'protected',
+    'module_function',
+    'lambda',
+    'proc',
+    'block_given?',
+    'nil?',
+    'is_a?',
+    'kind_of?',
+    'instance_of?',
+    'respond_to?',
+    'freeze',
+    'frozen?',
+    'dup',
+    'tap',
+    'yield_self',
+    'each',
+    'select',
+    'reject',
+    'detect',
+    'collect',
+    'inject',
+    'flat_map',
+    'each_with_object',
+    'each_with_index',
+    'any?',
+    'all?',
+    'none?',
+    'count',
+    'first',
+    'last',
+    'sort_by',
+    'min_by',
+    'max_by',
+    'group_by',
+    'partition',
+    'compact',
+    'flatten',
+    'uniq',
+]);
+/**
+ * Remaps `class << self` (singleton_class) to its enclosing class/module for
+ * receiver inference. A `singleton_class` node is not itself a type — walking
+ * up to the real owner resolves the singleton's enclosing class for the
+ * `resolveEnclosingOwner` scope-resolution hook.
+ * Returns null for orphaned singleton_class (no enclosing class/module found).
+ * All other container types are returned as-is.
+ */
+const rubyResolveEnclosingOwner = (node) => {
+    if (node.type === 'singleton_class') {
+        let ancestor = node.parent;
+        while (ancestor) {
+            if (ancestor.type === 'class' || ancestor.type === 'module') {
+                return ancestor;
+            }
+            ancestor = ancestor.parent;
+        }
+        return null; // no enclosing class/module — skip
+    }
+    return node; // use as-is for all other container types
+};
+exports.rubyProvider = (0, language_provider_js_1.defineLanguage)({
+    id: index_js_1.SupportedLanguages.Ruby,
+    extensions: ['.rb', '.rake', '.gemspec'],
+    entryPointPatterns: [/^call$/, /^perform$/, /^execute$/],
+    astFrameworkPatterns: [
+        {
+            framework: 'rails',
+            entryPointMultiplier: 3.0,
+            reason: 'rails-pattern',
+            patterns: [
+                'ApplicationController',
+                'ApplicationRecord',
+                'ActiveRecord::Base',
+                'before_action',
+                'after_action',
+                'has_many',
+                'belongs_to',
+                'has_one',
+                'validates',
+            ],
+        },
+        {
+            framework: 'sinatra',
+            entryPointMultiplier: 2.8,
+            reason: 'sinatra-pattern',
+            patterns: ['Sinatra::Base', 'Sinatra::Application'],
+        },
+    ],
+    treeSitterQueries: tree_sitter_queries_js_1.RUBY_QUERIES,
+    typeConfig: ruby_js_2.typeConfig,
+    exportChecker: export_detection_js_1.rubyExportChecker,
+    importResolver: (0, resolver_factory_js_1.createImportResolver)(ruby_js_3.rubyImportConfig),
+    callRouter: call_routing_js_1.routeRubyCall,
+    callExtractor: (0, generic_js_5.createCallExtractor)(ruby_js_7.rubyCallConfig),
+    resolveEnclosingOwner: rubyResolveEnclosingOwner,
+    fieldExtractor: (0, generic_js_2.createFieldExtractor)(ruby_js_4.rubyConfig),
+    methodExtractor: (0, generic_js_3.createMethodExtractor)({
+        ...ruby_js_5.rubyMethodConfig,
+        extractFunctionName: rubyExtractFunctionName,
+    }),
+    variableExtractor: (0, generic_js_4.createVariableExtractor)(ruby_js_6.rubyVariableConfig),
+    classExtractor: (0, generic_js_1.createClassExtractor)(ruby_js_1.rubyClassConfig),
+    // ── Leading `#` comments (RDoc/YARD) → description (issue #2270). Magic
+    //    comments and the shebang are not documentation. ──
+    descriptionExtractor: (0, ast_helpers_js_1.createLeadingDocDescriptionExtractor)({
+        lineCommentPrefixes: ['#'],
+        lineDirectivePrefixes: [
+            '# frozen_string_literal:',
+            '# encoding:',
+            '# coding:',
+            '# -*-',
+            '#!',
+            '# rubocop:',
+            '# typed:',
+        ],
+    }),
+    labelOverride: rubyLabelOverride,
+    // Ruby MRO is kind-aware: prepend providers beat the class's own method,
+    // which in turn beats include providers. The graph-level MRO phase
+    // (mro-processor.ts) and per-resolver buildMro consume this strategy.
+    mroStrategy: 'ruby-mixin',
+    builtInNames: BUILT_INS,
+    // ── RFC #909 Ring 3: scope-based resolution hooks ──────────
+    emitScopeCaptures: index_js_2.emitRubyScopeCaptures,
+    cfgVisitor: (0, ruby_js_8.createRubyCfgVisitor)(),
+    interpretImport: index_js_2.interpretRubyImport,
+    interpretTypeBinding: index_js_2.interpretRubyTypeBinding,
+    bindingScopeFor: index_js_2.rubyBindingScopeFor,
+    importOwningScope: index_js_2.rubyImportOwningScope,
+    receiverBinding: index_js_2.rubyReceiverBinding,
+    arityCompatibility: index_js_2.rubyArityCompatibility,
+});

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

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.rustArityCompatibility = rustArityCompatibility;
+function rustArityCompatibility(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';
+    if (min !== undefined && callsite.arity < min)
+        return 'incompatible';
+    if (max !== undefined && callsite.arity > max)
+        return 'incompatible';
+    return 'compatible';
+}

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

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.recordRustCacheHit = recordRustCacheHit;
+exports.recordRustCacheMiss = recordRustCacheMiss;
+exports.getRustCaptureCacheStats = getRustCaptureCacheStats;
+exports.resetRustCaptureCacheStats = resetRustCaptureCacheStats;
+let hits = 0;
+let misses = 0;
+function recordRustCacheHit() {
+    hits++;
+}
+function recordRustCacheMiss() {
+    misses++;
+}
+function getRustCaptureCacheStats() {
+    return { hits, misses };
+}
+function resetRustCaptureCacheStats() {
+    hits = 0;
+    misses = 0;
+}