rubydex 0.2.7-aarch64-linux → 0.2.9-aarch64-linux

data/rust/rubydex/tests/cli.rs

@@ -19,6 +19,9 @@ fn prints_help() {
         .success()
         .stdout(predicate::str::contains("A Static Analysis Toolkit for Ruby"))
         .stdout(predicate::str::contains("Usage:"))
+        .stdout(predicate::str::contains(
+            "If the first path is a directory, it is used as the workspace root for rubydex.toml",
+        ))
         .stdout(predicate::str::contains("--stats"))
         .stdout(predicate::str::contains("--dot"))
         .stdout(predicate::str::contains("--stop-after"));
@@ -52,6 +55,69 @@ fn paths_argument_variants() {
     });
 }
 
+#[test]
+fn single_directory_argument_is_workspace_root_for_config() {
+    with_context(|context| {
+        context.write("included.rb", "class Included\nend\n");
+        context.write("excluded/skipped.rb", "class Skipped\nend\n");
+        context.write("rubydex.toml", "exclude = [\"excluded\"]\n");
+
+        rdx(&[context.absolute_path().to_str().unwrap()])
+            .success()
+            .stderr(predicate::str::is_empty())
+            .stdout(predicate::str::contains("Indexed 2 files"));
+    });
+}
+
+#[test]
+fn first_directory_argument_is_workspace_root_for_config() {
+    with_context(|context| {
+        context.write("included/kept.rb", "class Included\nend\n");
+        context.write("excluded/skipped.rb", "class Skipped\nend\n");
+        context.write("rubydex.toml", "exclude = [\"excluded\"]\n");
+
+        rdx(&[
+            context.absolute_path().to_str().unwrap(),
+            context.absolute_path_to("included").to_str().unwrap(),
+            context.absolute_path_to("excluded").to_str().unwrap(),
+        ])
+        .success()
+        .stderr(predicate::str::is_empty())
+        .stdout(predicate::str::contains("Indexed 2 files"));
+    });
+}
+
+#[test]
+fn single_file_argument_is_not_used_as_workspace_root() {
+    with_context(|context| {
+        context.write("included.rb", "class Included\nend\n");
+        context.write("excluded/skipped.rb", "class Skipped\nend\n");
+        context.write("rubydex.toml", "exclude = [\"excluded\"]\n");
+
+        rdx(&[context.absolute_path_to("excluded/skipped.rb").to_str().unwrap()])
+            .success()
+            .stderr(predicate::str::is_empty())
+            .stdout(predicate::str::contains("Indexed 2 files"));
+    });
+}
+
+#[test]
+fn first_file_argument_is_not_used_as_workspace_root() {
+    with_context(|context| {
+        context.write("included.rb", "class Included\nend\n");
+        context.write("excluded/skipped.rb", "class Skipped\nend\n");
+        context.write("rubydex.toml", "exclude = [\"excluded\"]\n");
+
+        rdx(&[
+            context.absolute_path_to("included.rb").to_str().unwrap(),
+            context.absolute_path_to("excluded").to_str().unwrap(),
+        ])
+        .success()
+        .stderr(predicate::str::is_empty())
+        .stdout(predicate::str::contains("Indexed 3 files"));
+    });
+}
+
 #[test]
 fn prints_index_metrics() {
     with_context(|context| {

data/rust/rubydex-sys/src/declaration_api.rs

@@ -9,7 +9,7 @@ use crate::definition_api::{DefinitionsIter, rdx_definitions_iter_new_from_ids};
 use crate::graph_api::{GraphPointer, with_graph};
 use crate::reference_api::{CConstantReference, CMethodReference, ConstantReferencesIter, MethodReferencesIter};
 use crate::utils;
-use rubydex::model::ids::{DeclarationId, StringId};
+use rubydex::model::ids::{DeclarationId, StringId, declaration_id_from_lookup_name};
 
 #[repr(C)]
 #[derive(Debug, Clone, Copy)]
@@ -80,7 +80,7 @@ pub(crate) unsafe fn decl_id_from_char_ptr(ptr: *const c_char) -> Option<Declara
     if s.is_empty() {
         return None;
     }
-    Some(DeclarationId::from(s.as_str()))
+    Some(declaration_id_from_lookup_name(&s))
 }
 
 /// An iterator over declaration IDs

data/rust/rubydex-sys/src/graph_api.rs

@@ -11,7 +11,7 @@ use rubydex::errors::Errors;
 use rubydex::indexing::LanguageId;
 use rubydex::model::encoding::Encoding;
 use rubydex::model::graph::Graph;
-use rubydex::model::ids::{DeclarationId, NameId, UriId};
+use rubydex::model::ids::{DeclarationId, NameId, UriId, declaration_id_from_lookup_name};
 use rubydex::model::keywords;
 use rubydex::model::name::NameRef;
 use rubydex::model::visibility::Visibility;
@@ -58,64 +58,75 @@ where
     result
 }
 
-/// Searches the graph using exact substring matching
+/// Searches the graph using exact substring matching, returning every declaration whose name matches any of the
+/// queries.
 ///
 /// # Safety
 ///
-/// Expects both the graph and the query pointers to be valid
+/// Expects `pointer` to be a valid graph and `c_queries` to point to an array of `count` valid, NUL-terminated C
+/// strings. Returns a null pointer when `count` is zero, `c_queries` is null, or any query is not valid UTF-8.
 #[unsafe(no_mangle)]
 pub unsafe extern "C" fn rdx_graph_declarations_search(
     pointer: GraphPointer,
-    c_query: *const c_char,
+    c_queries: *const *const c_char,
+    count: usize,
 ) -> *mut DeclarationsIter {
-    {
-        let Ok(query) = (unsafe { utils::convert_char_ptr_to_string(c_query) }) else {
-            return ptr::null_mut();
-        };
+    if count == 0 || c_queries.is_null() {
+        return ptr::null_mut();
+    }
 
-        let entries = with_graph(pointer, |graph| {
-            query::declaration_search(graph, &query, &query::MatchMode::Exact)
-                .into_iter()
-                .filter_map(|id| {
-                    let decl = graph.declarations().get(&id)?;
-                    Some(CDeclaration::from_declaration(id, decl))
-                })
-                .collect::<Vec<CDeclaration>>()
-                .into_boxed_slice()
-        });
+    let Ok(queries) = (unsafe { utils::convert_double_pointer_to_vec(c_queries, count) }) else {
+        return ptr::null_mut();
+    };
+    let query_refs: Vec<&str> = queries.iter().map(String::as_str).collect();
 
-        DeclarationsIter::new(entries)
-    }
+    let entries = with_graph(pointer, |graph| {
+        query::declaration_search(graph, &query_refs, &query::MatchMode::Exact)
+            .into_iter()
+            .filter_map(|id| {
+                let decl = graph.declarations().get(&id)?;
+                Some(CDeclaration::from_declaration(id, decl))
+            })
+            .collect::<Vec<CDeclaration>>()
+            .into_boxed_slice()
+    });
+
+    DeclarationsIter::new(entries)
 }
 
-/// Searches the graph using fuzzy matching
+/// Searches the graph using fuzzy matching, returning every declaration whose name matches any of the queries.
 ///
 /// # Safety
 ///
-/// Expects both the graph and the query pointers to be valid
+/// Expects `pointer` to be a valid graph and `c_queries` to point to an array of `count` valid, NUL-terminated C
+/// strings. Returns a null pointer when `count` is zero, `c_queries` is null, or any query is not valid UTF-8.
 #[unsafe(no_mangle)]
 pub unsafe extern "C" fn rdx_graph_declarations_fuzzy_search(
     pointer: GraphPointer,
-    c_query: *const c_char,
+    c_queries: *const *const c_char,
+    count: usize,
 ) -> *mut DeclarationsIter {
-    {
-        let Ok(query) = (unsafe { utils::convert_char_ptr_to_string(c_query) }) else {
-            return ptr::null_mut();
-        };
+    if count == 0 || c_queries.is_null() {
+        return ptr::null_mut();
+    }
 
-        let entries = with_graph(pointer, |graph| {
-            query::declaration_search(graph, &query, &query::MatchMode::Fuzzy)
-                .into_iter()
-                .filter_map(|id| {
-                    let decl = graph.declarations().get(&id)?;
-                    Some(CDeclaration::from_declaration(id, decl))
-                })
-                .collect::<Vec<CDeclaration>>()
-                .into_boxed_slice()
-        });
+    let Ok(queries) = (unsafe { utils::convert_double_pointer_to_vec(c_queries, count) }) else {
+        return ptr::null_mut();
+    };
+    let query_refs: Vec<&str> = queries.iter().map(String::as_str).collect();
 
-        DeclarationsIter::new(entries)
-    }
+    let entries = with_graph(pointer, |graph| {
+        query::declaration_search(graph, &query_refs, &query::MatchMode::Fuzzy)
+            .into_iter()
+            .filter_map(|id| {
+                let decl = graph.declarations().get(&id)?;
+                Some(CDeclaration::from_declaration(id, decl))
+            })
+            .collect::<Vec<CDeclaration>>()
+            .into_boxed_slice()
+    });
+
+    DeclarationsIter::new(entries)
 }
 
 /// # Panics
@@ -158,37 +169,41 @@ pub unsafe extern "C" fn rdx_graph_resolve_constant(
     })
 }
 
-/// Adds paths to exclude from file discovery during indexing.
+/// Adds glob patterns to exclude from file discovery during indexing.
 ///
 /// # Panics
 ///
-/// Will panic if the given array of C string paths cannot be converted to a `Vec<String>`.
+/// Will panic if the given array of C string patterns cannot be converted to a `Vec<String>`.
 ///
 /// # Safety
 ///
 /// - `pointer` must be a valid `GraphPointer` previously returned by this crate.
-/// - `paths` must be an array of `count` valid, null-terminated UTF-8 strings.
+/// - `patterns` must be an array of `count` valid, null-terminated UTF-8 strings.
 #[unsafe(no_mangle)]
-pub unsafe extern "C" fn rdx_graph_exclude_paths(pointer: GraphPointer, paths: *const *const c_char, count: usize) {
-    let paths: Vec<String> = unsafe { utils::convert_double_pointer_to_vec(paths, count).unwrap() };
-    let path_bufs: Vec<PathBuf> = paths.into_iter().map(PathBuf::from).collect();
-    with_mut_graph(pointer, |graph| graph.exclude_paths(path_bufs));
+pub unsafe extern "C" fn rdx_graph_exclude_patterns(
+    pointer: GraphPointer,
+    patterns: *const *const c_char,
+    count: usize,
+) {
+    let patterns: Vec<String> = unsafe { utils::convert_double_pointer_to_vec(patterns, count).unwrap() };
+    let entries: Vec<Box<str>> = patterns.into_iter().map(String::into_boxed_str).collect();
+    with_mut_graph(pointer, |graph| graph.exclude_patterns(entries));
 }
 
-/// Returns the currently excluded paths as an array of C strings. Writes the count to `out_count`. Returns NULL if no
-/// paths are excluded. Caller must free with `free_c_string_array`.
+/// Returns the currently excluded glob patterns as an array of C strings. Writes the count to `out_count`. Returns NULL
+/// if no patterns are excluded. Caller must free with `free_c_string_array`.
 ///
 /// # Safety
 ///
 /// - `pointer` must be a valid `GraphPointer` previously returned by this crate.
 /// - `out_count` must be a valid, writable pointer.
 #[unsafe(no_mangle)]
-pub unsafe extern "C" fn rdx_graph_excluded_paths(
+pub unsafe extern "C" fn rdx_graph_excluded_patterns(
     pointer: GraphPointer,
     out_count: *mut usize,
 ) -> *const *const c_char {
     with_graph(pointer, |graph| {
-        let excluded = graph.excluded_paths();
+        let excluded = graph.excluded_patterns();
 
         if excluded.is_empty() {
             unsafe { *out_count = 0 };
@@ -202,7 +217,7 @@ pub unsafe extern "C" fn rdx_graph_excluded_paths(
                 // on Windows if a configuration file is using forward slashes. For example:
                 //
                 // C:\project/vendor/bundle
-                let normalized = path.to_string_lossy().replace(std::path::MAIN_SEPARATOR, "/");
+                let normalized = path.replace(std::path::MAIN_SEPARATOR, "/");
 
                 CString::new(normalized)
                     .ok()
@@ -302,7 +317,7 @@ pub unsafe extern "C" fn rdx_index_all(
     let file_paths: Vec<String> = unsafe { utils::convert_double_pointer_to_vec(file_paths, count).unwrap() };
 
     with_mut_graph(pointer, |graph| {
-        let (file_paths, listing_errors) = listing::collect_file_paths(file_paths, &graph.excluded_paths());
+        let (file_paths, listing_errors) = listing::collect_file_paths(file_paths, &graph.excluded_patterns());
         let indexing_errors = indexing::index_files(graph, file_paths, indexing::IndexerBackend::RubyIndexer);
 
         let all_errors: Vec<String> = listing_errors
@@ -498,7 +513,7 @@ pub unsafe extern "C" fn rdx_graph_get_declaration(pointer: GraphPointer, name:
     };
 
     with_graph(pointer, |graph| {
-        let decl_id = DeclarationId::from(name_str.as_str());
+        let decl_id = declaration_id_from_lookup_name(&name_str);
 
         if let Some(decl) = graph.declarations().get(&decl_id) {
             Box::into_raw(Box::new(CDeclaration::from_declaration(decl_id, decl))).cast_const()
@@ -917,7 +932,7 @@ pub unsafe extern "C" fn rdx_graph_complete_namespace_access(
             graph,
             CompletionReceiver::NamespaceAccess {
                 self_decl_id,
-                namespace_decl_id: DeclarationId::from(name_str.as_str()),
+                namespace_decl_id: declaration_id_from_lookup_name(&name_str),
             },
             Vec::new(),
         )
@@ -951,7 +966,7 @@ pub unsafe extern "C" fn rdx_graph_complete_method_call(
             graph,
             CompletionReceiver::MethodCall {
                 self_decl_id,
-                receiver_decl_id: DeclarationId::from(name_str.as_str()),
+                receiver_decl_id: declaration_id_from_lookup_name(&name_str),
             },
             Vec::new(),
         )
@@ -995,7 +1010,7 @@ pub unsafe extern "C" fn rdx_graph_complete_method_argument(
             CompletionReceiver::MethodArgument {
                 self_decl_id,
                 nesting_name_id,
-                method_decl_id: DeclarationId::from(name_str.as_str()),
+                method_decl_id: declaration_id_from_lookup_name(&name_str),
             },
             names_to_untrack,
         )

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: rubydex
 version: !ruby/object:Gem::Version
-  version: 0.2.7
+  version: 0.2.9
 platform: aarch64-linux
 authors:
 - Shopify
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2026-06-30 00:00:00.000000000 Z
+date: 2026-07-09 00:00:00.000000000 Z
 dependencies: []
 description: A high-performance static analysis suite for Ruby, built in Rust with
   Ruby APIs
@@ -16,7 +16,6 @@ email:
 - ruby@shopify.com
 executables:
 - rdx
-- rubydex_mcp
 extensions: []
 extra_rdoc_files: []
 files:
@@ -24,7 +23,6 @@ files:
 - README.md
 - THIRD_PARTY_LICENSES.html
 - exe/rdx
-- exe/rubydex_mcp
 - ext/rubydex/declaration.c
 - ext/rubydex/declaration.h
 - ext/rubydex/definition.c
@@ -51,7 +49,6 @@ files:
 - lib/rubydex/3.3/rubydex.so
 - lib/rubydex/3.4/rubydex.so
 - lib/rubydex/4.0/rubydex.so
-- lib/rubydex/bin/rubydex_mcp
 - lib/rubydex/comment.rb
 - lib/rubydex/declaration.rb
 - lib/rubydex/diagnostic.rb
@@ -62,6 +59,15 @@ files:
 - lib/rubydex/keyword_parameter.rb
 - lib/rubydex/librubydex_sys.so
 - lib/rubydex/location.rb
+- lib/rubydex/mcp_server.rb
+- lib/rubydex/mcp_server/protocol.rb
+- lib/rubydex/mcp_server/tools/base_tool.rb
+- lib/rubydex/mcp_server/tools/codebase_stats_tool.rb
+- lib/rubydex/mcp_server/tools/find_constant_references_tool.rb
+- lib/rubydex/mcp_server/tools/get_declaration_tool.rb
+- lib/rubydex/mcp_server/tools/get_descendants_tool.rb
+- lib/rubydex/mcp_server/tools/get_file_declarations_tool.rb
+- lib/rubydex/mcp_server/tools/search_declarations_tool.rb
 - lib/rubydex/mixin.rb
 - lib/rubydex/reference.rb
 - lib/rubydex/signature.rb
@@ -72,11 +78,6 @@ files:
 - rust/about.toml
 - rust/about_templates/about.hbs
 - rust/about_templates/mingw_licenses.hbs
-- rust/rubydex-mcp/Cargo.toml
-- rust/rubydex-mcp/src/main.rs
-- rust/rubydex-mcp/src/server.rs
-- rust/rubydex-mcp/src/tools.rs
-- rust/rubydex-mcp/tests/mcp.rs
 - rust/rubydex-sys/Cargo.toml
 - rust/rubydex-sys/build.rs
 - rust/rubydex-sys/cbindgen.toml

data/exe/rubydex_mcp

@@ -1,17 +0,0 @@
-#!/usr/bin/env ruby
-# frozen_string_literal: true
-
-require "rbconfig"
-
-host_os = RbConfig::CONFIG.fetch("host_os")
-executable = host_os.match?(/mswin|mingw|cygwin/) ? "rubydex_mcp.exe" : "rubydex_mcp"
-binary = File.expand_path("../lib/rubydex/bin/#{executable}", __dir__)
-
-unless File.executable?(binary)
-  abort(<<~MESSAGE.chomp)
-    rubydex_mcp is not available at #{binary}.
-    Install a precompiled rubydex gem, or reinstall rubydex with Cargo available so the MCP executable can be built locally.
-  MESSAGE
-end
-
-exec(binary, *ARGV)

data/rust/rubydex-mcp/Cargo.toml

@@ -1,34 +0,0 @@
-[package]
-name = "rubydex-mcp"
-version = "0.2.6"
-edition = "2024"
-rust-version = "1.89.0"
-license = "MIT"
-description = "MCP server exposing Rubydex semantic Ruby code intelligence tools."
-homepage = "https://github.com/Shopify/rubydex"
-repository = "https://github.com/Shopify/rubydex"
-readme = "README.md"
-keywords = ["ruby", "mcp", "static-analysis"]
-categories = ["development-tools"]
-
-[[bin]]
-name = "rubydex_mcp"
-path = "src/main.rs"
-
-[dependencies]
-rubydex = { version = "0.2.6", path = "../rubydex" }
-clap = { version = "4.5.16", features = ["derive"] }
-rmcp = { version = "1.4", features = ["server", "macros", "transport-io", "schemars"] }
-tokio = { version = "1", features = ["macros", "rt", "io-std"] }
-serde = { version = "1", features = ["derive"] }
-serde_json = "1"
-schemars = "1"
-url = "2"
-
-[dev-dependencies]
-rubydex = { version = "0.2.6", path = "../rubydex", features = ["test_utils"] }
-assert_cmd = "2.0"
-serde_json = "1"
-
-[lints]
-workspace = true

data/rust/rubydex-mcp/src/main.rs

@@ -1,48 +0,0 @@
-use clap::Parser;
-
-mod server;
-mod tools;
-
-#[derive(Parser, Debug)]
-#[command(
-    name = "rubydex_mcp",
-    about = "Rubydex MCP server for AI-assisted Ruby code intelligence",
-    version
-)]
-struct Args {
-    #[arg(value_name = "PATH", default_value = ".")]
-    path: String,
-}
-
-fn main() {
-    let args = Args::parse();
-
-    let root = match std::fs::canonicalize(&args.path) {
-        Ok(p) => p
-            .into_os_string()
-            .into_string()
-            .expect("Project path is not valid UTF-8"),
-        Err(e) => {
-            eprintln!("Warning: failed to canonicalize '{}': {e}", args.path);
-            args.path
-        }
-    };
-
-    // Create the server and start indexing in the background.
-    let server = server::RubydexServer::new(root.clone());
-    server.spawn_indexer(root);
-
-    // Serve MCP over stdio immediately while indexing runs.
-    // We need to do this because Claude Code's default MCP server timeout is 30 seconds,
-    // And in big codebases it's possible to exceed that and Claude Code would just consider
-    // the server fail to connect.
-    let rt = tokio::runtime::Builder::new_current_thread()
-        .enable_all()
-        .build()
-        .expect("Failed to build tokio runtime");
-
-    if let Err(e) = rt.block_on(server.serve()) {
-        eprintln!("MCP server error: {e}");
-        std::process::exit(1);
-    }
-}