Ensure evaluated code is balanced

* Fixes #25

Author: PEZ

CHANGELOG.md

@@ -4,6 +4,8 @@ Changes to Calva Backseat Driver
 
 ## [Unreleased]
 
+- [Balance brackets before evaluating code](https://github.com/BetterThanTomorrow/calva-backseat-driver/issues/25)
+
 ## [v0.0.16] - 2025-08-12
 
 - [Human Intelligence input box closes when focus is lost (should persist)](https://github.com/BetterThanTomorrow/calva-backseat-driver/issues/22)

src/calva_backseat_driver/bracket_balance.cljs

@@ -2,13 +2,17 @@
   (:require ["parinfer" :as parinfer]))
 
 (defn infer-parens
+  [code]
+  (some-> (parinfer/indentMode code #js {:partialResult true})
+          (js->clj :keywordize-keys true)))
+
+(defn infer-parens-response
   "Infer parens from the indentation"
   [{:ex/keys [dispatch!]
     :calva/keys [text]}]
   (dispatch! [[:app/ax.log :debug "[Server] Infering brackets for:" text]])
   (try
-    (let [result (some-> (parinfer/indentMode  text #js {:partialResult true})
-                         (js->clj :keywordize-keys true))]
+    (let [result (infer-parens text)]
       (clj->js
        (if (:success result)
          (let [new-text (:text result)]
@@ -21,5 +25,5 @@
       #js {:error (.-message e)})))
 
 (comment
-  (infer-parens {:ex/dispatch! println
-                 :calva/text "(def foo [a b"}))
+  (infer-parens-response {:ex/dispatch! println
+                          :calva/text "(def foo [a b"}))

src/calva_backseat_driver/integrations/calva/features.cljs

@@ -1,6 +1,7 @@
 (ns calva-backseat-driver.integrations.calva.features
   (:require
    ["vscode" :as vscode]
+   [calva-backseat-driver.bracket-balance :as balance]
    [calva-backseat-driver.integrations.calva.api :as calva]
    [calva-backseat-driver.integrations.calva.editor :as editor]
    [promesa.core :as p]))
@@ -11,43 +12,56 @@
 (def ^:private empty-result-note
   "Not expecting a empty string as a result? If it is the first time you are using a namespace, evaluate its ns-form in the `user` namespace first.")
 
-
 (def ^:private error-result-note
   "* clj: Evaluating `*e` will give your information about the error.
    * cljs: Evaluating `(.-stack *e), gives you a stack trace")
 
+
 (defn evaluate-code+
   "Returns a promise that resolves to the result of evaluating Clojure/ClojureScript code.
    Takes a string of code to evaluate and a session key (clj/cljs/cljc), js/undefined means current session."
   [{:ex/keys [dispatch!]
     :calva/keys [code repl-session-key ns]}]
-  (p/let [evaluate (get-in calva/calva-api [:repl :evaluateCode])
-          result (-> (p/let [^js evaluation+ (if ns
-                                               (evaluate repl-session-key code ns)
-                                               (evaluate repl-session-key code))]
-                       (dispatch! [[:app/ax.log :debug "[Server] Evaluating code:" code]])
-                       (cond-> {:result (.-result evaluation+)
-                                :ns (.-ns evaluation+)
-                                :stdout (.-output evaluation+)
-                                :stderr (.-errorOutput evaluation+)
-                                :session-key (.-replSessionKey evaluation+)
-                                :note "Remember to check the output tool now and then to see what's happening in the application."}
-                         (.-error evaluation+)
-                         (merge {:error (.-error evaluation+)
-                                 :stacktrace (.-stacktrace evaluation+)})
-
-                         (not ns)
-                         (merge {:note no-ns-eval-note})
-
-                         (= "" (.-result evaluation+))
-                         (merge {:note empty-result-note})))
-                     (p/catch (fn [err]
-                                (dispatch! [[:app/ax.log :debug "[Server] Evaluation failed:"
-                                             err]])
-                                {:result "nil"
-                                 :stderr (pr-str err)
-                                 :note error-result-note})))]
-    (clj->js result)))
+  (let [inferred (balance/infer-parens code)
+        balancded-code (if (:success inferred)
+                         (:text inferred)
+                         code)
+        balancing-ocurred? (not= code balancded-code)]
+    (when balancing-ocurred?
+      (dispatch! [[:app/ax.log :debug "[Server] Code was unbalanced:" code "balancded-code:" balancded-code]]))
+    (p/let [evaluate (get-in calva/calva-api [:repl :evaluateCode])
+            result (-> (p/let [^js evaluation+ (if ns
+                                                 (evaluate repl-session-key balancded-code ns)
+                                                 (evaluate repl-session-key balancded-code))]
+                         (dispatch! [[:app/ax.log :debug "[Server] Evaluating code:" balancded-code]])
+                         (cond-> {:result (.-result evaluation+)
+                                  :ns (.-ns evaluation+)
+                                  :stdout (.-output evaluation+)
+                                  :stderr (.-errorOutput evaluation+)
+                                  :session-key (.-replSessionKey evaluation+)
+                                  :note "Remember to check the output tool now and then to see what's happening in the application."}
+
+                           balancing-ocurred?
+                           (merge
+                            {:balancing-note "The code provided for evaluation had unbalanced brackets. The code was automatically balanced before evaluation. Use the code in the `balanced-code` to correct your code on record."
+                             :balanced-code balancded-code})
+
+                           (.-error evaluation+)
+                           (merge {:error (.-error evaluation+)
+                                   :stacktrace (.-stacktrace evaluation+)})
+
+                           (not ns)
+                           (merge {:note no-ns-eval-note})
+
+                           (= "" (.-result evaluation+))
+                           (merge {:note empty-result-note})))
+                       (p/catch (fn [err]
+                                  (dispatch! [[:app/ax.log :debug "[Server] Evaluation failed:"
+                                               err]])
+                                  {:result "nil"
+                                   :stderr (pr-str err)
+                                   :note error-result-note})))]
+      (clj->js result))))
 
 (defn get-clojuredocs+ [{:ex/keys [dispatch!]
                          :calva/keys [clojure-symbol]}]

src/calva_backseat_driver/mcp/requests.cljs

@@ -269,8 +269,8 @@
 
         (= tool "balance_brackets")
         (let [{:keys [text]} arguments
-              result (bracket-balance/infer-parens (merge options
-                                                          {:calva/text text}))]
+              result (bracket-balance/infer-parens-response (merge options
+                                                                   {:calva/text text}))]
           {:jsonrpc "2.0"
            :id id
            :result {:content [{:type "text"

src/calva_backseat_driver/tools.cljs

@@ -90,8 +90,8 @@
 
        :invoke (fn invoke [^js options _token]
                  (let [text (-> options .-input .-text)
-                       result (balance/infer-parens {:ex/dispatch! dispatch!
-                                                     :calva/text text})]
+                       result (balance/infer-parens-response {:ex/dispatch! dispatch!
+                                                              :calva/text text})]
                    (vscode/LanguageModelToolResult.
                     #js [(vscode/LanguageModelTextPart.
                           (js/JSON.stringify result))])))})