refactor: extract constants and improve code quality (#20)

Author: bug-ops

crates/deps-core/src/cache.rs

@@ -7,6 +7,12 @@ use std::time::Instant;
 /// Maximum number of cached entries to prevent unbounded memory growth.
 const MAX_CACHE_ENTRIES: usize = 1000;
 
+/// HTTP request timeout in seconds.
+const HTTP_TIMEOUT_SECS: u64 = 30;
+
+/// Percentage of cache entries to evict when capacity is reached.
+const CACHE_EVICTION_PERCENTAGE: usize = 10;
+
 /// Validates that a URL uses HTTPS protocol.
 ///
 /// Returns an error if the URL doesn't start with "https://".
@@ -96,12 +102,12 @@ pub struct HttpCache {
 impl HttpCache {
     /// Creates a new HTTP cache with default configuration.
     ///
-    /// The cache uses a 30-second timeout for all requests and identifies
-    /// itself with a `deps-lsp/0.1.0` user agent.
+    /// The cache uses a configurable timeout for all requests and identifies
+    /// itself with an auto-versioned user agent.
     pub fn new() -> Self {
         let client = Client::builder()
-            .user_agent("deps-lsp/0.1.0")
-            .timeout(std::time::Duration::from_secs(30))
+            .user_agent(format!("deps-lsp/{}", env!("CARGO_PKG_VERSION")))
+            .timeout(std::time::Duration::from_secs(HTTP_TIMEOUT_SECS))
             .build()
             .expect("failed to create HTTP client");
 
@@ -330,12 +336,12 @@ impl HttpCache {
         self.entries.is_empty()
     }
 
-    /// Evicts approximately 10% of cache entries when capacity is reached.
+    /// Evicts approximately `CACHE_EVICTION_PERCENTAGE`% of cache entries when capacity is reached.
     ///
     /// Uses a simple random eviction strategy. In a production system,
     /// this could be replaced with LRU or TTL-based eviction.
     fn evict_entries(&self) {
-        let target_removals = MAX_CACHE_ENTRIES / 10;
+        let target_removals = MAX_CACHE_ENTRIES / CACHE_EVICTION_PERCENTAGE;
         let mut removed = 0;
 
         // Simple eviction: remove oldest entries by fetched_at timestamp

crates/deps-core/src/handler.rs

@@ -14,6 +14,15 @@ use tower_lsp::lsp_types::{
     InlayHint, InlayHintKind, InlayHintLabel, InlayHintLabelPart, MarkupContent, MarkupKind, Range,
 };
 
+/// Maximum number of versions to display in hover tooltips.
+const MAX_VERSIONS_IN_HOVER: usize = 8;
+
+/// Maximum number of features to display in hover tooltips.
+const MAX_FEATURES_IN_HOVER: usize = 10;
+
+/// Maximum number of versions to offer in code action suggestions.
+const MAX_CODE_ACTION_VERSIONS: usize = 5;
+
 /// Generic handler for LSP operations across ecosystems.
 ///
 /// This trait uses Generic Associated Types (GATs) to provide
@@ -431,26 +440,32 @@ where
     }
 
     markdown.push_str("**Versions** *(use Cmd+. to update)*:\n");
-    for (i, version) in versions.iter().take(8).enumerate() {
+    for (i, version) in versions.iter().take(MAX_VERSIONS_IN_HOVER).enumerate() {
         if i == 0 {
             markdown.push_str(&format!("- {} *(latest)*\n", version.version_string()));
         } else {
             markdown.push_str(&format!("- {}\n", version.version_string()));
         }
     }
-    if versions.len() > 8 {
-        markdown.push_str(&format!("- *...and {} more*\n", versions.len() - 8));
+    if versions.len() > MAX_VERSIONS_IN_HOVER {
+        markdown.push_str(&format!(
+            "- *...and {} more*\n",
+            versions.len() - MAX_VERSIONS_IN_HOVER
+        ));
     }
 
     // Features (if supported by ecosystem)
     let features = latest.features();
     if !features.is_empty() {
         markdown.push_str("\n**Features**:\n");
-        for feature in features.iter().take(10) {
+        for feature in features.iter().take(MAX_FEATURES_IN_HOVER) {
             markdown.push_str(&format!("- `{}`\n", feature));
         }
-        if features.len() > 10 {
-            markdown.push_str(&format!("- *...and {} more*\n", features.len() - 10));
+        if features.len() > MAX_FEATURES_IN_HOVER {
+            markdown.push_str(&format!(
+                "- *...and {} more*\n",
+                features.len() - MAX_FEATURES_IN_HOVER
+            ));
         }
     }
 
@@ -562,11 +577,11 @@ where
             continue;
         };
 
-        // Offer up to 5 non-deprecated versions
+        // Offer up to MAX_CODE_ACTION_VERSIONS non-deprecated versions
         for (i, version) in versions
             .iter()
             .filter(|v| !H::is_deprecated(v))
-            .take(5)
+            .take(MAX_CODE_ACTION_VERSIONS)
             .enumerate()
         {
             let new_text = H::format_version_for_edit(dep, version.version_string());

crates/deps-lsp/src/server.rs

@@ -18,6 +18,12 @@ use tower_lsp::lsp_types::{
 };
 use tower_lsp::{Client, LanguageServer, jsonrpc::Result};
 
+/// LSP command identifiers.
+mod commands {
+    /// Command to update a dependency version.
+    pub const UPDATE_VERSION: &str = "deps-lsp.updateVersion";
+}
+
 pub struct Backend {
     client: Client,
     state: Arc<ServerState>,
@@ -191,7 +197,7 @@ impl Backend {
                 ..Default::default()
             })),
             execute_command_provider: Some(ExecuteCommandOptions {
-                commands: vec!["deps-lsp.updateVersion".into()],
+                commands: vec![commands::UPDATE_VERSION.into()],
                 ..Default::default()
             }),
             ..Default::default()
@@ -341,7 +347,7 @@ impl LanguageServer for Backend {
     ) -> Result<Option<serde_json::Value>> {
         tracing::info!("execute_command: {:?}", params.command);
 
-        if params.command == "deps-lsp.updateVersion"
+        if params.command == commands::UPDATE_VERSION
             && let Some(args) = params.arguments.first()
             && let Ok(update_args) = serde_json::from_value::<UpdateVersionArgs>(args.clone())
         {