Merge pull request gi-dellav#223 from wowi42/feat/lsp

feat: LSP integration with diagnostics feedback to the agent

Author: gi-dellav

Cargo.lock

@@ -32,6 +32,7 @@ multimodal = ["rig/image"]
 pdf = ["multimodal", "rig/pdf"]   
 advisor = []
 hooks = []
+lsp = ["dep:lsp-types"]
 
 [dependencies]
 rig = { version = "0.40", features = ["rmcp"] }
@@ -73,6 +74,7 @@ include_dir = "0.7"
 http = "1"
 agent-client-protocol = { version = "1.0.1", optional = true }
 blocking = { version = "1", optional = true }
+lsp-types = { version = "0.97", optional = true }
 mimalloc = { version = "0.1", default-features = false }
 
 [dev-dependencies]

Cargo.toml

@@ -1088,6 +1088,62 @@ The `/advisor` slash command provides runtime control:
 /advisor context-limit <n>  Set max kilobytes of conversation context
 ```
 
+## LSP
+
+zerostack can run language servers for the files the agent edits and feed
+diagnostics (errors/warnings) back into `edit`/`write` tool results — the
+agent sees type errors immediately instead of discovering them on the next
+build. An `lsp_diagnostics` tool also lets the agent query one file or the
+whole project on demand.
+
+This integration is behind the non-default `lsp` Cargo feature — build with
+`--features lsp` to enable it.
+
+### TOML
+
+```toml
+[lsp]
+enabled = true
+
+[lsp.servers.rust]          # override a built-in default
+command = "rust-analyzer"
+extensions = [".rs"]
+
+[lsp.servers.myserver]      # fully custom server
+command = "my-ls"
+args = ["--stdio"]
+extensions = [".my"]
+# env = { RUST_LOG = "debug" }
+# initialization = { ... }   # server-specific initializationOptions
+# disabled = false           # true removes a same-named built-in
+```
+
+### YAML
+
+```yaml
+lsp:
+  enabled: true
+  servers:
+    rust:
+      command: rust-analyzer
+      extensions: [".rs"]
+```
+
+Built-in server defaults (used only when the binary is on PATH):
+rust-analyzer, gopls, typescript-language-server, pyright-langserver,
+clangd, bash-language-server, lua-language-server.
+
+Behavior notes:
+
+- Servers are **PATH binaries only** — zerostack never auto-installs a
+  language server. A missing binary is skipped with a debug log.
+- Servers start lazily on the first edit touching one of their extensions
+  (workspace root = session cwd) and stop when zerostack exits.
+- Everything is fail-open: a hung or crashed server only means "no
+  diagnostics", never a failed edit.
+- Post-edit diagnostics are capped (errors first, ~20 lines); nothing is
+  appended when the file is clean.
+
 ## Logging
 
 zerostack uses the `tracing` framework for structured logging. By default, only

docs/CONFIG.md

@@ -182,7 +182,21 @@ pub async fn build_agent_inner<M: CompletionModel + 'static>(
     additional_params: Option<serde_json::Value>,
     #[cfg(feature = "mcp")] mcp_manager: Option<&McpClientManager>,
 ) -> Agent<M> {
-    let preamble = build_preamble(context, reasoning_enabled);
+    #[cfg(feature = "lsp")]
+    let lsp_manager = if cli.resolve_no_tools(cfg) {
+        None
+    } else {
+        cfg.resolve_lsp().map(|c| {
+            crate::extras::lsp::LspManager::new(c, std::env::current_dir().unwrap_or_default())
+        })
+    };
+
+    #[cfg_attr(not(feature = "lsp"), allow(unused_mut))]
+    let mut preamble = build_preamble(context, reasoning_enabled);
+    #[cfg(feature = "lsp")]
+    if lsp_manager.is_some() {
+        preamble.push_str(crate::agent::prompt::LSP_PROMPT);
+    }
 
     let mut builder = AgentBuilder::new(model).preamble(&preamble);
 
@@ -209,19 +223,22 @@ pub async fn build_agent_inner<M: CompletionModel + 'static>(
         let max_grep_results = cfg.resolve_max_grep_results();
         let max_find_results = cfg.resolve_max_find_results();
         let max_list_dir_entries = cfg.resolve_max_list_dir_entries();
+        let write_tool =
+            tools::WriteTool::new(permission.clone(), ask_tx.clone(), max_text_file_size);
+        #[cfg(feature = "lsp")]
+        let write_tool = write_tool.with_lsp(lsp_manager.clone());
+        let edit_tool = tools::EditTool::new(permission.clone(), ask_tx.clone());
+        #[cfg(feature = "lsp")]
+        let edit_tool = edit_tool.with_lsp(lsp_manager.clone());
         let base_tools: SmallVec<[Box<dyn rig::tool::ToolDyn>; 8]> = SmallVec::from_buf([
             Box::new(tools::ReadTool::new(
                 permission.clone(),
                 ask_tx.clone(),
                 max_text_file_size,
                 max_read_lines,
             )),
-            Box::new(tools::WriteTool::new(
-                permission.clone(),
-                ask_tx.clone(),
-                max_text_file_size,
-            )),
-            Box::new(tools::EditTool::new(permission.clone(), ask_tx.clone())),
+            Box::new(write_tool),
+            Box::new(edit_tool),
             Box::new(tools::BashTool::new(
                 permission.clone(),
                 ask_tx.clone(),
@@ -254,7 +271,8 @@ pub async fn build_agent_inner<M: CompletionModel + 'static>(
                 feature = "subagents",
                 feature = "memory",
                 feature = "mcp",
-                feature = "advisor"
+                feature = "advisor",
+                feature = "lsp"
             )),
             allow(unused_mut)
         )]
@@ -309,6 +327,11 @@ pub async fn build_agent_inner<M: CompletionModel + 'static>(
             all_tools.push(Box::new(AdvisorTool::new()));
         }
 
+        #[cfg(feature = "lsp")]
+        if let Some(lsp) = &lsp_manager {
+            all_tools.push(Box::new(tools::lsp::LspTool::new(lsp.clone())));
+        }
+
         let all_tools = filter_tools_by_allowlist(all_tools, &cli.tools);
 
         #[cfg(feature = "hooks")]

src/agent/builder.rs

@@ -38,6 +38,18 @@ You are an expert coding assistant. Read, write, edit files and run commands. Re
 
 pub const TODO_TOOLS_PROMPT: &str = "";
 
+/// Appended to the preamble when LSP integration is active (`[lsp]
+/// enabled = true`). Tells the model that diagnostics arrive automatically
+/// after edits and that it can query them on demand.
+#[cfg(feature = "lsp")]
+pub const LSP_PROMPT: &str = "\n\n## LSP diagnostics\n\
+Language servers are running for this project: after every successful edit or \
+write, fresh diagnostics (errors/warnings) are appended to the tool result \
+automatically. Trust them and fix what they report before moving on — no need \
+to run a manual typecheck just to confirm. Use the lsp_diagnostics tool to \
+query a file before editing it, or to list diagnostics across the project. \
+Files with no server configured simply return no diagnostics.";
+
 pub const COMPACTION_PROMPT: &str = "\
 You are a conversation summarizer for a coding session. Distill the following conversation into a concise summary.
 

src/agent/prompt.rs

@@ -6,15 +6,32 @@ use crate::agent::tools::{
     levenshtein_similarity, normalize_whitespace,
 };
 use crate::config::types::EditSystem;
+#[cfg(feature = "lsp")]
+use crate::extras::lsp::LspManager;
 
 pub struct EditTool {
     pub permission: Option<PermCheck>,
     pub ask_tx: Option<AskSender>,
+    /// When `Some`, edited files are synced to their language server and
+    /// fresh diagnostics are appended to the tool result.
+    #[cfg(feature = "lsp")]
+    pub lsp: Option<LspManager>,
 }
 
 impl EditTool {
     pub fn new(permission: Option<PermCheck>, ask_tx: Option<AskSender>) -> Self {
-        EditTool { permission, ask_tx }
+        EditTool {
+            permission,
+            ask_tx,
+            #[cfg(feature = "lsp")]
+            lsp: None,
+        }
+    }
+
+    #[cfg(feature = "lsp")]
+    pub fn with_lsp(mut self, lsp: Option<LspManager>) -> Self {
+        self.lsp = lsp;
+        self
     }
 }
 
@@ -607,6 +624,15 @@ impl Tool for EditTool {
             result = format!("{}\n\n{}", msg, result);
         }
 
+        #[cfg(feature = "lsp")]
+        if let Some(lsp) = &self.lsp {
+            let file = std::path::Path::new(&path);
+            lsp.notify_changed(file).await;
+            if let Some(block) = lsp.diagnostics_block_for_edit(file).await {
+                result.push_str(&block);
+            }
+        }
+
         Ok(result)
     }
 }

src/agent/tools/edit.rs

@@ -0,0 +1,78 @@
+//! `lsp_diagnostics` agent tool: on-demand language-server diagnostics.
+//! Post-edit diagnostics are appended to edit/write results automatically;
+//! this tool is for querying a file before editing it, or surveying the
+//! whole project.
+
+use std::path::Path;
+use std::time::Duration;
+
+use rig::tool::Tool;
+use serde::Deserialize;
+
+use crate::agent::tools::ToolError;
+use crate::extras::lsp::LspManager;
+
+/// Longer than the post-edit wait: an explicit query justifies giving the
+/// server more time to catch up.
+const QUERY_WAIT: Duration = Duration::from_secs(3);
+
+pub struct LspTool {
+    pub manager: LspManager,
+}
+
+#[derive(Deserialize)]
+pub struct LspArgs {
+    /// File to inspect. Omit to list diagnostics for every file.
+    pub path: Option<String>,
+}
+
+impl LspTool {
+    pub fn new(manager: LspManager) -> Self {
+        Self { manager }
+    }
+}
+
+impl Tool for LspTool {
+    const NAME: &'static str = "lsp_diagnostics";
+
+    type Error = ToolError;
+    type Args = LspArgs;
+    type Output = String;
+
+    fn description(&self) -> String {
+        "Get language-server diagnostics (errors/warnings). With `path`: diagnostics for that file, synced from disk first. Without: every file that currently has diagnostics.".to_string()
+    }
+
+    fn parameters(&self) -> serde_json::Value {
+        serde_json::json!({
+            "type": "object",
+            "properties": {
+                "path": { "type": "string", "description": "File to inspect (optional; omit for all files)" }
+            }
+        })
+    }
+
+    async fn call(&self, args: LspArgs) -> Result<String, ToolError> {
+        match args.path {
+            Some(path) => {
+                let expanded = crate::fs::expand_tilde(&path);
+                let path = Path::new(&expanded);
+                if !path.exists() {
+                    return Err(ToolError::Msg(format!("File '{expanded}' does not exist.")));
+                }
+                self.manager.notify_changed(path).await;
+                Ok(self
+                    .manager
+                    .diagnostics_block(path, QUERY_WAIT)
+                    .await
+                    .map(|block| block.trim_start().to_string())
+                    .unwrap_or_else(|| format!("No diagnostics for {expanded}.")))
+            }
+            None => Ok(self
+                .manager
+                .all_diagnostics_block()
+                .map(|block| format!("Files with diagnostics:\n{block}"))
+                .unwrap_or_else(|| "No diagnostics.".to_string())),
+        }
+    }
+}

src/agent/tools/lsp.rs

@@ -4,6 +4,8 @@ pub(crate) mod edit;
 pub(crate) mod find_files;
 pub(crate) mod grep;
 pub(crate) mod list_dir;
+#[cfg(feature = "lsp")]
+pub(crate) mod lsp;
 pub(crate) mod normalize;
 pub(crate) mod read;
 pub(crate) mod todo;