Remove unused code from paren-utils and mcp-log-client

- Remove unused functions from paren_utils: tokenize-code, fix-parens, repair-parens, code-has-delimiter-errors?
- Keep only parinfer-repair which is actively used
- Delete completely unused mcp-log-client namespace
- Remove dead paren-utils import from unified_clojure_edit/pipeline

Author: Bruce Hauman

src/clojure_mcp/sexp/paren_utils.clj

@@ -1,103 +1,10 @@
 (ns clojure-mcp.sexp.paren-utils
   (:require
-   [clojure-mcp.delimiter :as delimiter]
-   [rewrite-clj.parser :as parser]
-   [rewrite-clj.node :as node]
-   [clojure.string :as string])
+   [clojure-mcp.delimiter :as delimiter])
   (:import [com.oakmac.parinfer Parinfer]))
 
-;; Tokenizer that breaks code into expressions and delimiter tokens
-(defn tokenize-code
-  "Tokenize Clojure code into valid expressions and individual tokens.
-   Uses parse-string to extract complete valid expressions."
-  [code-str]
-  (loop [remaining code-str
-         tokens []]
-    (if (string/blank? remaining)
-      tokens
-      (let [result
-            (try
-              (let [expr (parser/parse-string remaining)
-                    expr-str (node/string expr)]
-                {:success true
-                 :expr-str expr-str
-                 :token {:type :expression, :value expr-str}})
-              (catch Exception _
-                (let [first-char (first remaining)
-                      delimiters #{\( \) \[ \] \{ \}}]
-                  {:success false
-                   :token (if (contains? delimiters first-char)
-                            {:type :delimiter, :value first-char}
-                            {:type :invalid, :value (str first-char)})})))]
-        (if (:success result)
-          (recur (subs remaining (count (:expr-str result)))
-                 (conj tokens (:token result)))
-          (recur (subs remaining 1)
-                 (conj tokens (:token result))))))))
-
-(def delim-map {\( \) \[ \] \{ \}})
-
-(def open-delim #{\( \[ \{})
-
-(defn invert-delim [{:keys [type value] :as x}]
-  {:pre [(= :delimiter type) (open-delim value)]}
-  (update x :value delim-map))
-
-(defn open-delim? [{:keys [type value] :as x}]
-  (when (= :delimiter type)
-    (open-delim value)))
-
-(defn fix-parens
-  ([tokens]
-   (fix-parens 0 nil [] [] tokens))
-  ([extra-closes open-stack bads accum [tk & xs :as tokens]]
-   (cond
-     (and (empty? tokens) (empty? bads))
-     {:success true
-      :removed-closing-delims extra-closes
-      :added-closing-delims (count open-stack)
-      :result (concat accum (map invert-delim open-stack))}
-
-     (empty? tokens)
-     {:success false
-      :extra-closes extra-closes
-      :bad-code bads
-      :partial-result accum}
-
-     (open-delim? tk)
-     (fix-parens extra-closes (cons tk open-stack) bads (conj accum tk) xs)
-
-     (= :delimiter (:type tk)) ;; ignore closing delim
-     (fix-parens (inc extra-closes) open-stack bads accum xs)
-
-     (= :expression (:type tk))
-     (fix-parens extra-closes open-stack bads (conj accum tk) xs)
-
-     :else
-     (fix-parens extra-closes open-stack (conj bads tk) accum xs))))
-
-(defn repair-parens [code-str]
-  (let [{:keys [success result removed-closing-delims added-closing-delims]}
-        (fix-parens (tokenize-code code-str))]
-    (when success
-      {:repaired? true
-       :form (string/join (map :value result))
-       :message
-       (cond-> nil
-         (> removed-closing-delims 0)
-         (str (format "Removed %s extra closing parentheses. " removed-closing-delims))
-         (> added-closing-delims 0)
-         (str (format "Added %s missing closing parentheses" added-closing-delims)))})))
-
 (defn parinfer-repair [code-str]
   (let [res (Parinfer/indentMode code-str nil nil nil false)]
     (when (and (.success res)
                (not (delimiter/delimiter-error? (.text res))))
-      (.text res))))
-
-(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]
-  (delimiter/delimiter-error? code-str))
+      (.text res))))

src/clojure_mcp/tools/unified_clojure_edit/pipeline.clj

@@ -8,7 +8,6 @@
    [clojure-mcp.tools.unified-read-file.file-timestamps :as file-timestamps]
    [rewrite-clj.zip :as z]
    [rewrite-clj.parser :as p]
-   [clojure-mcp.sexp.paren-utils :as paren-utils]
    [clojure.spec.alpha :as s]
    [clojure.string :as str]
    [clojure.java.io :as io]))