Merge pull request #42 from BetterThanTomorrow:41-unbalance-refusal

41-unbalance-refusal

* Fixes #41

Author: PEZ

CHANGELOG.md

@@ -4,6 +4,8 @@ Changes to Calva Backseat Driver
 
 ## [Unreleased]
 
+- [Avoid using potentially incorrectly auto-balanced code in evaluations and edits](https://github.com/BetterThanTomorrow/calva-backseat-driver/issues/41)
+
 ## [v0.0.22] - 2025-10-01
 
 - Fix: [Evaluation tool not available in v0.0.21](https://github.com/BetterThanTomorrow/calva-backseat-driver/issues/39)

e2e-test-ws/.joyride/src/tests/mcp/server_test.cljs

@@ -1,6 +1,5 @@
 (ns tests.mcp.server-test
   (:require
-   ["fs" :as fs]
    ["net" :as net]
    ["path" :as path]
    ["vscode" :as vscode]

e2e-test-ws/.joyride/src/tests/ws_ready/example_test.cljs

@@ -1,5 +1,5 @@
 (ns tests.ws-ready.example-test
-  (:require [cljs.test :refer [deftest testing is]]
+  (:require [cljs.test :refer [deftest is]]
             ["vscode" :as vscode]
             workspace-activate))
 

scripts/tasks.clj

@@ -1,5 +1,5 @@
 (ns tasks
-  (:require [babashka.process :as p]
+  (:require #_[babashka.process :as p]
             [clojure.string :as string]
             [babashka.fs :as fs]
             publish

src/calva_backseat_driver/bracket_balance.cljs

@@ -1,18 +1,13 @@
 (ns calva-backseat-driver.bracket-balance
-  (:require ["parinfer" :as parinfer]))
-
-(defn infer-parens
-  [code]
-  (some-> (parinfer/indentMode code #js {:partialResult true})
-          (js->clj :keywordize-keys true)))
+  (:require [calva-backseat-driver.integrations.parinfer :as parinfer]))
 
 (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 (infer-parens text)]
+    (let [result (parinfer/infer-brackets text)]
       (clj->js
        (if (:success result)
          (let [new-text (:text result)]

src/calva_backseat_driver/integrations/calva/editor.cljs

@@ -174,37 +174,31 @@
                      :file-context file-context})
 
                   ;; Validation done. Proceed with form editing
-                  (p/let [balance-result (some-> (parinfer/infer-brackets new-form)
-                                                 (js->clj :keywordize-keys true))
-                          form-data (get-ranges-form-data-by-line file-path final-line-number ranges-fn-key)
-                          diagnostics-before-edit (get-diagnostics-for-file file-path)]
-                    (if (:success balance-result)
-                      (p/let [balanced-form (:text balance-result)
-                              balancing-occurred? (not= new-form balanced-form)
-                              text (if (= :insertionPoint ranges-fn-key)
-                                     (str (string/trim balanced-form) "\n\n")
-                                     balanced-form)
-                              edit-result (edit-replace-range file-path
-                                                              (first (:ranges-object form-data))
-                                                              text)
-                              _ (p/delay 1000) ;; TODO: Consider subscribing on diagnistics changes instead
-                              diagnostics-after-edit (get-diagnostics-for-file file-path)]
-                        (if edit-result
-                          (do
-                            (.save vscode-document)
-                            (cond-> {:success true
-                                     :diagnostics-before-edit diagnostics-before-edit
-                                     :diagnostics-after-edit diagnostics-after-edit}
-                              (not= final-line-number line-number)
-                              (assoc :actual-line-used final-line-number)
-
-                              balancing-occurred?
-                              (merge
-                               {:balancing-note "The code provided for editing had unbalanced brackets. The code was automatically balanced before editing. Use the code in the `balanced-code` to correct your code on record."
-                                :balanced-code balanced-form})))
-                          {:success false
-                           :diagnostics-before-edit diagnostics-before-edit}))
-                      balance-result))))))
+                  (let [validation-result (parinfer/validate-brackets new-form)]
+                    (if-not (:valid? validation-result)
+                      ;; REFUSE to edit - return validation failure
+                      (p/resolved (assoc validation-result :success false))
+                      ;; Valid brackets - proceed with edit
+                      (p/let [form-data (get-ranges-form-data-by-line file-path final-line-number ranges-fn-key)
+                              diagnostics-before-edit (get-diagnostics-for-file file-path)]
+                        (p/let [text (if (= :insertionPoint ranges-fn-key)
+                                       (str (string/trim new-form) "\n\n")
+                                       new-form)
+                                edit-result (edit-replace-range file-path
+                                                                (first (:ranges-object form-data))
+                                                                text)
+                                _ (p/delay 1000)
+                                diagnostics-after-edit (get-diagnostics-for-file file-path)]
+                          (if edit-result
+                            (do
+                              (.save vscode-document)
+                              (cond-> {:success true
+                                       :diagnostics-before-edit diagnostics-before-edit
+                                       :diagnostics-after-edit diagnostics-after-edit}
+                                (not= final-line-number line-number)
+                                (assoc :actual-line-used final-line-number)))
+                            {:success false
+                             :diagnostics-before-edit diagnostics-before-edit})))))))))
           (p/catch (fn [e]
                      {:success false
                       :error (.-message e)})))
@@ -265,75 +259,68 @@
 (defn structural-create-file+
   "Create a new Clojure file with exact content using vscode/workspace.fs API"
   [file-path content]
-  (let [inferred (parinfer/infer-brackets content)
-        infer-result (when inferred (js->clj inferred :keywordize-keys true))
-        balanced-content (if (:success infer-result)
-                           (:text infer-result)
-                           content)
-        balancing-occurred? (not= content balanced-content)]
-    (p/let [uri (vscode/Uri.file file-path)
-            normalized-content (normalize-file-content balanced-content)
-            content-bytes (.encode (js/TextEncoder.) normalized-content)
-            directory-path (get-directory-from-path file-path)
-            directory-uri (vscode/Uri.file directory-path)]
-      (p/-> (vscode/workspace.fs.createDirectory directory-uri)
-            (p/catch (fn [_] nil)) ;; Ignore if directory already exists
-            (p/then (fn [_]
-                      (vscode/workspace.fs.writeFile uri content-bytes)))
-            (p/then (fn [_]
-                      (p/let [_ (p/delay 1000) ;; Wait for diagnostics to update
-                              diagnostics-after-edit (get-diagnostics-for-file file-path)]
-                        (cond-> {:success true
-                                 :file-path file-path
-                                 :message "File created successfully"
-                                 :diagnostics-after-edit diagnostics-after-edit}
-                          balancing-occurred?
-                          (merge {:balancing-note "The code provided had unbalanced brackets. The code was automatically balanced before creating file."
-                                  :balanced-code balanced-content})))))
-            (p/catch (fn [error]
-                       {:success false
-                        :error (.-message error)
-                        :file-path file-path}))))))
+  (let [validation-result (parinfer/validate-brackets content)]
+    (if-not (:valid? validation-result)
+      ;; REFUSE to create - return validation failure
+      (p/resolved (assoc validation-result
+                         :file-path file-path))
+      ;; Valid brackets - proceed with file creation
+      (p/let [uri (vscode/Uri.file file-path)
+              normalized-content (normalize-file-content content)
+              content-bytes (.encode (js/TextEncoder.) normalized-content)
+              directory-path (get-directory-from-path file-path)
+              directory-uri (vscode/Uri.file directory-path)]
+        (p/-> (vscode/workspace.fs.createDirectory directory-uri)
+              (p/catch (fn [_] nil))
+              (p/then (fn [_]
+                        (vscode/workspace.fs.writeFile uri content-bytes)))
+              (p/then (fn [_]
+                        (p/let [_ (p/delay 1000)
+                                diagnostics-after-edit (get-diagnostics-for-file file-path)]
+                          {:success true
+                           :file-path file-path
+                           :message "File created successfully"
+                           :diagnostics-after-edit diagnostics-after-edit})))
+              (p/catch (fn [error]
+                         {:success false
+                          :error (.-message error)
+                          :file-path file-path})))))))
 
 (defn append-code+
   "Append a top-level form to the end of a file at guaranteed top level"
   [file-path code]
-  (let [inferred (parinfer/infer-brackets code)
-        infer-result (when inferred (js->clj inferred :keywordize-keys true))
-        balanced-form (if (:success infer-result)
-                        (:text infer-result)
-                        code)
-        balancing-occurred? (not= code balanced-form)]
-    (-> (p/let [uri (vscode/Uri.file file-path)
-                ^js vscode-document (vscode/workspace.openTextDocument uri)
-                diagnostics-before-edit (get-diagnostics-for-file file-path)
-                last-line-number (.-lineCount vscode-document)
-                end-position (vscode/Position. last-line-number 0)
-                last-line-text (if (pos? last-line-number)
-                                 (.-text (.lineAt vscode-document (dec last-line-number)))
-                                 "")
-                needs-spacing? (and (pos? last-line-number)
-                                    (not (string/blank? last-line-text)))
-                spacing (if needs-spacing? "\n\n" "\n")
-                append-text (str spacing (string/trim balanced-form) "\n")
-                edit (vscode/TextEdit.insert end-position append-text)
-                workspace-edit (vscode/WorkspaceEdit.)
-                _ (.set workspace-edit uri #js [edit])
-                edit-result (vscode/workspace.applyEdit workspace-edit)
-                _ (p/delay 1000) ;; Wait for diagnostics to update
-                diagnostics-after-edit (get-diagnostics-for-file file-path)]
-          (.save vscode-document)
-          (if edit-result
-            (cond-> {:success true
-                     :appended-at-end true
-                     :diagnostics-before-edit diagnostics-before-edit
-                     :diagnostics-after-edit diagnostics-after-edit}
-              balancing-occurred?
-              (merge {:balancing-note "The code provided had unbalanced brackets. The code was automatically balanced before appending."
-                      :balanced-code balanced-form}))
-            {:success false
-             :diagnostics-before-edit diagnostics-before-edit
-             :error "Failed to apply workspace edit"}))
-        (p/catch (fn [error]
-                   {:success false
-                    :error (.-message error)})))))
+  (let [validation-result (parinfer/validate-brackets code)]
+    (if-not (:valid? validation-result)
+      ;; REFUSE to append - return validation failure
+      (p/resolved validation-result)
+      ;; Valid brackets - proceed with append
+      (-> (p/let [uri (vscode/Uri.file file-path)
+                  ^js vscode-document (vscode/workspace.openTextDocument uri)
+                  diagnostics-before-edit (get-diagnostics-for-file file-path)
+                  last-line-number (.-lineCount vscode-document)
+                  end-position (vscode/Position. last-line-number 0)
+                  last-line-text (if (pos? last-line-number)
+                                   (.-text (.lineAt vscode-document (dec last-line-number)))
+                                   "")
+                  needs-spacing? (and (pos? last-line-number)
+                                      (not (string/blank? last-line-text)))
+                  spacing (if needs-spacing? "\n\n" "\n")
+                  append-text (str spacing (string/trim code) "\n")
+                  edit (vscode/TextEdit.insert end-position append-text)
+                  workspace-edit (vscode/WorkspaceEdit.)
+                  _ (.set workspace-edit uri #js [edit])
+                  edit-result (vscode/workspace.applyEdit workspace-edit)
+                  _ (p/delay 1000)
+                  diagnostics-after-edit (get-diagnostics-for-file file-path)]
+            (.save vscode-document)
+            (if edit-result
+              {:success true
+               :appended-at-end true
+               :diagnostics-before-edit diagnostics-before-edit
+               :diagnostics-after-edit diagnostics-after-edit}
+              {:success false
+               :diagnostics-before-edit diagnostics-before-edit
+               :error "Failed to apply workspace edit"}))
+          (p/catch (fn [error]
+                     {:success false
+                      :error (.-message error)}))))))

src/calva_backseat_driver/integrations/calva/features.cljs

@@ -1,10 +1,10 @@
 (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]))
+   [promesa.core :as p]
+   [calva-backseat-driver.integrations.parinfer :as parinfer]))
 
 (def ^:private no-ns-eval-note
   "When evaluating without providing a namespace argument the evaluation is performed in the `user` namespace. Most often this is not what you want, and instead you should be evaluating providing the namespace argument. If it is the first time you are using a namespace, evaluate its ns-form first.")
@@ -22,46 +22,40 @@
    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]}]
-  (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))))
+  (let [{:keys [valid? balanced-code]
+         :as validation} (parinfer/validate-brackets code)]
+    (when-not valid?
+      (dispatch! [[:app/ax.log :debug "[Server] Code was unbalanced:" code "balanced-code:" balanced-code]]))
+    (if-not valid?
+      (p/resolved validation)
+      (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)))))
 
 (defn get-clojuredocs+ [{:ex/keys [dispatch!]
                          :calva/keys [clojure-symbol]}]