Remove comment forms from codebase

Remove all (comment ...) forms from the bottom of source files across
25 files. These comment blocks contained REPL testing examples and
development code that are no longer needed.

All tests pass (295 tests, 2085 assertions, 0 failures).

Author: Bruce Hauman

src/clojure_mcp/agent/langchain.clj

@@ -204,30 +204,3 @@
       (cond->
        tools (.tools (convert-tools tools)))
       (.chatMemory memory)))
-
-(comment
-  (def test-tool
-    {:name "hello"
-     :description "says hello"
-     :schema
-     (json/json-str {:type :object
-                     :properties
-                     {:nm {:type :string
-                           :description "Name to say hi to"}}
-                     :required [:nm]})
-     :tool-fn (fn [_ {:keys [nm]} callback]
-                (callback [(str "Hello " nm "!")] false))})
-  #_(create-service AiService {})
-
-  (let [exec (registration-map->tool-executor test-tool)]
-    (.execute exec (-> (ToolExecutionRequest/builder)
-                       (.name "hello")
-                       (.arguments (json/json-str {:nm "Joey"}))
-                       (.build))
-              "asdf")))
-
-;; keep this example
-#_(definterface StreamingAiService
-    (^dev.langchain4j.service.TokenStream chat [^String userMessage])
-    (^dev.langchain4j.service.TokenStream chat [^dev.langchain4j.data.message.UserMessage userMessage]))
-

src/clojure_mcp/agent/langchain/schema.clj

@@ -94,62 +94,3 @@
     (doseq [[nm edn-schema] properties]
       (.addProperty obj-build (name nm) (edn->sch edn-schema)))
     (.build obj-build)))
-
-(comment
-  (edn->sch {:type :string
-             :description "Hello"})
-  (edn->sch {:type :integer
-             :description "Hello"})
-  (edn->sch {:type :number
-             :description "Hello"})
-  (edn->sch {:type :boolean
-             :description "Hello"})
-
-  (edn->sch {:enum ["a"]})
-
-  ;; Mixed types example
-  (edn->sch {:type ["string" "number"]
-             :description "Can be string or number"})
-
-  (edn->sch {:type :array
-             :items {:type :integer
-                     :description "Hello"}})
-
-  ;; Array with mixed types
-  (edn->sch {:type :array
-             :items {:type ["string" "number"]}})
-
-  ;; Complete example: Creating a ToolSpecification
-  (import '[dev.langchain4j.agent.tool ToolSpecification])
-
-  (let [schema {:type :object
-                :properties {:op {:enum ["set_path" "get_path" "delete_path" "inspect"]}
-                             :path {:type :array
-                                    :items {:type ["string" "number"]}}
-                             :value {:type ["object" "array" "string" "number" "boolean"]}
-                             :explanation {:type :string}}
-                :required [:op :explanation]}
-        params (edn->sch schema)]
-    (-> (ToolSpecification/builder)
-        (.name "scratch_pad")
-        (.description "Persistent data storage")
-        (.parameters params)
-        .build))
-
-  (edn->sch {:type :object
-             :description "HOWDy"
-             :properties {:name {:type :string
-                                 :description "The name"}
-                          :path {:type :array
-                                 :items {:type ["string" "number"]
-                                         :description "Can be string or number key"}}
-                          :value {:type ["object" "array" "string" "number" "boolean" "null"]
-                                  :description "Any JSON value"}
-                          :edits {:type :array
-                                  :items {:type :object
-                                          :properties {:old {:type :string
-                                                             :description "The name"}
-                                                       :new {:type :string
-                                                             :description "The name"}}
-                                          :required [:old :new]}}}}))
-

src/clojure_mcp/dialects.clj

@@ -128,13 +128,3 @@
       :else :unknown)))
 
 ;; Future dialect support placeholders
-(comment
-  ;; ClojureScript on Node
-  (defmethod fetch-project-directory-exp :cljs-node
-    [_]
-    "js/process.cwd()")
-
-  ;; Jank might have C++ interop
-  (defmethod fetch-project-directory-exp :jank
-    [_]
-    "(jank.native/cwd)"))

src/clojure_mcp/file_content.clj

@@ -101,11 +101,3 @@
   (and (map? map)
        (::file-response map)))
 
-(comment
-  (-> "./dev/sponsors.pdf"
-      ->file-response
-      file-response->file-content)
-
-  (should-be-file-response? "./dev/logback.xml")
-
-  (text-media-type? (mime-type (str->nio-path "hello.md"))))

src/clojure_mcp/nrepl.clj

@@ -284,11 +284,3 @@
             :repl/error (atom nil)
             ::state state))))
 
-(comment
-
-  (def serv (create {:port 54171}))
-  (start-polling serv)
-  (stop-polling serv)
-
-  (tool-eval-code serv "(+ 1 2)"))
-

src/clojure_mcp/sexp/match.clj

@@ -77,27 +77,4 @@
 
 (defn find-match [pattern-str code-str]
   (find-match* (z/sexpr (z/of-string pattern-str))
-               (z/of-string code-str)))
-
-(comment
-
-  ;; Define a multimethod for calculating area
-  (defmulti area :type)
-
-  (defmethod area :circle
-    [shape]
-    (let [{:keys [radius]} shape]
-      ;; Using exact Math/PI constant instead of hardcoded value
-      (* Math/PI radius radius))))
-
-#_(z/string (find-match "(defmethod area :circle [shape]
-   (let [{:keys [radius]} shape]
-;; Using exact Math/PI constant instead of hardcoded value
-(* _* radius radius )
-  ))" (slurp "src/clojure_mcp/sexp/match.clj")))
-
-;; Example tests
-#_(match-sexpr '(+ _* radius radius) '(+ 3 radius radius))
-#_(match-sexpr '(defn calc [x y] _* (if (> x 10) x y))
-               '(defn calc [x y] (println "calculating") (if (> x 10) x y)))
-#_(match-sexpr '(* Math/PI radius radius) '(* Math/PI radius radius)) ;; Regular * operators match normally
+               (z/of-string code-str)))

src/clojure_mcp/sexp/paren_utils.clj

@@ -100,42 +100,4 @@
    (unbalanced parentheses, brackets, braces, or string quotes).
    Returns false otherwise."
   [code-str]
-  (delimiter/delimiter-error? code-str))
-
-(comment
-  (def code1 "(defn hello [name] (str \"Hello\" name)))")
-  (repair-parens code1)
-  (tokenize-code code1)
-  (fix-parens (tokenize-code code1))
-  (repair-parens code1)
-
-  ;; => {:repaired? true, :form "(defn hello [name] (str \"Hello\" name))", :message "Removed 1 extra closing parentheses"}
-
-  ;; Test with missing closing paren
-  (def code2 "(defn hello [name] (str \"Hello\" name)")
-  (tokenize-code code2)
-  (fix-parens (tokenize-code code2))
-  (repair-parens code2)
-  (parinfer-repair code2)
-  ;; => {:repaired? true, :form "(defn hello [name] (str \"Hello\" name))", :message "Added 1 missing closing parentheses"}
-
-  ;; Test with complex case - both extra and missing parens
-  (def code3 "(defn hello [name]
-  (str \"Hello\" name))) 
-(defn world [] 
-  (println \"World\")")
-  (tokenize-code code3)
-  (fix-parens (tokenize-code code3))
-  (repair-parens code3)
-  (repair-parens code3)
-  ;; => {:repaired? true, :form "(defn hello [name] (str \"Hello\" name)) (defn world [] (println \"World\"))", 
-  ;;     :message "Removed 1 extra closing parentheses and added 1 missing closing parentheses"}
-
-  ;; Test with parens in string
-  (def code4 "(println \"Hello (world)\")")
-  (tokenize-code code4)
-  (fix-parens (tokenize-code code4))
-  (repair-parens code4)
-
-  ;; => {:repaired? false, :form "(println \"Hello (world)\")", :message "No repair needed"}
-  )
+  (delimiter/delimiter-error? code-str))

src/clojure_mcp/tool_system.clj

@@ -121,44 +121,3 @@
                                                [(:error-details data)])))]
                     (callback error-msgs true)))))})
 
-(comment
-  ;; === Simple testing for the tool-system ===
-
-  ;; Set up nREPL client for testing
-  (require '[clojure-mcp.nrepl :as nrepl])
-  (require '[clojure-mcp.tools.eval.tool :as eval-tool])
-
-  (def client-atom (atom (nrepl/create {:port 7888})))
-  (nrepl/start-polling @client-atom)
-
-  ;; Create a tool instance 
-  (def eval-tool-instance (eval-tool/create-eval-tool client-atom))
-
-  ;; Generate the registration map with our debug println statements
-  (def reg-map (registration-map eval-tool-instance))
-
-  ;; Get the tool-fn
-  (def tool-fn (:tool-fn reg-map))
-
-  ;; Test it directly with string keys (like it would receive from MCP) 
-  (tool-fn nil {"code" "(+ 1 2)"}
-           (fn [result error] (println "RESULT:" result "ERROR:" error)))
-
-  ;; See what happens with malformed code
-  (tool-fn nil {"code" "(+ 1"}
-           (fn [result error] (println "ERROR RESULT:" result "ERROR FLAG:" error)))
-
-  ;; Helper function to make testing easier
-  (defn test-eval [code]
-    (let [p (promise)]
-      (tool-fn nil {"code" code}
-               (fn [result error]
-                 (deliver p {:result result :error? error})))
-      @p))
-
-  (test-eval "(+ 1 2)")
-  (test-eval "(println \"hello\")\n(+ 3 4)")
-  (test-eval "(/ 1 0)") ;; Should trigger error handling
-
-  ;; Clean up
-  (nrepl/stop-polling @client-atom))

src/clojure_mcp/tools/bash/core.clj

@@ -224,32 +224,3 @@ EDN parsing failed: %s\nRaw result: %s"
                          inner-value)
             :error "bash-command-failed"}))))))
 
-(comment
-  (require '[clojure-mcp.config :as config])
-
-  (def client-atom (atom (clojure-mcp.nrepl/create {:port 7888})))
-  #_(config/set-config! client-atom :nrepl-user-dir (System/getProperty "user.dir"))
-  #_(config/set-config! client-atom :allowed-directories [(System/getProperty "user.dir")])
-  (clojure-mcp.nrepl/start-polling @client-atom)
-
-  (execute-bash-command-nrepl client-atom {:command "curl -s https://rigsomelight.com"
-                                           :working-directory (System/getProperty "user.dir")})
-
-  (->> (eval-core/evaluate-code
-        @client-atom
-        {:code (generate-shell-eval-code
-                "clojure -X:test"
-                (System/getProperty "user.dir")
-                100000)
-         :timeout-ms 100000})
-       :outputs
-       (into {})
-       :value
-       edn/read-string)
-
-  (clojure-mcp.nrepl/stop-polling @client-atom))
-
-#_(execute-bash-command
-   {:command "ls -al"
-    :working-directory (System/getProperty "user.dir") :timeout-ms nil})
-

src/clojure_mcp/tools/bash/tool.clj

@@ -160,9 +160,3 @@ in the response to determine command success.")
   [nrepl-client-atom]
   (tool-system/registration-map (create-bash-tool nrepl-client-atom)))
 
-(comment
-  (def test-tool
-    (tool-system/registration-map (create-bash-tool (atom {::config/config {:allowed-directories [(System/getProperty "user.dir")]
-                                                                            :nrepl-user-dir (System/getProperty "user.dir")}}))))
-
-  ((:tool-fn test-tool) nil {"command" "ls -al"} (fn [a b] [a b])))