Add LSP diagnostics support. Related to #56

Author: ericdallo

CHANGELOG.md

@@ -2,6 +2,8 @@
 
 ## Unreleased
 
+- Add editor tools to retrieve information like diagnostics. #56
+
 ## 0.28.0
 
 - Change api for custom providers to support `openai-responses` instead of just `openai`, still supporting `openai` only.

docs/configuration.md

@@ -161,10 +161,11 @@ There are 3 possible ways to configure rules following this order of priority:
         rules: [{path: string;}];
         commands: [{path: string;}];
         systemPromptTemplateFile?: string;
-        nativeTools: {
+        nativeTools?: {
             filesystem: {enabled: boolean};
             shell: {enabled: boolean,
                     excludeCommands: string[]};
+            editor: {enabled: boolean,};
         };
         disabledTools: string[],
         toolCall?: {
@@ -222,7 +223,8 @@ There are 3 possible ways to configure rules following this order of priority:
       "commands" : [],
       "nativeTools": {"filesystem": {"enabled": true},
                       "shell": {"enabled": true,
-                                "excludeCommands": []}},
+                                "excludeCommands": []},
+                       "editor": {"enabled": true}},
       "disabledTools": [],
       "toolCall": {
         "manualApproval": null,

docs/features.md

@@ -42,6 +42,12 @@ Provides access to run shell commands, useful to run build tools, tests, and oth
 
 - `eca_shell_command`: run shell command. Supports configs to exclude commands via `:nativeTools :shell :excludeCommands`.
 
+#### Editor
+
+Provides access to get information from editor workspaces.
+
+- `eca_editor_diagnostics`: Ask client about the diagnostics (like LSP diagnostics).
+
 ### Contexts
 
 ![](./images/features/contexts.png)

docs/protocol.md

@@ -127,9 +127,19 @@ interface WorkspaceFolder {
 interface ClientCapabilities {
     codeAssistant?: {
         chat?: boolean;
-        doc?: boolean;
-        edit?: boolean;
-        fix?: boolean;
+        
+        /**
+         * Whether client supports provide editor informations to server like
+         * diagnostics, cursor information and others.
+         */
+        editor?: {
+            /**
+             * Whether client supports provide editor diagnostics 
+             * information to server (Ex: LSP diagnostics) via `editor/getDiagnostics` 
+             * server request.
+             */ 
+            diagnostics?: boolean;
+        }
     }
 }
 
@@ -943,6 +953,78 @@ _Response:_
 interface ChatDeleteResponse {}
 ```
 
+## Editor diagnostics (↪️)
+
+A server request to retrieve LSP or any other kind of diagnostics if available from current workspaces.
+Useful for server to provide to LLM information about errors/warnings about current code.
+
+_Request:_ 
+
+* method: `editor/getDiagnostics`
+* params: `EditorGetDiagnosticsParams` defined as follows:
+
+```typescript
+interface EditorGetDiagnosticsParams {
+    /**
+     * Optional uri to get diagnostics, if nil return whole workspaces diagnostics.
+     */
+    uri?: string;
+}
+```
+
+_Response:_
+
+```typescript
+interface EditorGetDiagnosticsResponse {
+    /**
+     * The list of diagnostics.
+     */
+    diagnostics: EditorDiagnostic[];
+}
+
+interface EditorDiagnostic {
+    /**
+     * The diagnostic file uri.
+     */
+    uri: string;
+    
+    /**
+     * The diagnostic severity.
+     */
+    severity: 'error' | 'warning' | 'info' | 'hint';
+    
+    /**
+     * The diagnostic source. Ex: 'clojure-lsp'
+     */
+    source: string;
+    
+    /**
+     * The diagnostic range (1-based).
+     */
+    range: {
+        start: {
+            line: number;
+            character: number;
+        };
+        
+        end: {
+            line: number;
+            character: number;
+        };
+    };
+    
+    /**
+     * The diagnostic code. Ex: 'wrong-args'
+     */
+    code?: string;
+
+    /**
+     * The diagnostic message. Ex: 'Wrong number of args for function X'
+     */
+    message: string; 
+}
+```
+
 ### Completion (↩️)
 
 Soon

src/eca/config.clj

@@ -27,7 +27,8 @@
    :commands []
    :nativeTools {:filesystem {:enabled true}
                  :shell {:enabled true
-                         :excludeCommands []}}
+                         :excludeCommands []}
+                 :editor {:enabled true}}
    :disabledTools []
    :mcpTimeoutSeconds 60
    :mcpServers {}

src/eca/features/chat.clj

@@ -103,7 +103,7 @@
 (defn ^:private prompt-messages!
   [user-messages
    clear-history-after-finished?
-   {:keys [db* config chat-id contexts behavior model instructions] :as chat-ctx}]
+   {:keys [db* config chat-id contexts behavior model instructions messenger] :as chat-ctx}]
   (when (seq contexts)
     (send-content! chat-ctx :system {:type :progress
                                      :state :running
@@ -210,7 +210,7 @@
                                          ;; Execute each tool call concurrently
                                           (future
                                             (if @approved?*
-                                              (let [result (f.tools/call-tool! name arguments @db* config)]
+                                              (let [result (f.tools/call-tool! name arguments @db* config messenger)]
                                                 (assert-chat-not-stopped! chat-ctx)
                                                 (add-to-history! {:role "tool_call" :content (assoc tool-call
                                                                                                     :details details

src/eca/features/tools.clj

@@ -5,6 +5,7 @@
    [babashka.fs :as fs]
    [clojure.string :as string]
    [eca.diff :as diff]
+   [eca.features.tools.editor :as f.tools.editor]
    [eca.features.tools.filesystem :as f.tools.filesystem]
    [eca.features.tools.mcp :as f.mcp]
    [eca.features.tools.shell :as f.tools.shell]
@@ -31,7 +32,9 @@
           (when (get-in config [:nativeTools :filesystem :enabled])
             f.tools.filesystem/definitions)
           (when (get-in config [:nativeTools :shell :enabled])
-            f.tools.shell/definitions))))
+            f.tools.shell/definitions)
+          (when (get-in config [:nativeTools :editor :enabled])
+            f.tools.editor/definitions))))
 
 (defn ^:private native-tools [db config]
   (vals (native-definitions db config)))
@@ -53,12 +56,14 @@
       (mapv #(assoc % :origin :native) (native-tools db config))
       (mapv #(assoc % :origin :mcp) (f.mcp/all-tools db))))))
 
-(defn call-tool! [^String name ^Map arguments db config]
+(defn call-tool! [^String name ^Map arguments db config messenger]
   (logger/info logger-tag (format "Calling tool '%s' with args '%s'" name arguments))
   (let [arguments (update-keys arguments clojure.core/name)]
     (try
       (let [result (if-let [native-tool-handler (get-in (native-definitions db config) [name :handler])]
-                     (native-tool-handler arguments {:db db :config config})
+                     (native-tool-handler arguments {:db db
+                                                     :config config
+                                                     :messenger messenger})
                      (f.mcp/call-tool! name arguments db))]
         (logger/debug logger-tag "Tool call result: " result)
         result)
@@ -114,10 +119,10 @@
 
 (defn manual-approval? [name config]
   (boolean
-    (let [manual-approval? (get-in config [:toolCall :manualApproval] nil)]
-      (if (coll? manual-approval?)
-        (some #(= name (str %)) manual-approval?)
-        manual-approval?))))
+   (let [manual-approval? (get-in config [:toolCall :manualApproval] nil)]
+     (if (coll? manual-approval?)
+       (some #(= name (str %)) manual-approval?)
+       manual-approval?))))
 
 (defn tool-call-summary [all-tools name args]
   (when-let [summary-fn (:summary-fn (first (filter #(= name (:name %))

src/eca/features/tools/editor.clj

@@ -0,0 +1,50 @@
+(ns eca.features.tools.editor
+  (:require
+   [babashka.fs :as fs]
+   [clojure.string :as string]
+   [eca.features.tools.util :as tools.util]
+   [eca.logger :as logger]
+   [eca.messenger :as messenger]
+   [eca.shared :as shared]))
+
+(defn ^:private diagnostics [arguments {:keys [messenger]}]
+  (or (tools.util/invalid-arguments arguments [["path" #(or (nil? %)
+                                                            (string/blank? %)
+                                                            (not (fs/directory? %))) "Path needs to be a file, not a directory."]])
+      (let [uri (some-> (get arguments "path") not-empty shared/filename->uri)]
+        (try
+          (let [diags (:diagnostics @(messenger/editor-diagnostics messenger uri))]
+            (if (seq diags)
+              {:error false
+               :contents [{:type :text
+                           :text (reduce
+                                  (fn [s {:keys [uri range severity code message]}]
+                                    (str s (format "%s:%s:%s: %s: %s%s"
+                                                   (shared/uri->filename uri)
+                                                   (-> range :start :line)
+                                                   (-> range :start :character)
+                                                   severity
+                                                   (if code (format "[%s] " code) "")
+                                                   message)))
+                                  ""
+                                  diags)}]}
+              {:error false
+               :contents [{:type :text
+                           :text "No diagnostics found"}]}))
+          (catch Exception e
+            (logger/error (format "Error getting editor diagnostics for arguments %s: %s" arguments e))
+            {:error true
+             :contents [{:type :text
+                         :text "Error getting editor diagnostics"}]})))))
+
+(def definitions
+  {"eca_editor_diagnostics"
+   {:description (str "Return editor diagnostics/findings (Ex: LSP diagnostics) for workspaces. "
+                      "Only provide the path if you want to get diagnostics for a specific file.")
+    :parameters {:type "object"
+                 :properties {"path" {:type "string"
+                                      :description "Optional absolute path to a file to return diagnostics only for that file."}}
+                 :required []}
+    :handler #'diagnostics
+    :enabled-fn (fn [{:keys [db]}] (-> db :client-capabilities :code-assistant :editor :diagnostics))
+    :summary-fn (constantly "Checking diagnostics")}})

src/eca/messenger.clj

@@ -7,4 +7,5 @@
 (defprotocol IMessenger
   (chat-content-received [this data])
   (tool-server-updated [this params])
-  (showMessage [this msg]))
+  (showMessage [this msg])
+  (editor-diagnostics [this uri]))

src/eca/server.clj

@@ -7,7 +7,7 @@
    [eca.logger :as logger]
    [eca.messenger :as messenger]
    [eca.nrepl :as nrepl]
-   [eca.shared :as shared]
+   [eca.shared :as shared :refer [assoc-some]]
    [lsp4clj.io-server :as io-server]
    [lsp4clj.liveness-probe :as liveness-probe]
    [lsp4clj.server :as lsp.server]))
@@ -104,7 +104,10 @@
      (lsp.server/send-notification server "tool/serverUpdated" params)))
   (showMessage [_this msg]
     (lsp.server/discarding-stdout
-     (lsp.server/send-notification server "$/showMessage" msg))))
+     (lsp.server/send-notification server "$/showMessage" msg)))
+  (editor-diagnostics [_this uri]
+    (lsp.server/discarding-stdout
+     (lsp.server/send-request server "editor/getDiagnostics" (assoc-some {} :uri uri)))))
 
 (defn start-server! [server]
   (let [db* (atom db/initial-db)