rubydex 0.1.0.beta12-aarch64-linux

data/rust/rubydex/src/visualization/dot.rs

@@ -0,0 +1,192 @@
+//! DOT format generator for Graphviz visualization of the graph structure.
+
+use std::fmt::Write;
+
+use crate::model::graph::Graph;
+
+const NAME_NODE_SHAPE: &str = "hexagon";
+const DEFINITION_NODE_SHAPE: &str = "ellipse";
+const URI_NODE_SHAPE: &str = "box";
+
+/// Escapes a string for use in DOT format labels and identifiers.
+fn escape_dot_string(s: &str) -> String {
+    if !s.contains('"') {
+        return s.to_string();
+    }
+
+    let mut result = String::with_capacity(s.len());
+    for c in s.chars() {
+        match c {
+            '"' => result.push_str("\\\""),
+            _ => result.push(c),
+        }
+    }
+    result
+}
+
+#[must_use]
+pub fn generate(graph: &Graph) -> String {
+    let mut output = String::new();
+    output.push_str("digraph {\n");
+    output.push_str("    rankdir=TB;\n\n");
+
+    write_declaration_nodes(&mut output, graph);
+    write_definition_nodes(&mut output, graph);
+    write_document_nodes(&mut output, graph);
+
+    output.push_str("}\n");
+    output
+}
+
+fn write_declaration_nodes(output: &mut String, graph: &Graph) {
+    let mut declarations: Vec<_> = graph.declarations().values().collect();
+    declarations.sort_by(|a, b| a.name().cmp(b.name()));
+
+    for declaration in declarations {
+        let name = declaration.name();
+        let escaped_name = escape_dot_string(name);
+        let node_id = format!("Name:{name}");
+        let _ = writeln!(
+            output,
+            "    \"{node_id}\" [label=\"{escaped_name}\",shape={NAME_NODE_SHAPE}];"
+        );
+
+        for def_id in declaration.definitions() {
+            let _ = writeln!(output, "    \"{node_id}\" -> \"def_{def_id}\" [dir=both];");
+        }
+    }
+
+    output.push('\n');
+}
+
+fn write_definition_nodes(output: &mut String, graph: &Graph) {
+    let mut definitions: Vec<_> = graph
+        .definitions()
+        .iter()
+        .filter_map(|(def_id, definition)| {
+            graph
+                .declarations()
+                .get(graph.definition_to_declaration_id(definition).unwrap())
+                .map(|declaration| {
+                    let def_type = definition.kind();
+                    let escaped_name = escape_dot_string(declaration.name());
+                    let label = format!("{def_type}({escaped_name})");
+                    let line = format!("    \"def_{def_id}\" [label=\"{label}\",shape={DEFINITION_NODE_SHAPE}];\n");
+                    (label, line)
+                })
+        })
+        .collect();
+
+    definitions.sort_by(|a, b| a.0.cmp(&b.0));
+
+    for (_, line) in definitions {
+        output.push_str(&line);
+    }
+    output.push('\n');
+}
+
+fn write_document_nodes(output: &mut String, graph: &Graph) {
+    let mut documents: Vec<_> = graph.documents().values().collect();
+    documents.sort_by(|a, b| a.uri().cmp(b.uri()));
+
+    for document in documents {
+        let uri = document.uri();
+        let label = uri.rsplit('/').next().unwrap_or(uri);
+        let escaped_uri = escape_dot_string(uri);
+        let escaped_label = escape_dot_string(label);
+        let _ = writeln!(
+            output,
+            "    \"{escaped_uri}\" [label=\"{escaped_label}\",shape={URI_NODE_SHAPE}];"
+        );
+
+        for def_id in document.definitions() {
+            let _ = writeln!(output, "    \"def_{def_id}\" -> \"{escaped_uri}\";");
+        }
+    }
+    output.push('\n');
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::{model::ids::DeclarationId, test_utils::GraphTest};
+
+    fn create_test_graph() -> GraphTest {
+        let mut graph_test = GraphTest::new();
+        graph_test.index_uri(
+            "file:///test.rb",
+            "
+                class TestClass
+                end
+
+                module TestModule
+                end
+            ",
+        );
+        graph_test.resolve();
+        graph_test
+    }
+
+    /// Finds the first definition ID for the declaration with the given name.
+    fn def_id_for(graph: &Graph, name: &str) -> String {
+        let decl = graph.declarations().get(&DeclarationId::from(name)).unwrap();
+        decl.definitions().first().unwrap().to_string()
+    }
+
+    #[test]
+    fn test_dot_generation() {
+        let context = create_test_graph();
+        let dot_output = generate(context.graph());
+
+        let basic_object_def = def_id_for(context.graph(), "BasicObject");
+        let class_def = def_id_for(context.graph(), "Class");
+        let kernel_def = def_id_for(context.graph(), "Kernel");
+        let module_def = def_id_for(context.graph(), "Module");
+        let object_def = def_id_for(context.graph(), "Object");
+        let test_class_def = def_id_for(context.graph(), "TestClass");
+        let test_module_def = def_id_for(context.graph(), "TestModule");
+
+        let expected = format!(
+            r#"digraph {{
+    rankdir=TB;
+
+    "Name:BasicObject" [label="BasicObject",shape=hexagon];
+    "Name:BasicObject" -> "def_{basic_object_def}" [dir=both];
+    "Name:Class" [label="Class",shape=hexagon];
+    "Name:Class" -> "def_{class_def}" [dir=both];
+    "Name:Kernel" [label="Kernel",shape=hexagon];
+    "Name:Kernel" -> "def_{kernel_def}" [dir=both];
+    "Name:Module" [label="Module",shape=hexagon];
+    "Name:Module" -> "def_{module_def}" [dir=both];
+    "Name:Object" [label="Object",shape=hexagon];
+    "Name:Object" -> "def_{object_def}" [dir=both];
+    "Name:TestClass" [label="TestClass",shape=hexagon];
+    "Name:TestClass" -> "def_{test_class_def}" [dir=both];
+    "Name:TestModule" [label="TestModule",shape=hexagon];
+    "Name:TestModule" -> "def_{test_module_def}" [dir=both];
+
+    "def_{basic_object_def}" [label="Class(BasicObject)",shape=ellipse];
+    "def_{class_def}" [label="Class(Class)",shape=ellipse];
+    "def_{module_def}" [label="Class(Module)",shape=ellipse];
+    "def_{object_def}" [label="Class(Object)",shape=ellipse];
+    "def_{test_class_def}" [label="Class(TestClass)",shape=ellipse];
+    "def_{kernel_def}" [label="Module(Kernel)",shape=ellipse];
+    "def_{test_module_def}" [label="Module(TestModule)",shape=ellipse];
+
+    "file:///test.rb" [label="test.rb",shape=box];
+    "def_{test_class_def}" -> "file:///test.rb";
+    "def_{test_module_def}" -> "file:///test.rb";
+    "rubydex:built-in" [label="rubydex:built-in",shape=box];
+    "def_{basic_object_def}" -> "rubydex:built-in";
+    "def_{kernel_def}" -> "rubydex:built-in";
+    "def_{object_def}" -> "rubydex:built-in";
+    "def_{module_def}" -> "rubydex:built-in";
+    "def_{class_def}" -> "rubydex:built-in";
+
+}}
+"#
+        );
+
+        assert_eq!(dot_output, expected);
+    }
+}

data/rust/rubydex/src/visualization.rs

@@ -0,0 +1,6 @@
+//! Graph visualization module for the Index structure.
+//!
+//! This module provides functionality to generate visual representations of the Index's
+//! internal graph structure, showing the relationships between Names, Definitions, and URIs.
+
+pub mod dot;

data/rust/rubydex/tests/cli.rs

@@ -0,0 +1,185 @@
+use assert_cmd::{assert::Assert, prelude::*};
+use predicates::prelude::*;
+use regex::Regex;
+use rubydex::test_utils::{normalize_indentation, with_context};
+use std::process::Command;
+
+fn rdx_cmd(args: &[&str]) -> Command {
+    let mut cmd = Command::cargo_bin("rubydex_cli").unwrap();
+    cmd.args(args);
+    cmd
+}
+
+fn rdx(args: &[&str]) -> Assert {
+    rdx_cmd(args).assert()
+}
+
+#[test]
+fn prints_help() {
+    rdx(&["--help"])
+        .success()
+        .stdout(predicate::str::contains("A Static Analysis Toolkit for Ruby"))
+        .stdout(predicate::str::contains("Usage:"))
+        .stdout(predicate::str::contains("--stats"))
+        .stdout(predicate::str::contains("--visualize"))
+        .stdout(predicate::str::contains("--stop-after"));
+}
+
+#[test]
+fn paths_argument_variants() {
+    rdx(&[])
+        .success()
+        .stderr(predicate::str::is_empty())
+        .stdout(predicate::str::contains("Indexed 1 files"));
+
+    rdx(&["."])
+        .success()
+        .stderr(predicate::str::is_empty())
+        .stdout(predicate::str::contains("Indexed 1 files"));
+
+    with_context(|context| {
+        context.write("dir1/file1.rb", "class Class1\nend\n");
+        context.write("dir1/file2.rb", "class Class2\nend\n");
+        context.write("dir2/file1.rb", "class Class3\nend\n");
+        context.write("dir2/file2.rb", "class Class4\nend\n"); // not indexed
+
+        rdx(&[
+            context.absolute_path_to("dir1").to_str().unwrap(),
+            context.absolute_path_to("dir2/file1.rb").to_str().unwrap(),
+        ])
+        .success()
+        .stderr(predicate::str::is_empty())
+        .stdout(predicate::str::contains("Indexed 4 files"));
+    });
+}
+
+#[test]
+fn prints_index_metrics() {
+    with_context(|context| {
+        context.write("file1.rb", "class FirstClass\nend\n");
+        context.write("file2.rb", "module SecondModule\nend\n");
+
+        rdx(&[context.absolute_path().to_str().unwrap()])
+            .success()
+            .stderr(predicate::str::is_empty())
+            .stdout(predicate::str::contains("Indexed 3 files"))
+            .stdout(predicate::str::contains("Found 7 names"))
+            .stdout(predicate::str::contains("Found 7 definitions"));
+    });
+}
+
+fn normalize_visualization_output(output: &str) -> String {
+    let def_re = Regex::new(r"def_-?[a-f0-9]+").unwrap();
+    let uri_re = Regex::new(r#"file://[^"]+/([^/"]+\.rb)"#).unwrap();
+
+    let normalized = def_re.replace_all(output, "def_<ID>");
+    uri_re.replace_all(&normalized, "file://<PATH>/$1").to_string()
+}
+
+#[test]
+fn visualize_simple_class() {
+    with_context(|context| {
+        context.write("simple.rb", "class SimpleClass\nend\n");
+
+        let output = rdx_cmd(&[context.absolute_path().to_str().unwrap(), "--visualize"])
+            .output()
+            .unwrap();
+
+        assert!(output.status.success());
+
+        let stdout = String::from_utf8_lossy(&output.stdout);
+        let normalized = normalize_visualization_output(&stdout);
+
+        let expected = normalize_indentation({
+            r#"
+            digraph {
+                rankdir=TB;
+
+                "Name:BasicObject" [label="BasicObject",shape=hexagon];
+                "Name:BasicObject" -> "def_<ID>" [dir=both];
+                "Name:Class" [label="Class",shape=hexagon];
+                "Name:Class" -> "def_<ID>" [dir=both];
+                "Name:Kernel" [label="Kernel",shape=hexagon];
+                "Name:Kernel" -> "def_<ID>" [dir=both];
+                "Name:Module" [label="Module",shape=hexagon];
+                "Name:Module" -> "def_<ID>" [dir=both];
+                "Name:Object" [label="Object",shape=hexagon];
+                "Name:Object" -> "def_<ID>" [dir=both];
+                "Name:SimpleClass" [label="SimpleClass",shape=hexagon];
+                "Name:SimpleClass" -> "def_<ID>" [dir=both];
+
+                "def_<ID>" [label="Class(BasicObject)",shape=ellipse];
+                "def_<ID>" [label="Class(Class)",shape=ellipse];
+                "def_<ID>" [label="Class(Module)",shape=ellipse];
+                "def_<ID>" [label="Class(Object)",shape=ellipse];
+                "def_<ID>" [label="Class(SimpleClass)",shape=ellipse];
+                "def_<ID>" [label="Module(Kernel)",shape=ellipse];
+
+                "file://<PATH>/simple.rb" [label="simple.rb",shape=box];
+                "def_<ID>" -> "file://<PATH>/simple.rb";
+                "rubydex:built-in" [label="rubydex:built-in",shape=box];
+                "def_<ID>" -> "rubydex:built-in";
+                "def_<ID>" -> "rubydex:built-in";
+                "def_<ID>" -> "rubydex:built-in";
+                "def_<ID>" -> "rubydex:built-in";
+                "def_<ID>" -> "rubydex:built-in";
+
+            }
+
+            "#
+        });
+
+        assert_eq!(normalized, expected);
+    });
+}
+
+#[test]
+fn stop_after() {
+    with_context(|context| {
+        context.write("file1.rb", "class Class1\nend\n");
+        context.write("file2.rb", "class Class2\nend\n");
+
+        rdx(&[
+            context.absolute_path().to_str().unwrap(),
+            "--stop-after",
+            "listing",
+            "--stats",
+        ])
+        .success()
+        .stdout(predicate::str::contains("Listing"))
+        .stdout(predicate::str::contains("Indexing").not())
+        .stdout(predicate::str::contains("Resolution").not())
+        .stdout(predicate::str::contains("Querying").not());
+
+        rdx(&[
+            context.absolute_path().to_str().unwrap(),
+            "--stop-after",
+            "indexing",
+            "--stats",
+        ])
+        .success()
+        .stdout(predicate::str::contains("Listing"))
+        .stdout(predicate::str::contains("Indexing"))
+        .stdout(predicate::str::contains("Resolution").not())
+        .stdout(predicate::str::contains("Querying").not());
+
+        rdx(&[
+            context.absolute_path().to_str().unwrap(),
+            "--stop-after",
+            "resolution",
+            "--stats",
+        ])
+        .success()
+        .stdout(predicate::str::contains("Listing"))
+        .stdout(predicate::str::contains("Indexing"))
+        .stdout(predicate::str::contains("Resolution"))
+        .stdout(predicate::str::contains("Querying").not());
+
+        rdx(&[context.absolute_path().to_str().unwrap(), "--stats"])
+            .success()
+            .stdout(predicate::str::contains("Listing"))
+            .stdout(predicate::str::contains("Indexing"))
+            .stdout(predicate::str::contains("Resolution"))
+            .stdout(predicate::str::contains("Querying"));
+    });
+}

data/rust/rubydex-mcp/Cargo.toml

@@ -0,0 +1,28 @@
+[package]
+name = "rubydex-mcp"
+version = "0.1.0"
+edition = "2024"
+rust-version = "1.89.0"
+license = "MIT"
+
+[[bin]]
+name = "rubydex_mcp"
+path = "src/main.rs"
+
+[dependencies]
+rubydex = { path = "../rubydex" }
+clap = { version = "4.5.16", features = ["derive"] }
+rmcp = { version = "0.15", 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 = { path = "../rubydex", features = ["test_utils"] }
+assert_cmd = "2.0"
+serde_json = "1"
+
+[lints]
+workspace = true

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

@@ -0,0 +1,48 @@
+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);
+    }
+}