Add prompt-cli for AI-powered command-line interaction

Introduces a new CLI that enables users to interact with AI agents
that have access to all Clojure MCP tools via nREPL.

Key features:
- Command-line interface for sending prompts to AI agents
- Automatic nREPL connection and environment detection
- Support for custom agent configurations and models
- Access to all MCP tools (file operations, REPL eval, code search)
- Project context loading (code index and summaries)
- Configurable via .clojure-mcp/config.edn

Components added:
- prompt_cli.clj: Main CLI implementation with arg parsing
- chat_listener.clj: Streaming chat listener for agent responses
- message_conv.clj: Message conversion utilities
- tool_format.clj: Custom formatting for tool requests/results
- Comprehensive documentation in doc/prompt-cli.md

Usage: clojure -M:prompt-cli -p "Your prompt here"

Author: Bruce Hauman

deps.edn

@@ -4,6 +4,7 @@
         nrepl/nrepl {:mvn/version "1.3.1"}
         org.clojure/tools.logging {:mvn/version "1.3.0"}
         org.clojure/tools.cli {:mvn/version "1.1.230"}
+        org.clj-commons/pretty {:mvn/version "3.6.7"}
 
         ;; for prompt templating
         pogonos/pogonos {:mvn/version "0.2.1"}
@@ -69,6 +70,10 @@
    :exec-args {:port 7888 :shadow-build "app" :shadow-port 7889}}
 
   ;; below are dev set ups that need a logback.xml file
+  :prompt-cli
+  {:extra-deps {org.slf4j/slf4j-nop {:mvn/version "2.0.16"}}
+   :main-opts ["-m" "clojure-mcp.prompt-cli"]}
+
   :dev-mcp
   {:extra-deps {ch.qos.logback/logback-classic {:mvn/version "1.4.14"}}
    :extra-paths ["dev" "test"]

doc/prompt-cli.md

@@ -0,0 +1,119 @@
+# Clojure MCP Prompt CLI
+
+A command-line interface for interacting with an AI agent that has access to all Clojure MCP tools.
+
+## Prerequisites
+
+- A running nREPL server (default port 7888, configurable)
+- Configured API keys for the chosen model (Anthropic, OpenAI, etc.)
+
+## Usage
+
+Start your nREPL server:
+```bash
+clojure -M:nrepl
+```
+
+In another terminal, run the CLI:
+```bash
+clojure -M:prompt-cli -p "Your prompt here"
+```
+
+## Options
+
+- `-p, --prompt PROMPT` - The prompt to send to the agent (required)
+- `-m, --model MODEL` - Override the default model (e.g., `:openai/gpt-4`, `:anthropic/claude-3-5-sonnet`)
+- `-c, --config CONFIG` - Path to a custom agent configuration file (optional)
+- `-d, --dir DIRECTORY` - Working directory (defaults to REPL's working directory)
+- `-P, --port PORT` - nREPL server port (default: 7888)
+- `-h, --help` - Show help message
+
+## Examples
+
+Basic usage with default model:
+```bash
+clojure -M:prompt-cli -p "What namespaces are available?"
+```
+
+Use a specific model:
+```bash
+clojure -M:prompt-cli -p "Evaluate (+ 1 2)" -m :openai/gpt-4
+```
+
+Create code:
+```bash
+clojure -M:prompt-cli -p "Create a fibonacci function"
+```
+
+Use a custom agent configuration:
+```bash
+clojure -M:prompt-cli -p "Analyze this project" -c my-custom-agent.edn
+```
+
+Connect to a different nREPL port:
+```bash
+clojure -M:prompt-cli -p "Run tests" -P 8888
+```
+
+Specify a working directory:
+```bash
+clojure -M:prompt-cli -p "List files" -d /path/to/project
+```
+
+## Configuration
+
+The CLI properly initializes the nREPL connection with:
+- Automatic detection of the working directory from the REPL
+- Loading of `.clojure-mcp/config.edn` from the working directory
+- Environment detection and initialization (Clojure, ClojureScript, etc.)
+- Loading of REPL helper functions
+
+## Default Agent Configuration
+
+By default, the CLI uses the `parent-agent-config` which includes:
+- The Clojure REPL system prompt
+- Access to all available tools
+- Project context (code index and summary)
+- Stateless memory (each invocation is independent)
+
+## Custom Agent Configuration
+
+You can create a custom agent configuration file in EDN format:
+
+```clojure
+{:id :my-agent
+ :name "my_agent"
+ :description "My custom agent"
+ :system-message "Your system prompt here..."
+ :context true  ; Include project context
+ :enable-tools [:read_file :clojure_eval :grep]  ; Specific tools or [:all]
+ :memory-size 100  ; Or false for stateless
+ :model :anthropic/claude-3-5-sonnet-20241022}
+```
+
+## Environment Variables
+
+Set `DEBUG=1` to see stack traces on errors:
+```bash
+DEBUG=1 clojure -M:prompt-cli -p "Your prompt"
+```
+
+## Model Configuration
+
+Models can be configured in `.clojure-mcp/config.edn`:
+```clojure
+{:models {:openai/my-gpt4 {:model-name "gpt-4"
+                            :temperature 0.3
+                            :api-key [:env "OPENAI_API_KEY"]}}}
+```
+
+Then use with:
+```bash
+clojure -M:prompt-cli -p "Your prompt" -m :openai/my-gpt4
+```
+
+## Tool Configuration
+
+The agent has access to all tools by default, which are filtered based on the project's `.clojure-mcp/config.edn` settings:
+- `enable-tools` and `disable-tools` settings are respected
+- Tool-specific configurations from `tools-config` are applied

resources/configs/example-prompt-cli-agent.edn

@@ -0,0 +1,32 @@
+;; Example custom agent configuration for prompt-cli
+;; Save this as custom-agent.edn and use with:
+;; clojure -M:prompt-cli -p "Your prompt" -c custom-agent.edn
+
+{:id :custom-agent
+ :name "custom_agent"
+ :description "Custom agent with limited tools for focused tasks"
+
+ ;; System message can be a string or a path to a resource file
+ :system-message "You are a helpful Clojure assistant focused on code analysis.
+Focus on understanding and explaining code rather than making changes.
+Be concise and clear in your explanations."
+
+ ;; Context controls whether to include project summary and code index
+ :context false ; Set to true to include project context
+
+ ;; Specify which tools the agent can use
+ ;; Use [:all] for all tools, or list specific tool IDs
+ :enable-tools [:read_file
+                :grep
+                :glob_files
+                :clojure_inspect_project
+                :think]
+
+ ;; Memory configuration
+ ;; false = stateless (each invocation is independent)
+ ;; number = conversation window size
+ :memory-size false
+
+ ;; Optional: specify a model (can be overridden with -m flag)
+ ;; :model :anthropic/claude-3-5-sonnet-20241022
+ }

src/clojure_mcp/agent/langchain/chat_listener.clj

@@ -0,0 +1,174 @@
+(ns clojure-mcp.agent.langchain.chat-listener
+  "Creates ChatModelListener instances from Clojure functions that work with EDN data"
+  (:require
+   [clojure-mcp.agent.langchain.message-conv :as msg-conv]
+   [clojure.tools.logging :as log])
+  (:import
+   [dev.langchain4j.model.chat.listener
+    ChatModelListener
+    ChatModelRequestContext
+    ChatModelResponseContext
+    ChatModelErrorContext]
+   [dev.langchain4j.model.chat.request
+    ChatRequestParameters]
+   [dev.langchain4j.model.chat.response
+    ChatResponseMetadata]
+   [dev.langchain4j.model.output
+    TokenUsage]))
+
+(defn- chat-request-parameters->edn
+  "Convert ChatRequestParameters to EDN"
+  [^ChatRequestParameters params]
+  (when params
+    {:model-name (.modelName params)
+     :temperature (.temperature params)
+     :top-p (.topP params)
+     :top-k (.topK params)
+     :frequency-penalty (.frequencyPenalty params)
+     :presence-penalty (.presencePenalty params)
+     :max-output-tokens (.maxOutputTokens params)
+     :stop-sequences (some-> (.stopSequences params) vec)
+     :tool-specifications (some-> (.toolSpecifications params) vec)
+     :tool-choice (.toolChoice params)
+     :response-format (.responseFormat params)}))
+
+(defn- token-usage->edn
+  "Convert TokenUsage to EDN"
+  [^TokenUsage usage]
+  (when usage
+    {:input-token-count (.inputTokenCount usage)
+     :output-token-count (.outputTokenCount usage)
+     :total-token-count (.totalTokenCount usage)}))
+
+(defn- chat-response-metadata->edn
+  "Convert ChatResponseMetadata to EDN"
+  [^ChatResponseMetadata metadata]
+  (when metadata
+    {:id (.id metadata)
+     :model-name (.modelName metadata)
+     :finish-reason (some-> (.finishReason metadata) str)
+     :token-usage (token-usage->edn (.tokenUsage metadata))}))
+
+(defn- chat-request-context->edn
+  "Convert ChatModelRequestContext to EDN"
+  [^ChatModelRequestContext ctx]
+  (let [chat-request (.chatRequest ctx)]
+    {:messages (-> (.messages chat-request)
+                   msg-conv/messages->edn
+                   msg-conv/parse-messages-tool-arguments)
+     :parameters (chat-request-parameters->edn (.parameters chat-request))
+     :model-provider (str (.modelProvider ctx))
+     :attributes (into {} (.attributes ctx))
+     :ctx ctx}))
+
+(defn- chat-response-context->edn
+  "Convert ChatModelResponseContext to EDN"
+  [^ChatModelResponseContext ctx]
+  (let [chat-response (.chatResponse ctx)
+        chat-request (.chatRequest ctx)]
+    {:ai-message (-> (.aiMessage chat-response)
+                     msg-conv/message->edn
+                     msg-conv/parse-tool-arguments)
+     :metadata (chat-response-metadata->edn (.metadata chat-response))
+     :request {:messages (msg-conv/messages->edn (.messages chat-request))
+               :parameters (chat-request-parameters->edn (.parameters chat-request))}
+     :model-provider (str (.modelProvider ctx))
+     :attributes (into {} (.attributes ctx))
+     :ctx ctx}))
+
+(defn- chat-error-context->edn
+  "Convert ChatModelErrorContext to EDN"
+  [^ChatModelErrorContext ctx]
+  (let [chat-request (.chatRequest ctx)]
+    {:error {:message (.getMessage (.error ctx))
+             :class (-> (.error ctx) class .getName)
+             :stack-trace (mapv str (.getStackTrace (.error ctx)))}
+     :request (when chat-request
+                {:messages (msg-conv/messages->edn (.messages chat-request))
+                 :parameters (chat-request-parameters->edn (.parameters chat-request))})
+     :model-provider (str (.modelProvider ctx))
+     :attributes (into {} (.attributes ctx))}))
+
+(defn create-listener
+  "Create a ChatModelListener from Clojure functions.
+   
+   Args:
+   - handlers: Map with optional keys:
+     :on-request - (fn [request-edn] ...) called before sending request
+     :on-response - (fn [response-edn] ...) called after receiving response
+     :on-error - (fn [error-edn] ...) called on errors
+   
+   Each handler receives EDN data converted from the Java objects.
+   
+   Example:
+   (create-listener
+     {:on-request (fn [req] (log/info \"Request:\" req))
+      :on-response (fn [resp] (log/info \"Response:\" resp))
+      :on-error (fn [err] (log/error \"Error:\" err))})"
+  [{:keys [on-request on-response on-error]}]
+  (reify ChatModelListener
+    (onRequest [_ request-context]
+      (when on-request
+        (try
+          (on-request (chat-request-context->edn request-context))
+          (catch Exception e
+            #_(log/error e "Error in on-request handler")))))
+
+    (onResponse [_ response-context]
+      (when on-response
+        (try
+          (on-response (chat-response-context->edn response-context))
+          (catch Exception e
+            #_(log/error e "Error in on-response handler")))))
+
+    (onError [_ error-context]
+      (when on-error
+        (try
+          (on-error (chat-error-context->edn error-context))
+          (catch Exception e
+            #_(log/error e "Error in on-error handler")))))))
+
+(defn logging-listener
+  "Create a listener that logs all events at specified levels.
+   
+   Args (optional):
+   - log-level: Map with :request, :response, :error levels
+                (defaults to :info for all)
+   
+   Example:
+   (logging-listener {:request :debug :response :info :error :error})"
+  ([]
+   (logging-listener {}))
+  ([{:keys [request response error]
+     :or {request :info response :info error :error}}]
+   (create-listener
+    {:on-request (fn [req]
+                   (log/log request "Chat request:" req))
+     :on-response (fn [resp]
+                    (log/log response "Chat response:" resp))
+     :on-error (fn [err]
+                 (log/log error "Chat error:" err))})))
+
+(defn token-tracking-listener
+  "Create a listener that tracks token usage.
+   
+   Args:
+   - usage-atom: Atom to accumulate token usage stats
+   
+   The atom will be updated with:
+   {:total-input-tokens n
+    :total-output-tokens n
+    :total-tokens n
+    :request-count n}"
+  [usage-atom]
+  (create-listener
+   {:on-response
+    (fn [resp]
+      (when-let [usage (get-in resp [:metadata :token-usage])]
+        (swap! usage-atom
+               (fn [stats]
+                 (-> stats
+                     (update :total-input-tokens (fnil + 0) (:input-token-count usage))
+                     (update :total-output-tokens (fnil + 0) (:output-token-count usage))
+                     (update :total-tokens (fnil + 0) (:total-token-count usage))
+                     (update :request-count (fnil inc 0)))))))}))