Merge pull request #155 from williamp44/fix/cljfmt-partial-formatting

feat: add cljfmt :partial mode to format only replaced forms (#154)

Author: bhauman

CONFIG.md

@@ -14,15 +14,17 @@ These basic settings affect how clojure-mcp interacts with your local system.
 Controls which directories the MCP tools can access for security. Paths can be relative (resolved from project root) or absolute.
 
 ### `:cljfmt`
-Boolean flag to enable/disable cljfmt formatting in editing pipelines (default: `true`). When disabled, file edits preserve the original formatting without applying cljfmt.
+Controls cljfmt formatting behavior in editing pipelines (default: `true`). Determines whether and how formatting is applied when editing Clojure forms.
 
 **Available values:**
-- `true` (default) - Applies cljfmt formatting to all edited files
-- `false` - Disables formatting, preserving exact whitespace and formatting
+- `true` (default) - Applies cljfmt formatting to the entire file after each edit
+- `:partial` - Formats only the replaced/inserted form in isolation, preserving surrounding formatting
+- `false` - Disables formatting entirely, preserving exact whitespace and formatting
 
 **When to use each setting:**
-- `true` - Best for maintaining consistent code style across your project
-- `false` - Useful when working with files that have specific formatting requirements or when you want to preserve manual formatting
+- `true` - Best for maintaining consistent code style across your project. Note: this reformats the entire file after each edit, which may introduce formatting changes to code you did not intend to modify.
+- `:partial` - Recommended for most workflows. Formats only the form being edited (fixing indentation, spacing, etc.) without touching the rest of the file. Prevents collateral formatting changes to unrelated code.
+- `false` - Useful when working with files that have specific formatting requirements or when you want to preserve manual formatting completely
 
 ### `:write-file-guard`
 Controls the file timestamp tracking behavior (default: `:partial-read`). This setting determines when file editing is allowed based on read operations.

PROJECT_SUMMARY.md

@@ -135,8 +135,9 @@ your-project/
   - `:partial-read` - Both full and collapsed reads update timestamps (default)
   - `:full-read` - Only full reads update timestamps (safest)
   - `false` - Disables timestamp checking entirely
-- `cljfmt`: Boolean flag to enable/disable cljfmt formatting in editing pipelines (default: `true`)
-  - `true` - Applies cljfmt formatting to edited files (default behavior)
+- `cljfmt`: Controls cljfmt formatting in editing pipelines (default: `true`)
+  - `true` - Applies cljfmt formatting to entire file after edits (default behavior)
+  - `:partial` - Formats only the replaced/inserted form, preserving surrounding formatting
   - `false` - Disables formatting, preserving exact whitespace and formatting
 - `bash-over-nrepl`: Boolean flag to control bash command execution mode (default: `true`)
   - `true` - Execute bash commands over nREPL connection (default behavior)

src/clojure_mcp/config.clj

@@ -144,7 +144,9 @@
                   distinct
                   vec))
       (some? (:cljfmt config))
-      (assoc :cljfmt (boolean (:cljfmt config)))
+      (assoc :cljfmt (if (= :partial (:cljfmt config))
+                       :partial
+                       (boolean (:cljfmt config))))
       (some? (:bash-over-nrepl config))
       (assoc :bash-over-nrepl (boolean (:bash-over-nrepl config)))
       (some? (:nrepl-env-type config))
@@ -224,7 +226,12 @@
 (defn get-nrepl-user-dir [nrepl-client-map]
   (get-config nrepl-client-map :nrepl-user-dir))
 
-(defn get-cljfmt [nrepl-client-map]
+(defn get-cljfmt
+  "Returns the cljfmt setting: true (default), false, or :partial.
+   - true: full-file formatting via cljfmt after edits
+   - false: no formatting
+   - :partial: format only the replaced form in isolation, preserving surrounding formatting"
+  [nrepl-client-map]
   (let [value (get-config nrepl-client-map :cljfmt)]
     (if (nil? value)
       true ; Default to true when not specified

src/clojure_mcp/config/schema.clj

@@ -261,7 +261,7 @@
    ;; Core configuration
    [:allowed-directories {:optional true} [:sequential Path]]
    [:write-file-guard {:optional true} [:enum :full-read :partial-read false]]
-   [:cljfmt {:optional true} :boolean]
+   [:cljfmt {:optional true} [:or :boolean [:= :partial]]]
    [:bash-over-nrepl {:optional true} :boolean]
    [:nrepl-env-type {:optional true} [:enum :clj :bb :basilisp :scittle]]
    [:start-nrepl-cmd {:optional true} [:sequential NonBlankString]]

src/clojure_mcp/tools/form_edit/core.clj

@@ -10,7 +10,8 @@
    [rewrite-clj.node :as n]
    [rewrite-clj.parser :as p]
    [rewrite-clj.zip :as z]
-   [clojure-mcp.utils.file :as file-utils]))
+   [clojure-mcp.utils.file :as file-utils]
+   [taoensso.timbre :as log]))
 
 ;; Form identification and location functions
 
@@ -276,6 +277,52 @@
   [source-str formatting-options]
   (fmt/reformat-string source-str formatting-options))
 
+;; Partial formatting helpers
+
+(defn re-indent-to-column
+  "Re-indents a formatted form string so that:
+   - The first line is unchanged (it will be placed at the correct column by rewrite-clj)
+   - Subsequent lines are indented to align with the target column position.
+
+   Arguments:
+   - form-str: The formatted form string (formatted in isolation starting at column 1)
+   - target-col: The 1-based column where the form starts in the file
+
+   Returns:
+   - The re-indented form string"
+  [form-str target-col]
+  (if (<= target-col 1)
+    form-str
+    (let [lines (str/split form-str #"\n" -1)
+          indent-str (apply str (repeat (dec target-col) " "))
+          re-indented (cons (first lines)
+                            (map (fn [line]
+                                   (if (str/blank? line)
+                                     line
+                                     (str indent-str line)))
+                                 (rest lines)))]
+      (str/join "\n" re-indented))))
+
+(defn format-form-in-isolation
+  "Formats a form string in isolation using cljfmt, then re-indents it
+   to match the target column position. This avoids reformatting the
+   entire file when only one form is being replaced.
+
+   Arguments:
+   - form-str: The form source code to format
+   - target-col: The 1-based column where the form starts in the file
+   - formatting-options: cljfmt formatting options
+
+   Returns:
+   - The formatted and re-indented form string, or the original on failure"
+  [form-str target-col formatting-options]
+  (try
+    (let [formatted (fmt/reformat-string form-str formatting-options)]
+      (re-indent-to-column formatted target-col))
+    (catch Exception e
+      (log/debug "Partial formatting failed, using original form:" (.getMessage e))
+      form-str)))
+
 ;; File operations
 
 (defn load-file-content

src/clojure_mcp/tools/form_edit/pipeline.clj

@@ -42,13 +42,16 @@
 
 (s/def ::dry-run (s/nilable #{"diff" "new-source"}))
 
+(s/def ::form-col pos-int?)
+
 (s/def ::context
   (s/keys :req [::file-path]
           :opt [::source ::old-content ::new-source-code ::top-level-def-name
                 ::top-level-def-type ::edit-type ::error ::message
                 ::zloc ::offsets ::lint-result ::docstring
                 ::comment-substring ::new-content ::expand-symbols
-                ::diff ::type ::output-source ::nrepl-client-atom ::dry-run]))
+                ::diff ::type ::output-source ::nrepl-client-atom ::dry-run
+                ::form-col]))
 
 ;; Pipeline helper functions
 
@@ -229,6 +232,43 @@
                      (str error-msg suggestion-msg)
                      error-msg)}))))
 
+(defn capture-form-position
+  "Captures the column position of the found form for partial formatting.
+   Must be called after find-form, before edit-form.
+   Saves ::form-col (1-based column) to the context when position is available.
+   Leaves ::form-col absent when z/position returns nil so downstream code
+   can fall back to full-file formatting rather than mis-indenting.
+
+   Requires ::zloc in the context (pointing to the found form)."
+  [ctx]
+  (let [zloc (::zloc ctx)]
+    (if-let [pos (z/position zloc)]
+      (assoc ctx ::form-col (second pos)) ;; [row col] -> col
+      ctx))) ;; leave ::form-col absent — downstream falls back to full-file formatting
+
+(defn format-new-source-partial
+  "Formats the new source code in isolation when cljfmt is set to :partial
+   and position tracking succeeded (::form-col is present in context).
+   Formats ::new-source-code using cljfmt, then re-indents to match the
+   target column position. This is done BEFORE insertion so the formatted
+   content replaces the old form without touching the rest of the file.
+
+   When ::form-col is absent (position tracking unavailable), passes through
+   unchanged so format-source falls back to full-file formatting.
+
+   Requires ::new-source-code, ::form-col, and ::nrepl-client-atom in context."
+  [ctx]
+  (let [nrepl-client-map (some-> ctx ::nrepl-client-atom deref)
+        cljfmt-setting (config/get-cljfmt nrepl-client-map)]
+    (if (and (= :partial cljfmt-setting) (::form-col ctx))
+      (let [new-source (::new-source-code ctx)
+            target-col (::form-col ctx)
+            formatting-options (core/project-formatting-options nrepl-client-map)
+            formatted (core/format-form-in-isolation new-source target-col formatting-options)]
+        (assoc ctx ::new-source-code formatted))
+      ;; Not :partial mode, or position unavailable — pass through
+      ctx)))
+
 (defn edit-form
   "Edits the form according to the specified edit type.
    Requires ::zloc, ::top-level-def-type, ::top-level-def-name, 
@@ -269,13 +309,25 @@
   "Formats the source code using the formatter.
    If formatting fails but the source is syntactically valid,
    returns the original source unchanged.
-   
+
+   When cljfmt is :partial AND the form was already formatted in isolation
+   (indicated by ::form-col in context), skips whole-file formatting.
+   Otherwise falls back to full-file formatting (e.g., for sexp-edit-pipeline
+   which doesn't do pre-insertion partial formatting).
+
    Requires ::output-source in the context.
    Updates ::output-source with the formatted code (or unchanged if formatting fails)."
   [ctx]
   (let [nrepl-client-map (some-> ctx ::nrepl-client-atom deref)
-        cljfmt-enabled (config/get-cljfmt nrepl-client-map)]
-    (if cljfmt-enabled
+        cljfmt-setting (config/get-cljfmt nrepl-client-map)]
+    (cond
+      ;; :partial mode with pre-formatted form - skip whole-file formatting
+      ;; ::form-col presence means format-new-source-partial already ran
+      (and (= :partial cljfmt-setting) (::form-col ctx))
+      ctx
+
+      ;; true (or :partial without pre-formatting) - full-file formatting
+      cljfmt-setting
       (try
         (let [source (::output-source ctx)
               formatting-options (core/project-formatting-options nrepl-client-map)
@@ -289,7 +341,9 @@
             ;; Only propagate error if we don't have valid source
             {::error true
              ::message (str "Failed to format source: " (.getMessage e))})))
-      ;; If cljfmt is disabled, return ctx unchanged
+
+      ;; false - formatting disabled, return ctx unchanged
+      :else
       ctx)))
 
 (defn determine-file-type
@@ -425,6 +479,8 @@
      enhance-defmethod-name
      parse-source
      find-form
+     capture-form-position
+     format-new-source-partial
      edit-form
      zloc->output-source
      format-source

test/clojure_mcp/config/schema_test.clj

@@ -84,7 +84,14 @@
 
   (testing "Config with all nrepl-env-type values"
     (doseq [env-type [:clj :bb :basilisp :scittle]]
-      (is (schema/valid? {:nrepl-env-type env-type})))))
+      (is (schema/valid? {:nrepl-env-type env-type}))))
+
+  (testing "Config with cljfmt :partial"
+    (is (schema/valid? {:cljfmt :partial})))
+
+  (testing "Config with all cljfmt values"
+    (doseq [v [true false :partial]]
+      (is (schema/valid? {:cljfmt v})))))
 
 ;; ==============================================================================
 ;; Invalid Configuration Tests