refactor: env to args

Author: rrrodzilla

Cargo.lock

@@ -19,3 +19,6 @@ futures = "0.3"
 bincode = { version = "2.0.1", features = ["serde"] } # Enable serde integration
 tiktoken-rs = "0.6.0"
 cargo = "0.86.0"
+tempfile = "3.19.1"
+xdg = { version = "2.5.2", features = ["serde"] }
+anyhow = "1.0.97"

Cargo.toml

@@ -56,7 +56,7 @@
             rustVersion = "stable";
             # Example configuration:
             # withTools = [ ];  # Will be prefixed with cargo-
-            # extraPackages = [ ];
+            extraPackages = [ pkgs.openssl.dev pkgs.pkg-config ]; # Add openssl dev libs and pkg-config
             # ide.type = "none";
           };
 

flake.nix

@@ -1,6 +1,15 @@
 use scraper::{Html, Selector};
 use std::fs;
-use std::path::Path;
+use cargo::core::resolver::features::CliFeatures;
+// use cargo::core::SourceId; // Removed unused import
+// use cargo::util::Filesystem; // Removed unused import
+
+use cargo::core::Workspace;
+use cargo::ops::{self, CompileOptions, DocOptions, Packages};
+use cargo::util::context::GlobalContext;
+use anyhow::Error as AnyhowError;
+// use std::process::Command; // Remove Command again
+use tempfile::tempdir;
 use thiserror::Error;
 use walkdir::WalkDir;
 
@@ -10,10 +19,12 @@ pub enum DocLoaderError {
     Io(#[from] std::io::Error),
     #[error("WalkDir Error: {0}")]
     WalkDir(#[from] walkdir::Error),
-    // #[error("Failed to parse HTML for file: {0}")] // Commented out unused variant
-    // HtmlParsing(String), // Commented out unused variant
     #[error("CSS selector error: {0}")]
-    Selector(String), // Using String as SelectorErrorKind is not easily clonable/convertible
+    Selector(String),
+    #[error("Temporary directory creation failed: {0}")]
+    TempDirCreationFailed(std::io::Error),
+    #[error("Cargo library error: {0}")]
+    CargoLib(#[from] AnyhowError), // Re-add CargoLib variant
 }
 
 // Simple struct to hold document content, maybe add path later if needed
@@ -23,11 +34,60 @@ pub struct Document {
     pub content: String,
 }
 
-/// Loads and parses HTML documents from a given directory path.
+/// Generates documentation for a given crate in a temporary directory,
+/// then loads and parses the HTML documents.
 /// Extracts text content from the main content area of rustdoc generated HTML.
-pub fn load_documents(docs_path: &str) -> Result<Vec<Document>, DocLoaderError> {
+pub fn load_documents(crate_name: &str, _crate_version: &str) -> Result<Vec<Document>, DocLoaderError> { // Mark version as unused for now
     let mut documents = Vec::new();
-    let docs_path = Path::new(docs_path);
+
+    let temp_dir = tempdir().map_err(DocLoaderError::TempDirCreationFailed)?;
+    let temp_dir_path = temp_dir.path();
+
+    println!(
+        "Generating documentation for crate '{}' in temporary directory: {}",
+        crate_name,
+        temp_dir_path.display()
+    );
+
+    // Execute `cargo doc` using std::process::Command
+    // --- Use Cargo API ---
+    let config = GlobalContext::default()?;
+    // config.shell().set_verbosity(Verbosity::Quiet); // Keep commented
+
+    let current_dir = std::env::current_dir()?;
+    let mut ws = Workspace::new(&current_dir.join("Cargo.toml"), &config)?; // Make ws mutable
+    // Set target_dir directly on Workspace
+    ws.set_target_dir(cargo::util::Filesystem::new(temp_dir_path.to_path_buf()));
+
+    // Create CompileOptions, relying on ::new for BuildConfig
+    let mut compile_opts = CompileOptions::new(&config, cargo::core::compiler::CompileMode::Doc { deps: false, json: false })?;
+    // Specify the package explicitly
+    let package_spec = crate_name.replace('-', "_"); // Just use name (with underscores)
+    compile_opts.cli_features = CliFeatures::new_all(false); // Use new_all(false)
+    compile_opts.spec = Packages::Packages(vec![package_spec]);
+
+    // Create DocOptions: Pass compile options
+    let doc_opts = DocOptions {
+        compile_opts,
+        open_result: false, // Don't open in browser
+        output_format: ops::OutputFormat::Html,
+    };
+
+    ops::doc(&ws, &doc_opts).map_err(DocLoaderError::CargoLib)?; // Use ws
+    // --- End Cargo API ---
+    // Construct the path to the generated documentation within the temp directory
+    // Cargo uses underscores in the directory path if the crate name has hyphens
+    let crate_name_underscores = crate_name.replace('-', "_");
+    let docs_path = temp_dir_path.join("doc").join(&crate_name_underscores);
+
+    if !docs_path.exists() || !docs_path.is_dir() {
+         return Err(DocLoaderError::CargoLib(anyhow::anyhow!(
+             "Generated documentation not found at expected path: {}. Check crate name and cargo doc output.",
+             docs_path.display()
+         )));
+    }
+    println!("Generated documentation path: {}", docs_path.display());
+
 
     // Define the CSS selector for the main content area in rustdoc HTML
     // This might need adjustment based on the exact rustdoc version/theme
@@ -39,7 +99,7 @@ pub fn load_documents(docs_path: &str) -> Result<Vec<Document>, DocLoaderError>
     for entry in WalkDir::new(docs_path)
         .into_iter()
         .filter_map(Result::ok) // Ignore errors during iteration for now
-        .filter(|e| !e.file_type().is_dir() && e.path().extension().map_or(false, |ext| ext == "html"))
+        .filter(|e| !e.file_type().is_dir() && e.path().extension().is_some_and(|ext| ext == "html"))
     {
         let path = entry.path();
         let path_str = path.to_string_lossy().to_string();

src/doc_loader.rs

@@ -6,6 +6,8 @@ use crate::doc_loader::DocLoaderError; // Need to import DocLoaderError from the
 pub enum ServerError {
     #[error("Environment variable not set: {0}")]
     MissingEnvVar(String),
+    #[error("Missing command line argument: {0}")]
+    MissingArgument(String),
     #[error("MCP Service Error: {0}")]
     Mcp(#[from] ServiceError), // Use ServiceError
     #[error("IO Error: {0}")]
@@ -18,4 +20,6 @@ pub enum ServerError {
     Json(#[from] serde_json::Error), // Add error for JSON deserialization
     #[error("Tiktoken Error: {0}")]
     Tiktoken(String),
+    #[error("XDG Directory Error: {0}")]
+    Xdg(String),
 }

src/error.rs

@@ -27,6 +27,7 @@ use ndarray::Array1;
 use std::fs::{self, File};
 use std::io::BufReader; // Removed unused BufWriter
 use std::path::PathBuf; // Removed unused Path
+use xdg::BaseDirectories;
 use bincode::{
     config,
     // serde::OwnedSerdeDecoder, // No longer needed
@@ -40,17 +41,23 @@ async fn main() -> Result<(), ServerError> {
     // Load .env file if present
     dotenvy::dotenv().ok();
 
-    // Get required environment variables
-    let crate_name =
-        env::var("CRATE_NAME").map_err(|_| ServerError::MissingEnvVar("CRATE_NAME".to_string()))?;
-    let docs_path =
-        env::var("DOCS_PATH").map_err(|_| ServerError::MissingEnvVar("DOCS_PATH".to_string()))?;
+    // Get crate name and version from command line arguments
+    let mut args = env::args().skip(1); // Skip program name
+    let crate_name = args.next().ok_or_else(|| {
+        eprintln!("Usage: rustdocs_mcp_server <CRATE_NAME> <CRATE_VERSION>");
+        ServerError::MissingArgument("CRATE_NAME".to_string())
+    })?;
+    let crate_version = args.next().ok_or_else(|| {
+        eprintln!("Usage: rustdocs_mcp_server <CRATE_NAME> <CRATE_VERSION>");
+        ServerError::MissingArgument("CRATE_VERSION".to_string())
+    })?;
+
     let _openai_api_key = env::var("OPENAI_API_KEY")
         .map_err(|_| ServerError::MissingEnvVar("OPENAI_API_KEY".to_string()))?; // Needed later
 
-    // Load documents
-    println!("Loading documents from: {}", docs_path);
-    let documents = load_documents(&docs_path)?;
+    // Load documents by generating them dynamically
+    println!("Loading documents for crate: {}", crate_name);
+    let documents = load_documents(&crate_name, &crate_version)?; // Pass crate_name and crate_version
     println!("Loaded {} documents.", documents.len());
 
     // Initialize OpenAI client and set it in the OnceLock
@@ -60,8 +67,16 @@ async fn main() -> Result<(), ServerError> {
         .expect("Failed to set OpenAI client");
 
     // --- Persistence Logic ---
-    let persist_dir = PathBuf::from("storage").join(&crate_name);
-    let embeddings_file_path = persist_dir.join("embeddings.bin");
+    // Use XDG Base Directory specification for data storage
+    let xdg_dirs = BaseDirectories::with_prefix("rustdocs-mcp-server")
+        .map_err(|e| ServerError::Xdg(format!("Failed to get XDG directories: {}", e)))?; // Use the new Xdg variant
+
+    // Construct the path within the XDG data directory, including the crate name
+    let relative_path = PathBuf::from(&crate_name).join("embeddings.bin");
+
+    // Use place_data_file to get the full path and ensure parent directories exist
+    let embeddings_file_path = xdg_dirs.place_data_file(relative_path)
+        .map_err(ServerError::Io)?; // Map IO error if directory creation fails
 
     let embeddings = if embeddings_file_path.exists() {
         println!("Loading embeddings from: {:?}", embeddings_file_path);
@@ -105,9 +120,7 @@ async fn main() -> Result<(), ServerError> {
     let embeddings = match embeddings {
         Some(e) => e,
         None => {
-            // Ensure persist directory exists
-            fs::create_dir_all(&persist_dir)
-                .map_err(|e| ServerError::Io(e))?; // Map IO error
+            // Directory creation is handled by xdg_dirs.place_data_file
 
             // Generate embeddings
             println!("Generating embeddings...");