cgraphx 2.0.2 → 2.0.6

package/dist/core/code/engine/core/ingestion/languages/ruby/import-target.js

@@ -0,0 +1,88 @@
+"use strict";
+/**
+ * Resolve a Ruby require/require_relative import path to a repo-relative file.
+ *
+ * Ruby import resolution rules:
+ *   - `require_relative './foo'` → resolve relative to the importing file's dir
+ *   - `require 'foo'`           → suffix-match via the existing Ruby import resolver
+ *   - External gems             → null (unresolvable within the repo)
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resolveRubyImportTarget = resolveRubyImportTarget;
+const ruby_js_1 = require("../../import-resolvers/ruby.js");
+const utils_js_1 = require("../../import-resolvers/utils.js");
+const heritage_marker_js_1 = require("../../utils/heritage-marker.js");
+// ─── resolveRubyImportTarget ──────────────────────────────────────────────
+/**
+ * ScopeResolver-shaped adapter:
+ *   `(targetRaw, fromFile, allFilePaths, resolutionConfig?) → string | string[] | null`
+ *
+ * For relative paths (`./` or `../` — require_relative semantics), resolves
+ * against the importing file's directory, trying `.rb` and `/index.rb`
+ * suffixes.
+ *
+ * For bare requires (gem-style like `'json'`, `'serializable'`), delegates
+ * to the existing `resolveRubyImportInternal` which uses suffix matching.
+ *
+ * Returns `null` for external gems that have no matching file in the repo.
+ */
+function resolveRubyImportTarget(targetRaw, fromFile, allFilePaths, _resolutionConfig) {
+    if (!targetRaw)
+        return null;
+    if ((0, heritage_marker_js_1.isHeritageMarker)(targetRaw))
+        return null;
+    const fromNormalized = fromFile.replace(/\\/g, '/');
+    const fromDir = fromNormalized.includes('/')
+        ? fromNormalized.slice(0, fromNormalized.lastIndexOf('/'))
+        : '';
+    // ── require_relative: relative path resolution ──────────────────────
+    if (targetRaw.startsWith('./') || targetRaw.startsWith('../')) {
+        const resolved = resolveRelative(targetRaw, fromDir, allFilePaths);
+        return resolved;
+    }
+    // ── require: bare/gem-style suffix matching ─────────────────────────
+    return resolveBare(targetRaw, allFilePaths);
+}
+// ─── internal helpers ─────────────────────────────────────────────────────
+/**
+ * Resolve a relative require path (`./foo`, `../bar`) against `fromDir`.
+ * Tries `${resolved}.rb` then `${resolved}/index.rb`.
+ */
+function resolveRelative(targetRaw, fromDir, allFilePaths) {
+    // Resolve `./` and `../` segments manually against fromDir
+    const segments = (fromDir ? fromDir + '/' + targetRaw : targetRaw).split('/');
+    const resolved = [];
+    for (const seg of segments) {
+        if (seg === '' || seg === '.')
+            continue;
+        if (seg === '..') {
+            resolved.pop();
+        }
+        else {
+            resolved.push(seg);
+        }
+    }
+    const resolvedPath = resolved.join('/');
+    // Try direct .rb file
+    const rbFile = `${resolvedPath}.rb`;
+    if (allFilePaths.has(rbFile))
+        return rbFile;
+    // Try index.rb inside directory
+    const indexFile = `${resolvedPath}/index.rb`;
+    if (allFilePaths.has(indexFile))
+        return indexFile;
+    // The path might already include .rb extension
+    if (resolvedPath.endsWith('.rb') && allFilePaths.has(resolvedPath))
+        return resolvedPath;
+    return null;
+}
+/**
+ * Resolve a bare require path (`'serializable'`, `'json'`, `'net/http'`)
+ * via suffix matching using the existing Ruby import resolver.
+ */
+function resolveBare(targetRaw, allFilePaths) {
+    const normalizedFileList = [...allFilePaths].map((f) => f.replace(/\\/g, '/'));
+    const allFileList = [...allFilePaths];
+    const index = (0, utils_js_1.buildSuffixIndex)(normalizedFileList, allFileList);
+    return (0, ruby_js_1.resolveRubyImportInternal)(targetRaw, normalizedFileList, allFileList, index);
+}

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

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resolveRubyImportTarget = exports.rubyFunctionDefinitionLabel = exports.rubyReceiverBinding = exports.rubyImportOwningScope = exports.rubyBindingScopeFor = exports.findEnclosingClassOrModule = exports.synthesizeRubyReceiverBinding = exports.rubyMergeBindings = exports.rubyArityCompatibility = exports.normalizeRubyTypeName = exports.interpretRubyTypeBinding = exports.interpretRubyImport = exports.resetRubyCaptureCacheStats = exports.getRubyCaptureCacheStats = exports.emitRubyScopeCaptures = void 0;
+/**
+ * Ruby scope-resolution hooks (RFC #909 Ring 3).
+ */
+var captures_js_1 = require("./captures.js");
+Object.defineProperty(exports, "emitRubyScopeCaptures", { enumerable: true, get: function () { return captures_js_1.emitRubyScopeCaptures; } });
+var cache_stats_js_1 = require("./cache-stats.js");
+Object.defineProperty(exports, "getRubyCaptureCacheStats", { enumerable: true, get: function () { return cache_stats_js_1.getRubyCaptureCacheStats; } });
+Object.defineProperty(exports, "resetRubyCaptureCacheStats", { enumerable: true, get: function () { return cache_stats_js_1.resetRubyCaptureCacheStats; } });
+var interpret_js_1 = require("./interpret.js");
+Object.defineProperty(exports, "interpretRubyImport", { enumerable: true, get: function () { return interpret_js_1.interpretRubyImport; } });
+Object.defineProperty(exports, "interpretRubyTypeBinding", { enumerable: true, get: function () { return interpret_js_1.interpretRubyTypeBinding; } });
+Object.defineProperty(exports, "normalizeRubyTypeName", { enumerable: true, get: function () { return interpret_js_1.normalizeRubyTypeName; } });
+var arity_js_1 = require("./arity.js");
+Object.defineProperty(exports, "rubyArityCompatibility", { enumerable: true, get: function () { return arity_js_1.rubyArityCompatibility; } });
+var merge_bindings_js_1 = require("./merge-bindings.js");
+Object.defineProperty(exports, "rubyMergeBindings", { enumerable: true, get: function () { return merge_bindings_js_1.rubyMergeBindings; } });
+var receiver_binding_js_1 = require("./receiver-binding.js");
+Object.defineProperty(exports, "synthesizeRubyReceiverBinding", { enumerable: true, get: function () { return receiver_binding_js_1.synthesizeRubyReceiverBinding; } });
+Object.defineProperty(exports, "findEnclosingClassOrModule", { enumerable: true, get: function () { return receiver_binding_js_1.findEnclosingClassOrModule; } });
+var simple_hooks_js_1 = require("./simple-hooks.js");
+Object.defineProperty(exports, "rubyBindingScopeFor", { enumerable: true, get: function () { return simple_hooks_js_1.rubyBindingScopeFor; } });
+Object.defineProperty(exports, "rubyImportOwningScope", { enumerable: true, get: function () { return simple_hooks_js_1.rubyImportOwningScope; } });
+Object.defineProperty(exports, "rubyReceiverBinding", { enumerable: true, get: function () { return simple_hooks_js_1.rubyReceiverBinding; } });
+Object.defineProperty(exports, "rubyFunctionDefinitionLabel", { enumerable: true, get: function () { return simple_hooks_js_1.rubyFunctionDefinitionLabel; } });
+var import_target_js_1 = require("./import-target.js");
+Object.defineProperty(exports, "resolveRubyImportTarget", { enumerable: true, get: function () { return import_target_js_1.resolveRubyImportTarget; } });

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

@@ -0,0 +1,115 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.interpretRubyImport = interpretRubyImport;
+exports.interpretRubyTypeBinding = interpretRubyTypeBinding;
+exports.normalizeRubyTypeName = normalizeRubyTypeName;
+const heritage_marker_js_1 = require("../../utils/heritage-marker.js");
+// ─── interpretImport ──────────────────────────────────────────────────────
+/**
+ * Interpret a pre-decomposed Ruby import capture into a `ParsedImport`.
+ *
+ * Ruby `require` / `require_relative` / `load` bring everything from the
+ * target file into scope (wildcard semantics). The captures layer (U5)
+ * pre-decomposes the raw tree-sitter match so that this function receives:
+ *   - `@import.kind`   — always `'wildcard'` for Ruby
+ *   - `@import.source` — the string argument (e.g. `'./user'`, `'serializable'`)
+ *   - `@import.name`   — derived module name (informational)
+ */
+function interpretRubyImport(captures) {
+    const kind = captures['@import.kind']?.text;
+    if (kind === undefined)
+        return null;
+    const source = captures['@import.source']?.text;
+    if (source === undefined)
+        return null;
+    // Heritage-encoded imports (__heritage__:include:Serializable:User)
+    // are stored as namespace imports so emitHeritageEdges can read them.
+    if ((0, heritage_marker_js_1.isHeritageMarker)(source)) {
+        const name = captures['@import.name']?.text ?? source;
+        return { kind: 'namespace', localName: name, importedName: name, targetRaw: source };
+    }
+    // Ruby imports are always wildcard — everything in the required file
+    // becomes visible in the importing scope.
+    return { kind: 'wildcard', targetRaw: source };
+}
+// ─── interpretTypeBinding ─────────────────────────────────────────────────
+/**
+ * Interpret a Ruby type-binding capture into a `ParsedTypeBinding`.
+ *
+ * Type information in Ruby comes from YARD/RBS annotations, `.new` calls,
+ * and assignment inference. The captures layer tags each match with one of
+ * several sub-captures (`@type-binding.self`, `@type-binding.constructor`,
+ * etc.) so this function can determine the `source`.
+ */
+function interpretRubyTypeBinding(captures) {
+    const name = captures['@type-binding.name']?.text;
+    const type = captures['@type-binding.type']?.text;
+    if (name === undefined || type === undefined)
+        return null;
+    let source;
+    let normalizedType;
+    if (captures['@type-binding.self'] !== undefined) {
+        source = 'self';
+        normalizedType = normalizeRubyTypeName(type);
+    }
+    else if (captures['@type-binding.constructor'] !== undefined) {
+        source = 'constructor-inferred';
+        normalizedType = normalizeRubyConstructorType(type);
+    }
+    else if (captures['@type-binding.call-return'] !== undefined) {
+        source = 'constructor-inferred';
+        normalizedType = normalizeRubyTypeName(type);
+    }
+    else if (captures['@type-binding.return'] !== undefined) {
+        source = 'return-annotation';
+        normalizedType = normalizeRubyTypeName(type);
+    }
+    else if (captures['@type-binding.parameter'] !== undefined) {
+        source = 'parameter-annotation';
+        normalizedType = normalizeRubyTypeName(type);
+    }
+    else if (captures['@type-binding.alias'] !== undefined) {
+        source = 'assignment-inferred';
+        normalizedType = normalizeRubyTypeName(type);
+    }
+    else {
+        source = 'annotation';
+        normalizedType = normalizeRubyTypeName(type);
+    }
+    return { boundName: name, rawTypeName: normalizedType, source };
+}
+// ─── normalizeRubyTypeName ────────────────────────────────────────────────
+/**
+ * Normalize a Ruby type name to its simple form:
+ *   1. Strip leading `::` (root-qualified)
+ *   2. Take last segment of qualified paths (`Foo::Bar::Baz` → `Baz`)
+ *   3. Strip generic angle brackets for consistency (`Array<User>` → `Array`)
+ *   4. Trim whitespace
+ */
+function normalizeRubyTypeName(text) {
+    let t = text.trim();
+    // Strip leading root-qualifier
+    if (t.startsWith('::'))
+        t = t.slice(2);
+    // Strip generic angle brackets (e.g. `Array<User>` → `Array`)
+    const angleBracket = t.indexOf('<');
+    if (angleBracket !== -1)
+        t = t.slice(0, angleBracket);
+    // Take last segment of qualified paths (Foo::Bar::Baz → Baz)
+    const lastColon = t.lastIndexOf('::');
+    if (lastColon !== -1)
+        t = t.slice(lastColon + 2);
+    return t.trim();
+}
+// ─── internal helpers ─────────────────────────────────────────────────────
+/**
+ * Normalize a constructor-inferred type from a `.new` call.
+ * Handles `Foo::Bar.new` → `Bar` and plain `Foo.new` → `Foo`.
+ */
+function normalizeRubyConstructorType(text) {
+    let t = text.trim();
+    // Strip `.new` suffix if present (e.g. `Foo::Bar.new` → `Foo::Bar`)
+    if (t.endsWith('.new'))
+        t = t.slice(0, -4);
+    return normalizeRubyTypeName(t);
+}

package/dist/core/code/engine/core/ingestion/languages/ruby/merge-bindings.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.rubyMergeBindings = rubyMergeBindings;
+const TIER = {
+    local: 0,
+    namespace: 1,
+    import: 2,
+    reexport: 3,
+    wildcard: 4,
+};
+function rubyMergeBindings(existing, incoming, _scopeId) {
+    const seen = new Set();
+    return [...existing, ...incoming]
+        .sort((a, b) => (TIER[a.origin] ?? 99) - (TIER[b.origin] ?? 99) || a.def.nodeId.localeCompare(b.def.nodeId))
+        .filter((binding) => {
+        if (seen.has(binding.def.nodeId))
+            return false;
+        seen.add(binding.def.nodeId);
+        return true;
+    });
+}

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

@@ -0,0 +1,349 @@
+"use strict";
+/**
+ * Tree-sitter query for Ruby scope captures (U1 scope-resolution migration).
+ *
+ * Captures the structural skeleton the generic scope-resolution pipeline
+ * consumes: scopes (program/class/module/method/block), declarations
+ * (class, module, method, singleton_method, variable), imports
+ * (require/require_relative/load), type bindings (constructor-inferred
+ * locals via `.new`), and references (free calls, member calls).
+ *
+ * Ruby specifics that shape this query:
+ *
+ *   - Ruby modules are class-like scopes (they hold methods and can be
+ *     mixed in via include/extend/prepend).
+ *
+ *   - `singleton_method` (`def self.foo`) is a class-level method
+ *     declaration, captured as @scope.function + @declaration.function.
+ *
+ *   - Ruby has no static type annotations. Constructor inference via
+ *     `x = User.new` is handled here; YARD `@param`/`@return` comments
+ *     are handled programmatically in captures.ts.
+ *
+ *   - In Ruby, field access IS a method call (attr_reader generates
+ *     methods). Member calls cover both method calls and field reads.
+ *
+ *   - `require`, `require_relative`, and `load` are plain method calls
+ *     in the grammar — matched by name via `#match?`.
+ *
+ *   - `do_block` and `block` (`{ }`) are both block scopes that can
+ *     introduce closures.
+ *
+ * Exposes lazy `Parser` and `Query` singletons so callers don't pay
+ * tree-sitter init cost per file.
+ */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getRubyParser = getRubyParser;
+exports.getRubyScopeQuery = getRubyScopeQuery;
+const tree_sitter_1 = __importDefault(require("tree-sitter"));
+const node_module_1 = require("node:module");
+// 懒加载(spec §7/§13):tree-sitter-ruby 移至 devDependencies,生产 --omit=dev 不装。
+// 首次用到时按需 require + 缓存;失败 → null,该语言降级为结构层收录,不阻断 analyze。
+const _require = (0, node_module_1.createRequire)(__filename);
+let _rubyGrammar;
+const loadRubyGrammar = () => {
+    if (_rubyGrammar !== undefined)
+        return _rubyGrammar;
+    try {
+        _rubyGrammar = _require('tree-sitter-ruby');
+    }
+    catch {
+        _rubyGrammar = null;
+    }
+    return _rubyGrammar;
+};
+const RUBY_SCOPE_QUERY = `
+;; ── Scopes ───────────────────────────────────────────────────────────────
+
+(program) @scope.module
+
+(class) @scope.class
+(module) @scope.class
+
+(method) @scope.function
+(singleton_method) @scope.function
+
+(do_block) @scope.block
+(block) @scope.block
+
+;; ── Declarations — class ─────────────────────────────────────────────────
+
+(class
+  name: (constant) @declaration.name) @declaration.class
+
+;; class Foo::Bar — namespaced class definition
+(class
+  name: (scope_resolution
+    name: (constant) @declaration.name)) @declaration.class
+
+;; ── Declarations — module (labeled Trait for class-like registry lookup) ─
+
+(module
+  name: (constant) @declaration.name) @declaration.trait
+
+;; module Baz::Qux — namespaced module definition
+(module
+  name: (scope_resolution
+    name: (constant) @declaration.name)) @declaration.trait
+
+;; ── Declarations — method (instance) ─────────────────────────────────────
+
+(method
+  name: (identifier) @declaration.name) @declaration.function
+
+;; ── Declarations — singleton method (class-level: def self.foo) ──────────
+
+(singleton_method
+  name: (identifier) @declaration.name) @declaration.function
+
+;; ── Declarations — closure bound to a local ──────────────────────────────
+;;
+;; handler = ->(x) { target(x) } / lambda { |x| ... } / proc { |x| ... }
+;;
+;; Anchor discipline (same contract as javascript/query.ts): @declaration.function
+;; sits on the INNER (block), NOT on the assignment wrapper and NOT on the
+;; (lambda) node — the block is what carries @scope.block above, so anchoring
+;; there aligns anchor.range with the scope range. That alignment is what lets
+;; pickCallerCallableDef accept a Block-kind scope as a callable boundary.
+;; do_block/block stay @scope.block deliberately — do NOT re-kind them.
+;;
+;; The call forms are restricted to lambda/proc by name. An unrestricted
+;; (call block: (block)) would match ANY method call with a block, so
+;; mapped = items.map { |i| ... } would wrongly declare mapped a callable.
+;; Separate #eq? patterns rather than one #match? alternation: alternation
+;; predicates are a known hazard on this tree-sitter line.
+;; BOTH block forms in every pattern. do...end produces (do_block), braces
+;; produce (block), and do/end is the dominant MULTI-LINE style — covering only
+;; braces left lambda-do-end with a Block scope owning nothing, so its
+;; calls fell through to the enclosing method. @scope.block above already covers
+;; both, so the two channels now agree.
+;;
+;; The !receiver constraint is load-bearing: without it #eq? tests the method
+;; NAME only, so MyMod.lambda {...} / obj.proc {...} would be captured as
+;; closure bindings. Verified against the grammar: with !receiver those are
+;; rejected while bare lambda/proc still match.
+(assignment
+  left: (identifier) @declaration.name
+  right: (lambda body: [(block) (do_block)] @declaration.function))
+
+(assignment
+  left: (identifier) @declaration.name
+  right: (call
+    !receiver
+    method: (identifier) @_lambda-kw
+    block: [(block) (do_block)] @declaration.function)
+  (#eq? @_lambda-kw "lambda"))
+
+(assignment
+  left: (identifier) @declaration.name
+  right: (call
+    !receiver
+    method: (identifier) @_proc-kw
+    block: [(block) (do_block)] @declaration.function)
+  (#eq? @_proc-kw "proc"))
+
+;; Proc.new { ... } / Proc.new do ... end — the explicit constructor form.
+;; Receiver IS required here and must be the Proc constant, so this cannot
+;; collide with the bare-call patterns above.
+(assignment
+  left: (identifier) @declaration.name
+  right: (call
+    receiver: (constant) @_proc-const
+    method: (identifier) @_new-kw
+    block: [(block) (do_block)] @declaration.function)
+  (#eq? @_proc-const "Proc")
+  (#eq? @_new-kw "new"))
+
+;; ── Declarations — variable assignment ───────────────────────────────────
+
+(assignment
+  left: (identifier) @declaration.name) @declaration.variable
+
+;; ── Imports — require / require_relative / load ──────────────────────────
+;;
+;; All three are plain \`call\` nodes in tree-sitter-ruby with no receiver.
+;; The import-decomposer in captures.ts fans out the argument to a path.
+
+(call
+  method: (identifier) @_method
+  (#match? @_method "^(require|require_relative|load)$")) @import.statement
+
+;; ── Type bindings — constructor inference: x = User.new ──────────────────
+;;
+;; tree-sitter-ruby parses \`x = User.new\` as:
+;;   (assignment
+;;     left: (identifier)         ;; "x"
+;;     right: (call
+;;       receiver: (constant)     ;; "User"
+;;       method: (identifier)))   ;; "new"
+;;
+;; Captures the receiver constant as the type.
+
+(assignment
+  left: (identifier) @type-binding.name
+  right: (call
+    receiver: (constant) @type-binding.type
+    method: (identifier) @_new_method
+    (#eq? @_new_method "new"))) @type-binding.constructor
+
+;; Qualified constructor: x = Foo::Bar.new (scope_resolution receiver)
+
+(assignment
+  left: (identifier) @type-binding.name
+  right: (call
+    receiver: (scope_resolution) @type-binding.type
+    method: (identifier) @_new_method2
+    (#eq? @_new_method2 "new"))) @type-binding.constructor
+
+;; Instance-variable constructor: \`@service = UserService.new\` (#2807).
+;; The patterns above bind locals and constants; an instance variable — the
+;; only way a Ruby object gets a field at all — bound nothing, so \`@service.run\`
+;; had no receiver type and the fold declined the whole chain.
+;;
+;; \`@type-binding.name\` is captured on the \`instance_variable\` node, so the
+;; bound name keeps its \`@\` sigil and matches the receiver text at the call
+;; site verbatim. The narrow \`@type-binding.ivar-field\` marker rides the same
+;; node for \`rubyBindingScopeFor\` to hoist on; anchorCaptureFor takes the
+;; broadest range, so the assignment stays the anchor and the source stays
+;; \`constructor-inferred\`.
+;;
+;; These patterns match unconditionally HERE; captures.ts then discards the
+;; whole binding via \`isRubyInstanceIvarWrite\` unless \`self\` at the write is
+;; provably an instance of the enclosing lexical class — which rules out
+;; \`def self.x\`, \`class << self\`, the class body itself, and any write reached
+;; through a block, whose \`self\` its receiver chooses (\`class_eval\`,
+;; \`Class.new\`, \`instance_eval\`, \`define_method\`, …). A tree-sitter pattern
+;; cannot state "and no singleton or block ancestor", so the ownership test has
+;; to be a walk.
+
+(assignment
+  left: (instance_variable) @type-binding.name @type-binding.ivar-field
+  right: (call
+    receiver: (constant) @type-binding.type
+    method: (identifier) @_new_ivar
+    (#eq? @_new_ivar "new"))) @type-binding.constructor
+
+(assignment
+  left: (instance_variable) @type-binding.name @type-binding.ivar-field
+  right: (call
+    receiver: (scope_resolution) @type-binding.type
+    method: (identifier) @_new_ivar_q
+    (#eq? @_new_ivar_q "new"))) @type-binding.constructor
+
+;; Constant constructor: SERVICE = UserService.new (left is constant, not identifier)
+
+(assignment
+  left: (constant) @type-binding.name
+  right: (call
+    receiver: (constant) @type-binding.type
+    method: (identifier) @_new_method3
+    (#eq? @_new_method3 "new"))) @type-binding.constructor
+
+(assignment
+  left: (constant) @type-binding.name
+  right: (call
+    receiver: (scope_resolution) @type-binding.type
+    method: (identifier) @_new_method4
+    (#eq? @_new_method4 "new"))) @type-binding.constructor
+
+;; Call-return inference: x = build_service() (factory pattern)
+
+(assignment
+  left: (identifier) @type-binding.name
+  right: (call
+    !receiver
+    method: (identifier) @type-binding.type)) @type-binding.call-return
+
+;; Constant call-return: SERVICE = build_service()
+
+(assignment
+  left: (constant) @type-binding.name
+  right: (call
+    !receiver
+    method: (identifier) @type-binding.type)) @type-binding.call-return
+
+;; ── Type bindings — for-in loop: for x in collection ─────────────────────
+;;
+;; The loop variable \`x\` gets the element type of the collection.
+;; We bind \`x → collection\` as an alias; the chain-follow pass
+;; resolves \`collection → ElementType\` via YARD \`@param\` annotations.
+;; tree-sitter-ruby wraps the collection in an \`in\` node:
+;;   (for pattern: (identifier) value: (in (identifier)))
+
+(for
+  pattern: (identifier) @type-binding.name
+  value: (in
+    (identifier) @type-binding.type)) @type-binding.alias
+
+;; ── Type bindings — variable alias: x = y ────────────────────────────────
+
+(assignment
+  left: (identifier) @type-binding.name
+  right: (identifier) @type-binding.type) @type-binding.alias
+
+;; ── References — free calls (no receiver) ────────────────────────────────
+
+(call
+  !receiver
+  method: (identifier) @reference.name) @reference.call.free
+
+;; ── References — bare calls (zero-arity calls without parentheses) ──────
+;;
+;; Ruby allows calling methods without parentheses. When no arguments are
+;; passed, tree-sitter-ruby parses them as plain \`identifier\` nodes inside
+;; \`body_statement\`. This mirrors the legacy query pattern. The scope-
+;; resolution pipeline filters false positives via builtInNames and
+;; arity-based overload narrowing.
+
+(body_statement
+  (identifier) @reference.name) @reference.call.free
+
+;; ── References — member calls (with receiver): obj.method() ──────────────
+
+(call
+  receiver: (_) @reference.receiver
+  method: (identifier) @reference.name) @reference.call.member
+
+;; ── References — field writes: obj.field = value ─────────────────────────
+;;
+;; Ruby setter syntax: \`obj.name = x\` is an assignment whose left-hand
+;; side is a \`call\` node with a receiver.
+
+(assignment
+  left: (call
+    receiver: (_) @reference.receiver
+    method: (identifier) @reference.name)) @reference.write
+
+;; ── References — field writes (compound assignment: obj.field += value) ──
+
+(operator_assignment
+  left: (call
+    receiver: (_) @reference.receiver
+    method: (identifier) @reference.name)) @reference.write
+`;
+let _parser = null;
+let _query = null;
+function getRubyParser() {
+    if (_parser === null) {
+        const grammar = loadRubyGrammar();
+        if (grammar === null) {
+            throw new Error('tree-sitter-ruby grammar unavailable — install it (devDependency) or the language degrades to structure-layer capture.');
+        }
+        _parser = new tree_sitter_1.default();
+        _parser.setLanguage(grammar);
+    }
+    return _parser;
+}
+function getRubyScopeQuery() {
+    if (_query === null) {
+        const grammar = loadRubyGrammar();
+        if (grammar === null) {
+            throw new Error('tree-sitter-ruby grammar unavailable — install it (devDependency) or the language degrades to structure-layer capture.');
+        }
+        _query = new tree_sitter_1.default.Query(grammar, RUBY_SCOPE_QUERY);
+    }
+    return _query;
+}

package/dist/core/code/engine/core/ingestion/languages/ruby/receiver-binding.js

@@ -0,0 +1,70 @@
+"use strict";
+/**
+ * Synthesize `@type-binding.self` captures for Ruby methods.
+ *
+ * Every instance method and singleton method inside a class or module body
+ * gets `self` bound to the enclosing class/module name.  Ruby has no
+ * `@staticmethod` concept — even `def self.foo` dispatches on the class.
+ *
+ * For `class << self` (singleton_class) blocks, we walk past the
+ * singleton_class to the real owning class/module, matching the
+ * `rubyResolveEnclosingOwner` logic from the legacy provider.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.findEnclosingClassOrModule = findEnclosingClassOrModule;
+exports.synthesizeRubyReceiverBinding = synthesizeRubyReceiverBinding;
+const ast_helpers_js_1 = require("../../utils/ast-helpers.js");
+/**
+ * Walk up the parent chain from `node` to find the first enclosing
+ * `class` or `module` ancestor.
+ *
+ * - `singleton_class` (`class << self`) is not itself a real type, so we
+ *   skip past it and continue walking to find the true owner.
+ * - Stops at `program` (never walks past the file root).
+ * - Returns `null` when no enclosing class/module is found.
+ */
+function findEnclosingClassOrModule(node) {
+    let cur = node.parent;
+    while (cur !== null) {
+        if (cur.type === 'program')
+            return null;
+        if (cur.type === 'class' || cur.type === 'module')
+            return cur;
+        // singleton_class (`class << self`) is not the real owner —
+        // keep walking to find the enclosing class/module.
+        cur = cur.parent;
+    }
+    return null;
+}
+/**
+ * Extract the class/module name from the `name` field of a `class` or
+ * `module` node.  The field holds a `constant` node whose text is the
+ * simple name (e.g. "MyClass").
+ */
+function extractClassName(classOrModuleNode) {
+    const nameNode = classOrModuleNode.childForFieldName('name');
+    if (nameNode === null)
+        return null;
+    return nameNode.text;
+}
+/**
+ * Given a method node (`method` or `singleton_method`) and its enclosing
+ * `class`/`module` node (or null for top-level defs), synthesize a
+ * `@type-binding.self` capture that binds `self` to the class/module name.
+ *
+ * Returns `null` when:
+ * - `enclosingNode` is null (top-level def has no implicit receiver)
+ * - the enclosing node's name cannot be extracted
+ */
+function synthesizeRubyReceiverBinding(fnNode, enclosingNode) {
+    if (enclosingNode === null)
+        return null;
+    const className = extractClassName(enclosingNode);
+    if (className === null)
+        return null;
+    return {
+        '@type-binding.self': (0, ast_helpers_js_1.syntheticCapture)('@type-binding.self', fnNode, 'self'),
+        '@type-binding.name': (0, ast_helpers_js_1.syntheticCapture)('@type-binding.name', fnNode, 'self'),
+        '@type-binding.type': (0, ast_helpers_js_1.syntheticCapture)('@type-binding.type', fnNode, className),
+    };
+}