Index MCP dependency paths from wrapper

Author: st0012

exe/rubydex_mcp

@@ -1,11 +1,11 @@
 #!/usr/bin/env ruby
 # frozen_string_literal: true
 
-require "rbconfig"
+$LOAD_PATH.unshift(File.expand_path("../lib", __dir__))
 
-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__)
+require "rubydex/mcp_executable"
+
+binary = Rubydex::MCPExecutable.binary_path
 
 unless File.executable?(binary)
   abort(<<~MESSAGE.chomp)
@@ -14,4 +14,13 @@ unless File.executable?(binary)
   MESSAGE
 end
 
-exec(binary, *ARGV)
+args = if Rubydex::MCPExecutable.passthrough?(ARGV)
+  ARGV
+elsif Rubydex::MCPExecutable.setup_bundler_context(ARGV.first || Dir.pwd)
+  # The wrapper only discovers paths that require Ruby/Bundler context. Rust still performs the indexing pass.
+  Rubydex::MCPExecutable.compute_index_paths(ARGV)
+else
+  ARGV.empty? ? [Dir.pwd] : ARGV
+end
+
+exec(binary, *args)

lib/rubydex/mcp_executable.rb

@@ -0,0 +1,70 @@
+# frozen_string_literal: true
+
+require "rbconfig"
+
+module Rubydex
+  # Launcher-only helpers for `exe/rubydex_mcp`.
+  #
+  # Do not require this file from `lib/rubydex.rb`. The main Ruby API owns graph construction through
+  # `Rubydex::Graph`; this file exists only so the executable wrapper can inspect Bundler before it execs the Rust MCP
+  # server. The Rust server still performs the indexing pass.
+  module MCPExecutable
+    PASSTHROUGH_ARGUMENTS = ["-h", "--help", "-V", "--version"].freeze
+
+    extend self
+
+    def executable_name
+      host_os = RbConfig::CONFIG.fetch("host_os")
+      host_os.match?(/mswin|mingw|cygwin/) ? "rubydex_mcp.exe" : "rubydex_mcp"
+    end
+
+    def binary_path
+      File.expand_path("bin/#{executable_name}", __dir__)
+    end
+
+    def passthrough?(argv)
+      argv.any? { |arg| PASSTHROUGH_ARGUMENTS.include?(arg) }
+    end
+
+    def setup_bundler_context(workspace_path)
+      root = File.expand_path(workspace_path)
+      root = File.dirname(root) if File.file?(root)
+
+      gemfile = File.join(root, "Gemfile")
+      ENV["BUNDLE_GEMFILE"] ||= gemfile if File.file?(gemfile)
+
+      require "bundler/setup"
+      require "bundler"
+
+      true
+    rescue LoadError => e
+      warn("Warning: failed to load Bundler context: #{e.message}")
+      false
+    rescue Bundler::BundlerError => e
+      warn("Warning: failed to load Bundler context: #{e.message}")
+      false
+    end
+
+    def compute_index_paths(argv)
+      paths = argv.empty? ? [Dir.pwd] : argv
+      paths = paths.map { |path| File.expand_path(path) }
+
+      paths.concat(dependency_index_paths)
+      paths.uniq
+    end
+
+    def dependency_index_paths
+      Bundler.load.specs.flat_map do |spec|
+        spec.require_paths.filter_map do |path|
+          next if File.absolute_path?(path)
+
+          full_path = File.join(spec.full_gem_path, path)
+          full_path if File.directory?(full_path)
+        end
+      end.uniq
+    rescue Bundler::BundlerError => e
+      warn("Warning: failed to collect Bundler dependency paths: #{e.message}")
+      []
+    end
+  end
+end

rust/rubydex-mcp/src/main.rs

@@ -10,27 +10,24 @@ mod tools;
     version
 )]
 struct Args {
-    #[arg(value_name = "PATH", default_value = ".")]
-    path: String,
+    #[arg(value_name = "PATH")]
+    paths: Vec<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
-        }
+    let paths = if args.paths.is_empty() {
+        vec![".".to_string()]
+    } else {
+        args.paths
     };
 
+    let paths: Vec<String> = paths.into_iter().map(canonicalize_path).collect();
+    let root = paths.first().expect("expected at least one path").clone();
+
     // Create the server and start indexing in the background.
     let server = server::RubydexServer::new(root.clone());
-    server.spawn_indexer(root);
+    server.spawn_indexer(paths);
 
     // Serve MCP over stdio immediately while indexing runs.
     // We need to do this because Claude Code's default MCP server timeout is 30 seconds,
@@ -46,3 +43,16 @@ fn main() {
         std::process::exit(1);
     }
 }
+
+fn canonicalize_path(path: String) -> String {
+    match std::fs::canonicalize(&path) {
+        Ok(p) => p
+            .into_os_string()
+            .into_string()
+            .expect("Project path is not valid UTF-8"),
+        Err(e) => {
+            eprintln!("Warning: failed to canonicalize '{path}': {e}");
+            path
+        }
+    }
+}

rust/rubydex-mcp/src/server.rs

@@ -44,11 +44,11 @@ impl RubydexServer {
     }
 
     /// Spawns a background thread that indexes the codebase and marks the server as ready.
-    pub fn spawn_indexer(&self, path: String) {
+    pub fn spawn_indexer(&self, paths: Vec<String>) {
         let state = Arc::clone(&self.state);
         std::thread::spawn(move || {
             let result = std::panic::catch_unwind(std::panic::AssertUnwindSafe(|| {
-                let (file_paths, errors) = rubydex::listing::collect_file_paths(vec![path], &HashSet::new());
+                let (file_paths, errors) = rubydex::listing::collect_file_paths(paths, &HashSet::new());
                 for error in &errors {
                     eprintln!("Listing error: {error}");
                 }

rust/rubydex-mcp/tests/mcp.rs

@@ -300,3 +300,46 @@ fn mcp_server_e2e() {
         let _ = child.wait().unwrap();
     });
 }
+
+#[test]
+fn mcp_server_indexes_multiple_roots() {
+    with_context(|context| {
+        context.write("workspace/app.rb", "class WorkspaceThing; end");
+        context.write("dependency/lib/dependency_thing.rb", "class DependencyThing; end");
+
+        let mut child = Command::cargo_bin("rubydex_mcp")
+            .unwrap()
+            .args([
+                context.absolute_path_to("workspace").to_str().unwrap(),
+                context.absolute_path_to("dependency/lib").to_str().unwrap(),
+            ])
+            .stdin(Stdio::piped())
+            .stdout(Stdio::piped())
+            .stderr(Stdio::piped())
+            .spawn()
+            .unwrap();
+
+        let mut stdin = child.stdin.take().unwrap();
+        let stdout = child.stdout.take().unwrap();
+        let mut reader = BufReader::new(stdout);
+
+        initialize_session(&mut stdin, &mut reader);
+
+        let mut request_id = 3;
+        wait_for_indexing_to_complete(&mut stdin, &mut reader, &mut request_id);
+
+        let search_response = call_next_tool(
+            &mut stdin,
+            &mut reader,
+            &mut request_id,
+            "search_declarations",
+            &json!({ "query": "DependencyThing" }),
+        );
+        let results = search_response["results"].as_array().unwrap();
+        let result_names = names_from_entries(results);
+        assert_has_name(&result_names, "DependencyThing", "search results");
+
+        drop(stdin);
+        let _ = child.wait().unwrap();
+    });
+}

test/mcp_executable_test.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+require_relative "test_helper"
+
+require "rubydex/mcp_executable"
+
+class MCPExecutableTest < Minitest::Test
+  def test_compute_index_paths_include_bundler_dependency_require_paths
+    Rubydex::MCPExecutable.setup_bundler_context(Dir.pwd)
+
+    paths = Rubydex::MCPExecutable.compute_index_paths([Dir.pwd])
+    spec = Bundler.load.specs.find { |loaded_spec| loaded_spec.name == "rake" }
+    expected_path = File.join(spec.full_gem_path, "lib")
+
+    assert_includes(paths, Dir.pwd)
+    assert_includes(paths, expected_path)
+  end
+end