fix(lsp): filter inlay hints by requested range, improve error messages

Filter inlay hints by the range requested by the editor to fix
partial hint rendering in Zed. Show actionable GITHUB_TOKEN error
when GitHub API rate limit is hit without authentication.

Author: bug-ops

README.md

@@ -260,6 +260,19 @@ export GITHUB_TOKEN=$(gh auth token)
 export GITHUB_TOKEN=ghp_...
 ```
 
+For **Zed**, launch with the token so the LSP process inherits it:
+
+```bash
+# bash / zsh
+alias zed='GITHUB_TOKEN="$(gh auth token)" command zed'
+
+# fish
+alias zed='env GITHUB_TOKEN=(gh auth token) command zed'
+```
+
+> [!TIP]
+> Add the alias to your shell profile (`~/.zshrc`, `~/.bashrc`, `~/.config/fish/config.fish`) for persistence.
+
 ## Development
 
 > [!IMPORTANT]

crates/deps-lsp/src/document/lifecycle.rs

@@ -62,6 +62,8 @@ struct FetchResult {
     versions: HashMap<String, String>,
     /// Number of packages that failed to fetch (timeout or error)
     failed_count: usize,
+    /// First actionable error message (shown to user via `window/showMessage`)
+    first_error: Option<String>,
 }
 
 /// Fetches latest versions for multiple packages in parallel with progress reporting.
@@ -104,13 +106,15 @@ async fn fetch_latest_versions_parallel(
 
     let fetched = Arc::new(std::sync::atomic::AtomicUsize::new(0));
     let failed = Arc::new(std::sync::atomic::AtomicUsize::new(0));
+    let first_error: Arc<std::sync::Mutex<Option<String>>> = Arc::new(std::sync::Mutex::new(None));
     let timeout = Duration::from_secs(timeout_secs);
 
     let results: Vec<_> = stream::iter(package_names)
         .map(|name| {
             let registry = Arc::clone(&registry);
             let fetched = Arc::clone(&fetched);
             let failed = Arc::clone(&failed);
+            let first_error = Arc::clone(&first_error);
             let progress_sender = progress_sender.clone();
             async move {
                 let result =
@@ -128,6 +132,10 @@ async fn fetch_latest_versions_parallel(
                     Ok(Err(e)) => {
                         tracing::warn!(package = %name, error = %e, "fetch failed");
                         failed.fetch_add(1, std::sync::atomic::Ordering::Relaxed);
+                        let mut fe = first_error.lock().unwrap_or_else(|p| p.into_inner());
+                        if fe.is_none() {
+                            *fe = Some(e.to_string());
+                        }
                         None
                     }
                     Err(_) => {
@@ -152,6 +160,7 @@ async fn fetch_latest_versions_parallel(
     FetchResult {
         versions: results.into_iter().flatten().collect(),
         failed_count: failed.load(std::sync::atomic::Ordering::Relaxed),
+        first_error: first_error.lock().unwrap_or_else(|p| p.into_inner()).take(),
     }
 }
 
@@ -298,14 +307,16 @@ pub async fn handle_document_open(
 
         // Notify user about failed packages
         if fetch_result.failed_count > 0 {
-            client_clone
-                .show_message(
-                    tower_lsp_server::ls_types::MessageType::WARNING,
-                    format!(
-                        "deps-lsp: {} package(s) failed to fetch (timeout or network error)",
-                        fetch_result.failed_count
-                    ),
+            let message = if let Some(err) = &fetch_result.first_error {
+                format!("deps-lsp: {err}")
+            } else {
+                format!(
+                    "deps-lsp: {} package(s) failed to fetch (timeout or network error)",
+                    fetch_result.failed_count
                 )
+            };
+            client_clone
+                .show_message(MessageType::WARNING, message)
                 .await;
         }
 
@@ -505,14 +516,16 @@ pub async fn handle_document_change(
 
         // Notify user about failed packages
         if fetch_result.failed_count > 0 {
-            client_clone
-                .show_message(
-                    tower_lsp_server::ls_types::MessageType::WARNING,
-                    format!(
-                        "deps-lsp: {} package(s) failed to fetch (timeout or network error)",
-                        fetch_result.failed_count
-                    ),
+            let message = if let Some(err) = &fetch_result.first_error {
+                format!("deps-lsp: {err}")
+            } else {
+                format!(
+                    "deps-lsp: {} package(s) failed to fetch (timeout or network error)",
+                    fetch_result.failed_count
                 )
+            };
+            client_clone
+                .show_message(MessageType::WARNING, message)
                 .await;
         }
 

crates/deps-lsp/src/server.rs

@@ -378,17 +378,21 @@ impl LanguageServer for Backend {
     async fn inlay_hint(&self, params: InlayHintParams) -> Result<Option<Vec<InlayHint>>> {
         // Clone config before async call to release lock early
         let inlay_config = { self.config.read().await.inlay_hints.clone() };
+        let range = params.range;
 
-        Ok(Some(
-            inlay_hints::handle_inlay_hints(
-                Arc::clone(&self.state),
-                params,
-                &inlay_config,
-                self.client.clone(),
-                Arc::clone(&self.config),
-            )
-            .await,
-        ))
+        let hints: Vec<_> = inlay_hints::handle_inlay_hints(
+            Arc::clone(&self.state),
+            params,
+            &inlay_config,
+            self.client.clone(),
+            Arc::clone(&self.config),
+        )
+        .await
+        .into_iter()
+        .filter(|h| h.position.line >= range.start.line && h.position.line <= range.end.line)
+        .collect();
+
+        Ok(Some(hints))
     }
 
     async fn code_action(

crates/deps-swift/src/registry.rs

@@ -43,6 +43,7 @@ impl std::error::Error for InvalidOwnerRepo {}
 pub struct SwiftRegistry {
     cache: Arc<HttpCache>,
     auth_headers: Vec<(reqwest::header::HeaderName, String)>,
+    has_token: bool,
 }
 
 impl SwiftRegistry {
@@ -51,8 +52,9 @@ impl SwiftRegistry {
     /// Reads `GITHUB_TOKEN` from environment for authenticated requests
     /// (5000 req/h vs 60 req/h unauthenticated).
     pub fn new(cache: Arc<HttpCache>) -> Self {
-        let auth_headers = std::env::var("GITHUB_TOKEN")
-            .ok()
+        let token = std::env::var("GITHUB_TOKEN").ok().filter(|t| !t.is_empty());
+        let has_token = token.is_some();
+        let auth_headers = token
             .map(|token| {
                 tracing::info!("GITHUB_TOKEN detected, using authenticated GitHub API requests");
                 vec![(reqwest::header::AUTHORIZATION, format!("Bearer {token}"))]
@@ -62,6 +64,7 @@ impl SwiftRegistry {
         Self {
             cache,
             auth_headers,
+            has_token,
         }
     }
 
@@ -81,7 +84,17 @@ impl SwiftRegistry {
         let data = self
             .cache
             .get_cached_with_headers(&url, &self.headers())
-            .await?;
+            .await
+            .map_err(|e| {
+                if !self.has_token && e.to_string().contains("HTTP 403") {
+                    SwiftError::GitHubApiError {
+                        status: 403,
+                        message: "GitHub API rate limit exceeded. Set GITHUB_TOKEN to increase the limit (5000 req/h). Run: export GITHUB_TOKEN=$(gh auth token)".into(),
+                    }.into()
+                } else {
+                    e
+                }
+            })?;
         parse_tags_response(&data)
     }