added version tool

Author: elasticdotventures

.gitignore

@@ -24,3 +24,4 @@ Thumbs.db
 *.swo
 output_tests
 target/*
+context_portal/*

README.md

@@ -11,9 +11,10 @@ This is an MCP (Model Context Protocol) server that provides tools for Rust crat
 ## Installation
 
 ```bash
-git clone https://github.com/d6e/cratedocs-mcp.git
+git clone https://github.com/promptexecution/cratedocs-mcp.git
 cd cratedocs-mcp
 cargo build --release
+cargo install --path .
 ```
 
 ## Running the Server

src/bin/cratedocs.rs

@@ -22,6 +22,8 @@ struct Cli {
 
 #[derive(Subcommand)]
 enum Commands {
+    /// Output the version and exit
+    Version,
     /// Run the server in stdin/stdout mode
     Stdio {
         /// Enable debug logging
@@ -103,6 +105,10 @@ async fn main() -> Result<()> {
     let cli = Cli::parse();
 
     match cli.command {
+        Commands::Version => {
+            println!("{}", env!("CARGO_PKG_VERSION"));
+            Ok(())
+        },
         Commands::Stdio { debug } => run_stdio_server(debug).await,
         Commands::Http { address, debug } => run_http_server(address, debug).await,
         Commands::Test {

src/tools/docs/tests.rs

@@ -75,8 +75,8 @@ async fn test_list_tools() {
     let router = DocRouter::new();
     let tools = router.list_tools();
 
-    // Should have exactly 3 tools
-    assert_eq!(tools.len(), 3);
+    // Should have exactly 4 tools (lookup_crate, search_crates, lookup_item, list_crate_items)
+    assert_eq!(tools.len(), 4);
 
     // Check tool names
     let tool_names: Vec<String> = tools.iter().map(|t| t.name.clone()).collect();

src/tools/item_list.rs

@@ -0,0 +1,77 @@
+use anyhow::Result;
+
+/// Represents filters for item listing.
+#[derive(Debug)]
+pub struct ItemListFilters {
+    pub item_type: Option<String>,
+    pub visibility: Option<String>,
+    pub module: Option<String>,
+}
+
+/// Stub for the crate item enumeration tool.
+/// This will use rust-analyzer to enumerate items in a crate.
+pub async fn list_crate_items(
+    crate_name: &str,
+    version: &str,
+    filters: Option<ItemListFilters>,
+) -> Result<String> {
+    // 🦨 skunky: Implementation pending. Will use rust-analyzer APIs.
+    Ok(format!(
+        "Stub: list_crate_items for crate: {}, version: {}, filters: {:?}",
+        crate_name, version, filters
+    ))
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use tokio;
+
+    #[tokio::test]
+    async fn test_basic_call_returns_stub() {
+        let result = list_crate_items("serde", "1.0.0", None).await.unwrap();
+        assert!(result.contains("Stub: list_crate_items for crate: serde, version: 1.0.0"), "Stub output missing expected text");
+    }
+
+    #[tokio::test]
+    async fn test_with_item_type_filter() {
+        let filters = ItemListFilters {
+            item_type: Some("struct".to_string()),
+            visibility: None,
+            module: None,
+        };
+        let result = list_crate_items("serde", "1.0.0", Some(filters)).await.unwrap();
+        assert!(result.contains("filters: Some"), "Stub output missing filters");
+        assert!(result.contains("struct"), "Stub output missing item_type");
+    }
+
+    #[tokio::test]
+    async fn test_with_visibility_filter() {
+        let filters = ItemListFilters {
+            item_type: None,
+            visibility: Some("pub".to_string()),
+            module: None,
+        };
+        let result = list_crate_items("serde", "1.0.0", Some(filters)).await.unwrap();
+        assert!(result.contains("filters: Some"), "Stub output missing filters");
+        assert!(result.contains("pub"), "Stub output missing visibility");
+    }
+
+    #[tokio::test]
+    async fn test_with_module_filter() {
+        let filters = ItemListFilters {
+            item_type: None,
+            visibility: None,
+            module: Some("serde::de".to_string()),
+        };
+        let result = list_crate_items("serde", "1.0.0", Some(filters)).await.unwrap();
+        assert!(result.contains("filters: Some"), "Stub output missing filters");
+        assert!(result.contains("serde::de"), "Stub output missing module filter");
+    }
+
+    #[tokio::test]
+    async fn test_invalid_crate_name() {
+        let result = list_crate_items("not_a_real_crate", "0.0.1", None).await.unwrap();
+        assert!(result.contains("not_a_real_crate"), "Stub output missing invalid crate name");
+    }
+}

tests/integration_tests.rs

@@ -13,7 +13,7 @@ async fn test_doc_router_initialization() {
 
     // Tools should be available and correctly configured
     let tools = router.list_tools();
-    assert_eq!(tools.len(), 3);
+    assert_eq!(tools.len(), 4);
 
     // Check specific tool schemas
     let lookup_crate_tool = tools.iter().find(|t| t.name == "lookup_crate").unwrap();
@@ -68,8 +68,8 @@ async fn test_end_to_end_crate_lookup() {
     // The response should be HTML from docs.rs
     match &content[0] {
         mcp_core::Content::Text(text) => {
-            assert!(text.text.contains("<!DOCTYPE html>"));
-            assert!(text.text.contains("serde"));
+            // Output is now markdown, not HTML
+            assert!(text.text.to_lowercase().contains("serde"));
         },
         _ => panic!("Expected text content"),
     }