Replace clj-kondo with edamame for delimiter checking

Simplifies delimiter error detection by replacing comprehensive clj-kondo linting with edamame's focused delimiter checking. This reduces dependencies and overhead while maintaining reliable detection of unbalanced parentheses, brackets, braces, and quotes. Semantic errors are now caught at evaluation time rather than pre-evaluation.

🤖 Generated with [Claude Code](https://claude.com/claude-code)

Co-Authored-By: Claude <noreply@anthropic.com>

Author: Bruce Hauman

deps.edn

@@ -15,7 +15,7 @@
         ;; Clojure source manipulation
         rewrite-clj/rewrite-clj {:mvn/version "1.1.47"}
         dev.weavejester/cljfmt {:mvn/version "0.13.1"}
-        clj-kondo/clj-kondo {:mvn/version "2024.03.13"}
+        borkdude/edamame {:mvn/version "1.5.35"}
         org.clojars.oakes/parinfer {:mvn/version "0.4.0"}
 
         ;; llm ecosystem java libs
@@ -146,8 +146,6 @@
                  {:git/tag "v0.9.2" :git/sha "fe6b140"}
                  slipset/deps-deploy {:mvn/version "0.2.0"}}
           :ns-default build}
-  :neil {:project {:name clojure-mcp/clojure-mcp}}
-  :lint {:deps {clj-kondo/clj-kondo {:mvn/version "2025.02.20"}}
-         :main-opts ["-m" "clj-kondo.main" "--lint" "src"]}}}
+  :neil {:project {:name clojure-mcp/clojure-mcp}}}}
 
 

src/clojure_mcp/delimiter.clj

@@ -0,0 +1,42 @@
+(ns clojure-mcp.delimiter
+  "Delimiter error checking using edamame parser."
+  (:require [edamame.core :as e]))
+
+(defn delimiter-error?
+  "Returns true if the string has a delimiter error specifically.
+   Checks both that it's an :edamame/error and has delimiter info.
+   Uses :all true to enable all standard Clojure reader features:
+   function literals, regex, quotes, syntax-quote, deref, var, etc.
+   Also enables :read-cond :allow to support reader conditionals.
+   Handles unknown data readers gracefully with a default reader fn."
+  [s]
+  (try
+    (e/parse-string-all s {:all true
+                           :features #{:bb :clj :cljs :cljr :default}
+                           :read-cond :allow
+                           :readers (fn [_tag] (fn [data] data))
+                           :auto-resolve name})
+    false ; No error = no delimiter error
+    (catch clojure.lang.ExceptionInfo ex
+      (let [data (ex-data ex)]
+        (and (= :edamame/error (:type data))
+             (contains? data :edamame/opened-delimiter))))
+    (catch Exception _e
+      ;; For other exceptions, conservatively return true
+      ;; to allow potential delimiter repair attempts
+      true)))
+
+(defn count-forms
+  "Counts the number of top-level forms in a string using edamame.
+   Returns the count of forms, or throws an exception if parsing fails."
+  [s]
+  (try
+    (count (e/parse-string-all s {:all true
+                                  :features #{:bb :clj :cljs :cljr :default}
+                                  :read-cond :allow
+                                  :readers (fn [_tag] (fn [data] data))
+                                  :auto-resolve name}))
+    (catch Exception e
+      (throw (ex-info "Failed to parse forms"
+                      {:error (ex-message e)}
+                      e)))))

src/clojure_mcp/linting.clj

@@ -1,6 +1,6 @@
 (ns clojure-mcp.sexp.paren-utils
   (:require
-   [clojure-mcp.linting :as linting]
+   [clojure-mcp.delimiter :as delimiter]
    [rewrite-clj.parser :as parser]
    [rewrite-clj.node :as node]
    [clojure.string :as string])
@@ -92,44 +92,15 @@
 (defn parinfer-repair [code-str]
   (let [res (Parinfer/indentMode code-str nil nil nil false)]
     (when (and (.success res)
-               (not (:error? (linting/lint (.text res)))))
+               (not (delimiter/delimiter-error? (.text res))))
       (.text res))))
 
-(def delimiter-error-patterns [#"Unmatched bracket"
-                               #"Found an opening .* with no matching"
-                               #"Expected a .* to match"
-                               #"Mismatched bracket"
-                               #"Unexpected EOF while reading"
-                               #"Unmatched opening"
-                               #"Unmatched closing"])
-
-(defn has-delimiter-errors? [{:keys [report error?] :as lint-result}]
-  (if (and lint-result error?)
-    (boolean (some #(re-find % report) delimiter-error-patterns))
-    false))
-
 (defn code-has-delimiter-errors?
   "Returns true if the given Clojure code string has delimiter errors
    (unbalanced parentheses, brackets, braces, or string quotes).
    Returns false otherwise."
   [code-str]
-  (let [lint-result (linting/lint-delims code-str)]
-    (has-delimiter-errors? lint-result)))
-
-#_(defn smart-repair [code-str]
-    (if-let [parinfer-result (parinfer-repair code-str)]
-      (if-let [lint-result (linting/lint parinfer-result)]
-        {:repaired? true
-         :form parinfer-result
-         :message "Parenthesis repaired using parinfer"}
-        ;; Parinfer produced code with semantic issues, try homegrown approach
-        (or (repair-parens code-str)
-            ;; If homegrown fails too, return parinfer result with a warning
-            {:repaired? true
-             :form parinfer-result
-             :message "Warning: Fixed syntax but may have changed semantics"}))
-      ;; Parinfer failed (unlikely), fall back to homegrown
-      (repair-parens code-str)))
+  (delimiter/delimiter-error? code-str))
 
 (comment
   (def code1 "(defn hello [name] (str \"Hello\" name)))")

src/clojure_mcp/sexp/paren_utils.clj

@@ -3,7 +3,7 @@
    This namespace contains the pure functionality without any MCP-specific code."
   (:require
    [clojure-mcp.nrepl :as nrepl]
-   [clojure-mcp.linting :as linting]
+   [clojure-mcp.delimiter :as delimiter]
    [clojure-mcp.sexp.paren-utils :as paren-utils]
    [clojure.string :as string]
    [clojure.tools.logging :as log]))
@@ -36,10 +36,9 @@
 
 (defn repair-code
   [code]
-  (let [linted (linting/lint code)]
-    (if (and linted (:error? linted) (paren-utils/has-delimiter-errors? linted))
-      (or (paren-utils/parinfer-repair code) code)
-      code)))
+  (if (delimiter/delimiter-error? code)
+    (or (paren-utils/parinfer-repair code) code)
+    code))
 
 (defn evaluate-code
   "Evaluates Clojure code using the nREPL client.
@@ -58,67 +57,55 @@
         outputs (atom [])
         error-occurred (atom false)
         form-str code
-        linted (linting/lint form-str)
         add-output! (fn [prefix value] (swap! outputs conj [prefix value]))
         result-promise (promise)]
 
-    ;; Add linter output if present
-    (when linted
-      (add-output! :lint (:report linted))
-      (when (:error? linted)
-        (reset! error-occurred true)))
-
-    ;; If linter found critical errors, return early
-    (if @error-occurred
-      {:outputs @outputs
-       :error true}
-
-      ;; Otherwise, evaluate the code
-      (do
+    ;; Evaluate the code
+    (do
         ;; Push to eval history if available
-        (when-let [state (::nrepl/state nrepl-client)]
-          (swap! state update :clojure-mcp.repl-tools/eval-history conj form-str))
+      (when-let [state (::nrepl/state nrepl-client)]
+        (swap! state update :clojure-mcp.repl-tools/eval-history conj form-str))
 
         ;; Evaluate the code, using the namespace parameter if provided
-        (try
-          (nrepl/eval-code-msg
-           nrepl-client form-str
-           (if session {:session session} {})
-           (->> identity
-                (nrepl/out-err
-                 #(add-output! :out %)
-                 #(add-output! :err %))
-                (nrepl/value #(add-output! :value %))
-                (nrepl/done (fn [_]
-                              (deliver result-promise
-                                       {:outputs @outputs
-                                        :error @error-occurred})))
-                (nrepl/error (fn [{:keys [exception]}]
-                               (reset! error-occurred true)
-                               (add-output! :err exception)
-                               (deliver result-promise
-                                        {:outputs @outputs
-                                         :error true})))))
-          (catch Exception e
+      (try
+        (nrepl/eval-code-msg
+         nrepl-client form-str
+         (if session {:session session} {})
+         (->> identity
+              (nrepl/out-err
+               #(add-output! :out %)
+               #(add-output! :err %))
+              (nrepl/value #(add-output! :value %))
+              (nrepl/done (fn [_]
+                            (deliver result-promise
+                                     {:outputs @outputs
+                                      :error @error-occurred})))
+              (nrepl/error (fn [{:keys [exception]}]
+                             (reset! error-occurred true)
+                             (add-output! :err exception)
+                             (deliver result-promise
+                                      {:outputs @outputs
+                                       :error true})))))
+        (catch Exception e
             ;; prevent connection errors from confusing the LLM
-            (log/error e "Error when trying to eval on the nrepl connection")
-            (throw
-             (ex-info
-              (str "Internal Error: Unable to reach the nREPL "
-                   "thus we are unable to execute the bash command.")
-              {:error-type :connection-error}
-              e))))
+          (log/error e "Error when trying to eval on the nrepl connection")
+          (throw
+           (ex-info
+            (str "Internal Error: Unable to reach the nREPL "
+                 "thus we are unable to execute the bash command.")
+            {:error-type :connection-error}
+            e))))
 
         ;; Wait for the result and return it
-        (let [tmb (Object.)
-              res (deref result-promise timeout-ms tmb)]
-          (if-not (= tmb res)
-            res
-            (do
-              (nrepl/interrupt nrepl-client)
-              {:outputs [[:err (str "Eval timed out after " timeout-ms "ms.")]
-                         [:err "Perhaps, you had an infinite loop or an eval that ran too long."]]
-               :error true})))))))
+      (let [tmb (Object.)
+            res (deref result-promise timeout-ms tmb)]
+        (if-not (= tmb res)
+          res
+          (do
+            (nrepl/interrupt nrepl-client)
+            {:outputs [[:err (str "Eval timed out after " timeout-ms "ms.")]
+                       [:err "Perhaps, you had an infinite loop or an eval that ran too long."]]
+             :error true}))))))
 
 (defn evaluate-with-repair
   "Evaluates Clojure code with automatic repair of delimiter errors.

src/clojure_mcp/tools/eval/core.clj

@@ -10,7 +10,6 @@
    [clojure-mcp.tools.agent-tool-builder.file-changes :as file-changes]
    [clojure-mcp.tools.unified-read-file.file-timestamps :as file-timestamps]
    [clojure-mcp.config :as config]
-   [clojure-mcp.linting :as linting]
    [clojure.spec.alpha :as s]
    [clojure.string :as str]
    [clojure.java.io :as io]

src/clojure_mcp/tools/file_edit/pipeline.clj

@@ -5,7 +5,6 @@
    [clojure.java.io :as io]
    [clojure-mcp.tools.form-edit.pipeline :as pipeline]
    [clojure-mcp.utils.diff :as diff-utils]
-   [clojure-mcp.linting :as linting]
    [clojure-mcp.utils.valid-paths :as valid-paths]
    [rewrite-clj.zip :as z]
    [clojure-mcp.utils.file :as file-utils]))