rubydex 0.2.5 → 0.2.6

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 8d3ab0270eef0ad7036990b31d888f5d861e7f261b37f76ba3bf99cd1d0b426a
-  data.tar.gz: 59c5a86dbce3070f7e7d8373b9d4c195ad6d282bb78339395318ca06c39d0bb6
+  metadata.gz: c776445f3a3589b62c6f4e1987d424f91aa020585434182c4d16087097e28fb1
+  data.tar.gz: 4d5e1862670c7dd767bce180f70dda589237bf9696b82c99d971b58f2b6ec9bb
 SHA512:
-  metadata.gz: 43d479ff7d5bbae33645d8ebbd06c63b17d508a7b87239dec3c07b2987d54ab1ea5578a20d0e310f9f6bd357e95cf731b623d8f0a40d5fa8472eba1dbb1039ec
-  data.tar.gz: cd85f8985773424f7233b9d5e83d4efc452786a1b1232720942f4c430c4b1e12226a7da72fd88ea3f1dd92587bf8db814f8447dd15cc4bf5d43f56892d485705
+  metadata.gz: 82cc3034740d1e985a938492228a72b77fb4ea3687e07d87ec0cabfb3c342f26db21cc93f1559879037a45ab1d9eed0bb0869c64f55d6ec16ecd50226a5177a8
+  data.tar.gz: e8f7f5ef9e65ab9bbb82fa4cb1f69db91d8df4204ce008beef5f529b18b929a5b4c383ce4083d90fb05a9e054c35e6d04ca58d4b911f2db2e29a7c9c5a6e4698

data/README.md

@@ -84,30 +84,31 @@ like Claude to semantically query your Ruby codebase.
 
 ### Setup
 
-1. Install the binary:
+1. Add Rubydex to the Ruby project you want to index:
+   ```ruby
+   gem "rubydex"
+   ```
+
+2. Install the bundle:
    ```bash
-   cargo install --path rust/rubydex-mcp
+   bundle install
    ```
 
-2. Add rubydex to the Ruby project you want to index:
+3. Configure your MCP client to run `bundle exec rubydex_mcp`.
+
+   Using Claude Code as an example:
    ```bash
-   claude mcp add --scope project rubydex "\${HOME}/.cargo/bin/rubydex_mcp"
+   claude mcp add --scope project rubydex -- bundle exec rubydex_mcp
    ```
 
-   Or manually create a `.mcp.json` in the project root:
-   ```json
-   {
-     "mcpServers": {
-       "rubydex": {
-         "command": "${HOME}/.cargo/bin/rubydex_mcp"
-       }
-     }
-   }
+   Using Codex as an example:
+   ```bash
+   codex mcp add rubydex -- bundle exec rubydex_mcp
    ```
 
-3. Start Claude Code from that project directory. The MCP server indexes
-   the project at startup and provides semantic code intelligence tools.
-   Verify with `/mcp` in the session.
+   Start your MCP client from that project directory. The MCP server indexes
+   the project at startup and provides semantic code intelligence tools through
+   the tools below.
 
 ### Available MCP Tools
 

data/THIRD_PARTY_LICENSES.html

@@ -3823,14 +3823,14 @@ SOFTWARE.
                 <h4>Used by:</h4>
                 <ul class="license-used-by">
                     <li><a
-                            href=" https://crates.io/crates/rubydex ">rubydex
-                            0.1.0</a></li>
+                            href=" https://github.com/Shopify/rubydex ">rubydex
+                            0.2.6</a></li>
                     <li><a
-                            href=" https://crates.io/crates/rubydex-mcp ">rubydex-mcp
-                            0.1.0</a></li>
+                            href=" https://github.com/Shopify/rubydex ">rubydex-mcp
+                            0.2.6</a></li>
                     <li><a
-                            href=" https://crates.io/crates/rubydex-sys ">rubydex-sys
-                            0.1.0</a></li>
+                            href=" https://github.com/Shopify/rubydex ">rubydex-sys
+                            0.2.6</a></li>
                     <li><a
                             href=" https://github.com/DimaKudosh/difflib ">difflib
                             0.4.0</a></li>

data/ext/rubydex/definition.c

@@ -154,8 +154,8 @@ static VALUE rdxr_definition_deprecated(VALUE self) {
 }
 
 // Definition#name_location -> Rubydex::Location or nil
-// For class, module, and singleton class definitions, returns the location of just the name
-// (e.g., "Bar" in "class Foo::Bar"). For other definition types, returns nil.
+// For class, module, singleton class, and method definitions, returns the location of just the name
+// (e.g., "Bar" in "class Foo::Bar", or "foo" in "def foo"). For other definition types, returns nil.
 static VALUE rdxr_definition_name_location(VALUE self) {
     HandleData *data;
     TypedData_Get_Struct(self, HandleData, &handle_type, data);
@@ -341,6 +341,36 @@ static VALUE rdxr_method_alias_definition_signatures(VALUE self) {
     return rdxi_signatures_to_ruby(arr);
 }
 
+// MethodAliasDefinition#target -> Rubydex::Method?
+// Returns the resolved target method declaration by following the alias chain, or nil if the chain could not be
+// resolved (the target name doesn't exist on the owner, or the owner itself never resolved). Raises
+// Rubydex::AliasCycleError when the alias chain forms a cycle.
+static VALUE rdxr_method_alias_definition_target(VALUE self) {
+    HandleData *data;
+    TypedData_Get_Struct(self, HandleData, &handle_type, data);
+
+    void *graph;
+    TypedData_Get_Struct(data->graph_obj, void *, &graph_type, graph);
+
+    CMethodAliasTargetResult result = rdx_method_alias_definition_target(graph, data->id);
+
+    switch (result.status) {
+    case CMethodAliasResolution_Resolved: {
+        VALUE decl_class = rdxi_declaration_class_for_kind(result.declaration->kind);
+        VALUE argv[] = {data->graph_obj, ULL2NUM(result.declaration->id)};
+
+        free_c_declaration(result.declaration);
+        return rb_class_new_instance(2, argv, decl_class);
+    }
+    case CMethodAliasResolution_NotFound:
+        return Qnil;
+    case CMethodAliasResolution_Cycle:
+        rb_raise(rb_const_get(mRubydex, rb_intern("AliasCycleError")), "method alias chain forms a cycle");
+    default:
+        rb_raise(rb_eRuntimeError, "Unknown CMethodAliasResolution: %d", result.status);
+    }
+}
+
 void rdxi_initialize_definition(VALUE mod) {
     mRubydex = mod;
 
@@ -387,5 +417,6 @@ void rdxi_initialize_definition(VALUE mod) {
     cClassVariableDefinition = rb_define_class_under(mRubydex, "ClassVariableDefinition", cDefinition);
     cMethodAliasDefinition = rb_define_class_under(mRubydex, "MethodAliasDefinition", cDefinition);
     rb_define_method(cMethodAliasDefinition, "signatures", rdxr_method_alias_definition_signatures, 0);
+    rb_define_method(cMethodAliasDefinition, "target", rdxr_method_alias_definition_target, 0);
     cGlobalVariableAliasDefinition = rb_define_class_under(mRubydex, "GlobalVariableAliasDefinition", cDefinition);
 }

data/ext/rubydex/document.c

@@ -3,6 +3,7 @@
 #include "graph.h"
 #include "handle.h"
 #include "rustbindings.h"
+#include "utils.h"
 
 VALUE cDocument;
 
@@ -85,6 +86,40 @@ static VALUE rdxr_document_definitions(VALUE self) {
     return self;
 }
 
+// Size function for the Document#method_references enumerator
+static VALUE document_method_references_size(VALUE self, VALUE _args, VALUE _eobj) {
+    HandleData *data;
+    TypedData_Get_Struct(self, HandleData, &handle_type, data);
+
+    void *graph;
+    TypedData_Get_Struct(data->graph_obj, void *, &graph_type, graph);
+    struct MethodReferencesIter *iter = rdx_document_method_references_iter_new(graph, data->id);
+    size_t len = rdx_method_references_iter_len(iter);
+    rdx_method_references_iter_free(iter);
+
+    return SIZET2NUM(len);
+}
+
+// Document#method_references: () -> Enumerator[MethodReference]
+// Returns an enumerator that yields all method references for this document lazily
+static VALUE rdxr_document_method_references(VALUE self) {
+    if (!rb_block_given_p()) {
+        return rb_enumeratorize_with_size(self, rb_str_new2("method_references"), 0, NULL,
+                                          document_method_references_size);
+    }
+
+    HandleData *data;
+    TypedData_Get_Struct(self, HandleData, &handle_type, data);
+
+    void *graph;
+    TypedData_Get_Struct(data->graph_obj, void *, &graph_type, graph);
+    void *iter = rdx_document_method_references_iter_new(graph, data->id);
+    VALUE args = rb_ary_new_from_args(2, data->graph_obj, ULL2NUM((uintptr_t)iter));
+    rb_ensure(rdxi_method_references_yield, args, rdxi_method_references_ensure, args);
+
+    return self;
+}
+
 void rdxi_initialize_document(VALUE mRubydex) {
     cDocument = rb_define_class_under(mRubydex, "Document", rb_cObject);
 
@@ -92,6 +127,7 @@ void rdxi_initialize_document(VALUE mRubydex) {
     rb_define_method(cDocument, "initialize", rdxr_handle_initialize, 2);
     rb_define_method(cDocument, "uri", rdxr_document_uri, 0);
     rb_define_method(cDocument, "definitions", rdxr_document_definitions, 0);
+    rb_define_method(cDocument, "method_references", rdxr_document_method_references, 0);
 
     rb_funcall(rb_singleton_class(cDocument), rb_intern("private"), 1, ID2SYM(rb_intern("new")));
 }

data/ext/rubydex/graph.c

@@ -16,17 +16,20 @@ static VALUE cKeywordParameter;
 // Interned once in `rdxi_initialize_graph` to avoid repeated symbol-table lookups on hot completion paths.
 static ID id_self_receiver;
 
-// Extracts the optional `self_receiver:` kwarg from `opts`. Returns NULL when the kwarg is
-// absent or nil; raises ArgumentError when the value is the wrong type or empty.
+// Extracts the required `self_receiver:` kwarg from `opts`. Returns NULL when the value is `nil`,
+// which means "no self-type to walk" (e.g., empty class body where the singleton class hasn't
+// been created). Raises ArgumentError if the kwarg is absent, of the wrong type, or an empty
+// string. The kwarg is required so that callers commit to a self type — there is no implicit
+// default.
 static const char *extract_self_receiver(VALUE opts) {
     if (NIL_P(opts)) {
-        return NULL;
+        rb_raise(rb_eArgError, "missing keyword: self_receiver");
     }
 
     VALUE kwarg_val;
-    rb_get_kwargs(opts, &id_self_receiver, 0, 1, &kwarg_val);
+    rb_get_kwargs(opts, &id_self_receiver, 1, 0, &kwarg_val);
 
-    if (kwarg_val == Qundef || NIL_P(kwarg_val)) {
+    if (NIL_P(kwarg_val)) {
         return NULL;
     }
 
@@ -45,7 +48,18 @@ static void graph_free(void *ptr) {
     }
 }
 
-const rb_data_type_t graph_type = {"Graph", {0, graph_free, 0}, 0, 0, RUBY_TYPED_FREE_IMMEDIATELY};
+const rb_data_type_t graph_type = {
+    .wrap_struct_name = "Graph",
+    .function = {
+        .dmark = NULL,
+        .dfree = graph_free,
+        .dsize = NULL,
+        .dcompact = NULL,
+    },
+    .parent = NULL,
+    .data = NULL,
+    .flags = RUBY_TYPED_FREE_IMMEDIATELY,
+};
 
 // Custom allocator for the Graph class. Calls into Rust to create a new `Arc<Mutex<Graph>>` that gets stored internally
 // as a void pointer
@@ -589,11 +603,10 @@ static VALUE completion_result_to_ruby_array(struct CompletionResult result, VAL
     return ruby_array;
 }
 
-// Graph#complete_expression: (Array[String] nesting, self_receiver: nil) -> Array[Declaration | Keyword]
+// Graph#complete_expression: (Array[String] nesting, self_receiver:) -> Array[Declaration | Keyword]
 // Returns completion candidates for an expression context.
-// The nesting array represents the lexical scope stack. The optional self_receiver keyword argument
-// overrides the self-type (e.g., "Foo::<Foo>" for `def Foo.bar`); when nil, self is derived from
-// the innermost nesting element.
+// The nesting array represents the lexical scope stack. The required self_receiver keyword argument overrides the
+// self-type (e.g., "Foo::<Foo>" for `def Foo.bar`); when nil, self is derived from the innermost nesting element.
 static VALUE rdxr_graph_complete_expression(int argc, VALUE *argv, VALUE self) {
     VALUE nesting, opts;
     rb_scan_args(argc, argv, "1:", &nesting, &opts);
@@ -614,10 +627,11 @@ static VALUE rdxr_graph_complete_expression(int argc, VALUE *argv, VALUE self) {
     return completion_result_to_ruby_array(result, self);
 }
 
-// Graph#complete_namespace_access: (String name, self_receiver: nil) -> Array[Declaration]
+// Graph#complete_namespace_access: (String name, self_receiver:) -> Array[Declaration]
 // Returns completion candidates after a namespace access operator (e.g., `Foo::`).
-// The optional self_receiver kwarg is the caller's runtime self type, used to filter
-// visibility-restricted singleton methods (e.g., `private_class_method`).
+// The required self_receiver kwarg is the caller's runtime self type, used to filter
+// visibility-restricted singleton methods (e.g., `private_class_method`). Pass `nil` when there
+// is no caller context.
 static VALUE rdxr_graph_complete_namespace_access(int argc, VALUE *argv, VALUE self) {
     VALUE name, opts;
     rb_scan_args(argc, argv, "1:", &name, &opts);
@@ -633,10 +647,10 @@ static VALUE rdxr_graph_complete_namespace_access(int argc, VALUE *argv, VALUE s
     return completion_result_to_ruby_array(result, self);
 }
 
-// Graph#complete_method_call: (String name, self_receiver: nil) -> Array[Declaration]
+// Graph#complete_method_call: (String name, self_receiver:) -> Array[Declaration]
 // Returns completion candidates after a method call operator (e.g., `foo.`).
-// The optional self_receiver kwarg is the caller's runtime self type, used for MRI-style
-// visibility checks (private/protected).
+// The required self_receiver kwarg is the caller's runtime self type, used for visibility checks (private/protected).
+// Pass `nil` when there is no caller context.
 static VALUE rdxr_graph_complete_method_call(int argc, VALUE *argv, VALUE self) {
     VALUE name, opts;
     rb_scan_args(argc, argv, "1:", &name, &opts);
@@ -652,9 +666,9 @@ static VALUE rdxr_graph_complete_method_call(int argc, VALUE *argv, VALUE self)
     return completion_result_to_ruby_array(result, self);
 }
 
-// Graph#complete_method_argument: (String name, Array[String] nesting, self_receiver: nil) -> Array[Declaration | Keyword | KeywordParameter]
+// Graph#complete_method_argument: (String name, Array[String] nesting, self_receiver:) -> Array[Declaration | Keyword | KeywordParameter]
 // Returns completion candidates inside a method call's argument list (e.g., `foo.bar(|)`).
-// See complete_expression for semantics of self_receiver.
+// See complete_expression for semantics of self_receiver (required, may be nil).
 static VALUE rdxr_graph_complete_method_argument(int argc, VALUE *argv, VALUE self) {
     VALUE name, nesting, opts;
     rb_scan_args(argc, argv, "2:", &name, &nesting, &opts);

data/ext/rubydex/handle.h

@@ -22,12 +22,25 @@ static void handle_free(void *ptr) {
 }
 
 static const rb_data_type_t handle_type = {
-    "RubydexHandle", {handle_mark, handle_free, 0}, 0, 0, RUBY_TYPED_FREE_IMMEDIATELY};
+    .wrap_struct_name = "RubydexHandle",
+    .function = {
+        .dmark = handle_mark,
+        .dfree = handle_free,
+        .dsize = NULL,
+        .dcompact = NULL,
+    },
+    .parent = NULL,
+    .data = NULL,
+    .flags = RUBY_TYPED_FREE_IMMEDIATELY,
+};
 
 static VALUE rdxr_handle_alloc(VALUE klass) {
     HandleData *data = ALLOC(HandleData);
-    data->graph_obj = Qnil;
-    data->id = 0;
+
+    *data = (HandleData) {
+        .graph_obj = Qnil,
+        .id = 0,
+    };
 
     return TypedData_Wrap_Struct(klass, &handle_type, data);
 }
@@ -35,8 +48,11 @@ static VALUE rdxr_handle_alloc(VALUE klass) {
 static VALUE rdxr_handle_initialize(VALUE self, VALUE graph_obj, VALUE id_val) {
     HandleData *data;
     TypedData_Get_Struct(self, HandleData, &handle_type, data);
-    data->graph_obj = graph_obj;
-    data->id = NUM2ULL(id_val);
+
+    *data = (HandleData) {
+        .graph_obj = graph_obj,
+        .id = NUM2ULL(id_val),
+    };
 
     return self;
 }

data/lib/rubydex/errors.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+module Rubydex
+  class Error < StandardError; end
+
+  # Raised when `MethodAliasDefinition#target` walks an alias chain that loops back on itself.
+  class AliasCycleError < Error; end
+end

data/lib/rubydex/location.rb

@@ -14,6 +14,19 @@ module Rubydex
     #: Integer
     attr_reader :start_line, :end_line, :start_column, :end_column
 
+    class << self
+      #: (Prism::Location prism_location, uri: String) -> Location
+      def from_prism(prism_location, uri:)
+        Location.new(
+          uri: uri,
+          start_line: prism_location.start_line - 1,
+          start_column: prism_location.start_column,
+          end_line: prism_location.end_line - 1,
+          end_column: prism_location.end_column,
+        )
+      end
+    end
+
     #: (?uri: String, ?start_line: Integer, ?end_line: Integer, ?start_column: Integer, ?end_column: Integer) -> void
     def initialize(uri:, start_line:, end_line:, start_column:, end_column:)
       @uri = uri
@@ -68,6 +81,17 @@ module Rubydex
   # A one based location intended for display purposes. This is what should be used when displaying a location to users,
   # like in CLIs
   class DisplayLocation < Location
+    class << self
+      #: (Prism::Location prism_location, uri: String) -> Location
+      def from_prism(prism_location, uri:)
+        raise NotImplementedError, <<~MESSAGE
+          Cannot convert Prism::Location directly to a Rubydex::DisplayLocation.
+          Start with `Rubydex::Location.from_prism(...)` and then convert the resulting
+          location with `to_display`
+        MESSAGE
+      end
+    end
+
     # Returns itself
     #
     #: () -> DisplayLocation

data/lib/rubydex/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Rubydex
-  VERSION = "0.2.5"
+  VERSION = "0.2.6"
 end

data/lib/rubydex.rb

@@ -14,6 +14,7 @@ rescue LoadError
   require "rubydex/rubydex"
 end
 
+require "rubydex/errors"
 require "rubydex/failures"
 require "rubydex/location"
 require "rubydex/comment"

data/rbi/rubydex.rbi

@@ -174,7 +174,10 @@ class Rubydex::ConstantDefinition < Rubydex::Definition; end
 class Rubydex::GlobalVariableAliasDefinition < Rubydex::Definition; end
 class Rubydex::GlobalVariableDefinition < Rubydex::Definition; end
 class Rubydex::InstanceVariableDefinition < Rubydex::Definition; end
-class Rubydex::MethodAliasDefinition < Rubydex::Definition; end
+class Rubydex::MethodAliasDefinition < Rubydex::Definition
+  sig { returns(T.nilable(Rubydex::Method)) }
+  def target; end
+end
 class Rubydex::MethodDefinition < Rubydex::Definition; end
 
 class Rubydex::ModuleDefinition < Rubydex::Definition
@@ -246,6 +249,9 @@ class Rubydex::Document
   sig { returns(T::Enumerable[Rubydex::Definition]) }
   def definitions; end
 
+  sig { returns(T::Enumerable[Rubydex::MethodReference]) }
+  def method_references; end
+
   sig { returns(String) }
   def uri; end
 
@@ -257,6 +263,7 @@ class Rubydex::Document
 end
 
 class Rubydex::Error < StandardError; end
+class Rubydex::AliasCycleError < Rubydex::Error; end
 
 class Rubydex::Failure
   sig { params(message: String).void }
@@ -344,48 +351,48 @@ class Rubydex::Graph
   # Returns completion candidates for an expression context. This includes all keywords, constants, methods, instance
   # variables, class variables and global variables reachable from the current lexical scope and self type.
   #
-  # The nesting array represents the lexical scope stack. The optional `self_receiver` keyword argument overrides the
+  # The nesting array represents the lexical scope stack. The required `self_receiver` keyword argument overrides the
   # self type independently of the lexical scope (e.g., `"Foo::<Foo>"` for `def Foo.bar`). This distinction is important
   # because constants and class variables are always attached to the lexical scope. Meanwhile, methods and instance
-  # variables are attached to the type of `self` and those don't always match.
+  # variables are attached to the type of `self` and those don't always match. Pass `nil` when the self type is unknown
   sig do
     params(
       nesting: T::Array[String],
       self_receiver: T.nilable(String),
     ).returns(T::Array[T.any(Rubydex::Declaration, Rubydex::Keyword)])
   end
-  def complete_expression(nesting, self_receiver: nil); end
+  def complete_expression(nesting, self_receiver:); end
 
   # Returns completion candidates after a namespace access operator (e.g., `Foo::`). This includes all constants and
   # singleton methods for the namespace and its ancestors.
   #
-  # The optional `self_receiver` kwarg is the caller's runtime self type. It's used to filter visibility-restricted
-  # singleton methods (e.g., `private_class_method`). Pass `nil` (the default) for top-level/script scope.
+  # The required `self_receiver` kwarg is the caller's runtime self type. It's used to filter visibility-restricted
+  # singleton methods (e.g., `private_class_method`). Pass `nil` for top-level/script scope.
   sig do
     params(
       name: String,
       self_receiver: T.nilable(String),
     ).returns(T::Array[Rubydex::Declaration])
   end
-  def complete_namespace_access(name, self_receiver: nil); end
+  def complete_namespace_access(name, self_receiver:); end
 
   # Returns completion candidates after a method call operator (e.g., `foo.`). This includes all methods that exist on
   # the type of the receiver and its ancestors.
   #
-  # The optional `self_receiver` kwarg is the caller's runtime self type. It's used for visibility checks for `private`
-  # and `protected` methods. Pass `nil` (the default) for top-level/script scope.
+  # The required `self_receiver` kwarg is the caller's runtime self type. It's used for visibility checks for `private`
+  # and `protected` methods. Pass `nil` for top-level/script scope.
   sig do
     params(
       name: String,
       self_receiver: T.nilable(String),
     ).returns(T::Array[Rubydex::Method])
   end
-  def complete_method_call(name, self_receiver: nil); end
+  def complete_method_call(name, self_receiver:); end
 
   # Returns completion candidates inside a method call's argument list (e.g., `foo.bar(|)`). This includes everything
   # that expression completion provides plus keyword argument names of the method being called.
   #
-  # See `complete_expression` for the semantics of `nesting` and `self_receiver`.
+  # See `complete_expression` for the semantics of `nesting` and `self_receiver` (required, may be `nil`).
   sig do
     params(
       name: String,
@@ -393,7 +400,7 @@ class Rubydex::Graph
       self_receiver: T.nilable(String),
     ).returns(T::Array[T.any(Rubydex::Declaration, Rubydex::Keyword, Rubydex::KeywordParameter)])
   end
-  def complete_method_argument(name, nesting, self_receiver: nil); end
+  def complete_method_argument(name, nesting, self_receiver:); end
 
   private
 
@@ -411,6 +418,11 @@ class Rubydex::Graph
 end
 
 class Rubydex::DisplayLocation < Rubydex::Location
+  class << self
+    sig { params(prism_location: Prism::Location, uri: String).returns(T.noreturn) }
+    def from_prism(prism_location, uri:); end
+  end
+
   sig { returns([String, Integer, Integer, Integer, Integer]) }
   def comparable_values; end
 
@@ -424,6 +436,11 @@ end
 class Rubydex::Location
   include ::Comparable
 
+  class << self
+    sig { params(prism_location: Prism::Location, uri: String).returns(Rubydex::Location) }
+    def from_prism(prism_location, uri:); end
+  end
+
   sig do
     params(
       uri: String,

data/rust/Cargo.lock

@@ -1048,7 +1048,7 @@ dependencies = [
 
 [[package]]
 name = "rubydex"
-version = "0.1.0"
+version = "0.2.6"
 dependencies = [
  "assert_cmd",
  "bitflags",
@@ -1072,7 +1072,7 @@ dependencies = [
 
 [[package]]
 name = "rubydex-mcp"
-version = "0.1.0"
+version = "0.2.6"
 dependencies = [
  "assert_cmd",
  "clap",
@@ -1087,7 +1087,7 @@ dependencies = [
 
 [[package]]
 name = "rubydex-sys"
-version = "0.1.0"
+version = "0.2.6"
 dependencies = [
  "cbindgen",
  "libc",

data/rust/rubydex/Cargo.toml

@@ -1,9 +1,15 @@
 [package]
 name = "rubydex"
-version = "0.1.0"
+version = "0.2.6"
 edition = "2024"
 rust-version = "1.89.0"
 license = "MIT"
+description = "High-performance Ruby code indexing and static analysis library."
+homepage = "https://github.com/Shopify/rubydex"
+repository = "https://github.com/Shopify/rubydex"
+readme = "README.md"
+keywords = ["ruby", "indexing", "static-analysis"]
+categories = ["development-tools"]
 
 [[bin]]
 name = "rubydex_cli"