Support custom commands via md files

Author: ericdallo

CHANGELOG.md

@@ -2,6 +2,8 @@
 
 ## Unreleased
 
+- Support custom commands via md files in `~/.config/eca/commands/` or `.eca/commands/`.
+
 ## 0.19.0
 
 - Support `claude-opus-4-1` model.

docs/configuration.md

@@ -123,6 +123,39 @@ It's possible to configure ECA to be aware of custom LLM providers if they follo
 
 With that, ECA will include in the known models something like: `my-company/gpt-4.1`, `my-company/deepseek-r1`.
 
+## Custom command prompts
+
+You can configure custom command prompts for project, global or via `commands` config pointing to the path of the commands.
+Prompts can use variables like `$ARGS`, `$ARG1`, `ARG2`, to replace in the prompt during command call.
+
+### Local custom commands
+
+A `.eca/commands` folder from the workspace root containing `.md` files with the custom prompt.
+
+`.eca/commands/check-performance.md`
+```markdown
+Check for performance issues in $ARG1 and optimize if needed.
+```
+
+### Global custom commands
+
+A `$XDG_CONFIG_HOME/eca/commands` or `~/.config/eca/commands` folder containing `.md` files with the custom command prompt.
+
+`~/.config/eca/commands/check-performance.mdc`
+```markdown
+Check for performance issues in $ARG1 and optimize if needed.
+```
+
+### Config
+
+Just add to your config the `commands` pointing to `.md` files that will be searched from the workspace root if not an absolute path:
+
+```javascript
+{
+  "commands": [{"path": "my-custom-prompt.md"}]
+}
+```
+
 ## All configs
 
 ### Schema
@@ -132,6 +165,7 @@ interface Config {
     openaiApiKey?: string;
     anthropicApiKey?: string;
     rules: [{path: string;}];
+    commands: [{path: string;}];
     systemPromptTemplate?: string;
     nativeTools: {
         filesystem: {enabled: boolean};
@@ -181,6 +215,7 @@ interface Config {
   "openaiApiKey" : null,
   "anthropicApiKey" : null,
   "rules" : [],
+  "commands" : [],
   "nativeTools": {"filesystem": {"enabled": true},
                   "shell": {"enabled": true, 
                             "excludeCommands": []}},

docs/features.md

@@ -51,6 +51,10 @@ The built-in commands are:
 `/costs`: shows costs about current session.
 `/repo-map-show`: shows the current repoMap context of the session.
 
+#### Custom commands
+
+It's possible to configure custom command prompts, for more details check [its configuration](./configuration.md#custom-commands)
+
 ##  Completion
 
 Soon

src/eca/config.clj

@@ -19,6 +19,7 @@
   {:openaiApiKey nil
    :anthropicApiKey nil
    :rules []
+   :commands []
    :nativeTools {:filesystem {:enabled true}
                  :shell {:enabled true
                          :excludeCommands []}}

src/eca/features/chat.clj

@@ -3,6 +3,7 @@
    [cheshire.core :as json]
    [clojure.set :as set]
    [clojure.string :as string]
+   [eca.features.commands :as f.commands]
    [eca.features.context :as f.context]
    [eca.features.index :as f.index]
    [eca.features.prompt :as f.prompt]
@@ -12,7 +13,7 @@
    [eca.llm-api :as llm-api]
    [eca.logger :as logger]
    [eca.messenger :as messenger]
-   [eca.shared :as shared :refer [assoc-some multi-str]]))
+   [eca.shared :as shared :refer [assoc-some]]))
 
 (set! *warn-on-reflection* true)
 
@@ -45,23 +46,6 @@
 (defn ^:private tool-name->origin [name all-tools]
   (:origin (first (filter #(= name (:name %)) all-tools))))
 
-(defn ^:private tokens->cost [input-tokens input-cache-creation-tokens input-cache-read-tokens output-tokens model db]
-  (let [normalized-model (if (string/includes? model "/")
-                           (last (string/split model #"/"))
-                           model)
-        {:keys [input-token-cost output-token-cost
-                input-cache-creation-token-cost input-cache-read-token-cost]} (get-in db [:models normalized-model])
-        input-cost (* input-tokens input-token-cost)
-        input-cost (if input-cache-creation-tokens
-                     (+ input-cost (* input-cache-creation-tokens input-cache-creation-token-cost))
-                     input-cost)
-        input-cost (if input-cache-read-tokens
-                     (+ input-cost (* input-cache-read-tokens input-cache-read-token-cost))
-                     input-cost)]
-    (when (and input-token-cost output-token-cost)
-      (format "%.2f" (+ input-cost
-                        (* output-tokens output-token-cost))))))
-
 (defn ^:private usage-msg->usage
   [{:keys [input-tokens output-tokens
            input-cache-creation-tokens input-cache-read-tokens]}
@@ -84,8 +68,8 @@
       (assoc-some {:message-output-tokens output-tokens
                    :message-input-tokens (+ input-tokens message-input-cache-tokens)
                    :session-tokens (+ total-input-tokens total-input-cache-tokens total-output-tokens)}
-                  :message-cost (tokens->cost input-tokens input-cache-creation-tokens input-cache-read-tokens output-tokens model db)
-                  :session-cost (tokens->cost total-input-tokens total-input-cache-creation-tokens total-input-cache-read-tokens total-output-tokens model db)))))
+                  :message-cost (shared/tokens->cost input-tokens input-cache-creation-tokens input-cache-read-tokens output-tokens model db)
+                  :session-cost (shared/tokens->cost total-input-tokens total-input-cache-creation-tokens total-input-cache-read-tokens total-output-tokens model db)))))
 
 (defn ^:private message->decision [message]
   (let [slash? (string/starts-with? message "/")
@@ -98,13 +82,14 @@
         {:type :mcp-prompt
          :server server
          :prompt (second (string/split (first parts) #":"))
-         :args (if (seq parts)
-                 (vec (rest parts))
-                 [])})
+         :args (vec (rest parts))})
 
       slash?
-      {:type :eca-command
-       :command (subs message 1)}
+      (let [command (subs message 1)
+            parts (string/split command #" ")]
+        {:type :eca-command
+         :command (first parts)
+         :args (vec (rest parts))})
 
       :else
       {:type :prompt-message
@@ -276,27 +261,13 @@
                       :text error-message})
       (prompt-messages! messages false chat-ctx))))
 
-(defn ^:private handle-command! [{:keys [command]} {:keys [chat-id db* model] :as chat-ctx}]
-  (let [db @db*]
-    (case command
-      "costs" (let [total-input-tokens (get-in db [:chats chat-id :total-input-tokens] 0)
-                    total-input-cache-creation-tokens (get-in db [:chats chat-id :total-input-cache-creation-tokens] nil)
-                    total-input-cache-read-tokens (get-in db [:chats chat-id :total-input-cache-read-tokens] nil)
-                    total-output-tokens (get-in db [:chats chat-id :total-output-tokens] 0)
-                    text (multi-str (str "Total input tokens: " total-input-tokens)
-                                    (when total-input-cache-creation-tokens
-                                      (str "Total input cache creation tokens: " total-input-cache-creation-tokens))
-                                    (when total-input-cache-read-tokens
-                                      (str "Total input cache read tokens: " total-input-cache-read-tokens))
-                                    (str "Total output tokens: " total-output-tokens)
-                                    (str "Total cost: $" (tokens->cost total-input-tokens total-input-cache-creation-tokens total-input-cache-read-tokens total-output-tokens model db)))]
-                (send-content! chat-ctx :system {:type :text
-                                                 :text text}))
-      "repo-map-show" (send-content! chat-ctx :system {:type :text
-                                                       :text (f.index/repo-map db {:as-string? true})})
-      (send-content! chat-ctx :system {:type :text
-                                       :text (str "Unknown command: " command)})))
-  (finish-chat-prompt! :idle chat-ctx))
+(defn ^:private handle-command! [{:keys [command args]} {:keys [chat-id db* config model] :as chat-ctx}]
+  (let [{:keys [type] :as result} (f.commands/handle-command! command args chat-id model config db*)]
+    (case type
+      :text (do (send-content! chat-ctx :system {:type :text :text (:text result)})
+                (finish-chat-prompt! :idle chat-ctx))
+      :send-prompt (prompt-messages! [{:role "user" :content (:prompt result)}] true chat-ctx)
+      nil)))
 
 (defn prompt
   [{:keys [message model behavior contexts chat-id request-id]}
@@ -346,23 +317,10 @@
 
 (defn query-commands
   [{:keys [query chat-id]}
-   db*]
+   db*
+   config]
   (let [query (string/lower-case query)
-        mcp-prompts (->> (f.mcp/all-prompts @db*)
-                         (mapv #(-> %
-                                    (assoc :name (str (:server %) ":" (:name %))
-                                           :type :mcpPrompt)
-                                    (dissoc :server))))
-        eca-commands [{:name "costs"
-                       :type :native
-                       :description "Show the total costs of the current chat session."
-                       :arguments []}
-                      {:name "repo-map-show"
-                       :type :native
-                       :description "Show the actual repoMap of current session."
-                       :arguments []}]
-        commands (concat mcp-prompts
-                         eca-commands)
+        commands (f.commands/all-commands @db* config)
         commands (if (string/blank? query)
                    commands
                    (filter #(or (string/includes? (string/lower-case (:name %)) query)

src/eca/features/commands.clj

@@ -0,0 +1,122 @@
+(ns eca.features.commands
+  (:require
+   [babashka.fs :as fs]
+   [clojure.java.io :as io]
+   [clojure.string :as string]
+   [eca.config :as config]
+   [eca.features.index :as f.index]
+   [eca.features.tools.mcp :as f.mcp]
+   [eca.shared :as shared :refer [multi-str]]))
+
+(set! *warn-on-reflection* true)
+
+(defn ^:private normalize-command-name [f]
+  (string/lower-case (fs/strip-ext (fs/file-name f))))
+
+(defn ^:private global-file-commands []
+  (let [xdg-config-home (or (config/get-env "XDG_CONFIG_HOME")
+                            (io/file (config/get-property "user.home") ".config"))
+        commands-dir (io/file xdg-config-home "eca" "commands")]
+    (when (fs/exists? commands-dir)
+      (map (fn [file]
+             {:name (normalize-command-name file)
+              :path (str (fs/canonicalize file))
+              :type :user-global-file
+              :content (slurp (fs/file file))})
+           (fs/list-dir commands-dir)))))
+
+(defn ^:private local-file-commands [roots]
+  (->> roots
+       (mapcat (fn [{:keys [uri]}]
+                 (let [commands-dir (fs/file (shared/uri->filename uri) ".eca" "commands")]
+                   (when (fs/exists? commands-dir)
+                     (fs/list-dir commands-dir)))))
+       (map (fn [file]
+              {:name (normalize-command-name file)
+               :path (str (fs/canonicalize file))
+               :type :user-local-file
+               :content (slurp (fs/file file))}))))
+
+(defn ^:private config-commands [config roots]
+  (->> (get config :commands)
+       (map
+        (fn [{:keys [path]}]
+          (if (fs/absolute? path)
+            (when (fs/exists? path)
+              {:name (normalize-command-name path)
+               :path path
+               :type :user-config
+               :content (slurp path)})
+            (keep (fn [{:keys [uri]}]
+                    (let [f (fs/file (shared/uri->filename uri) path)]
+                      (when (fs/exists? f)
+                        {:name (normalize-command-name f)
+                         :path (str (fs/canonicalize f))
+                         :type :user-config
+                         :content (slurp f)})))
+                  roots))))
+       (flatten)
+       (remove nil?)))
+
+(defn ^:private custom-commands [config roots]
+  (concat (config-commands config roots)
+          (global-file-commands)
+          (local-file-commands roots)))
+
+(defn all-commands [db config]
+  (let [mcp-prompts (->> (f.mcp/all-prompts db)
+                         (mapv #(-> %
+                                    (assoc :name (str (:server %) ":" (:name %))
+                                           :type :mcpPrompt)
+                                    (dissoc :server))))
+        eca-commands [{:name "costs"
+                       :type :native
+                       :description "Show the total costs of the current chat session."
+                       :arguments []}
+                      {:name "repo-map-show"
+                       :type :native
+                       :description "Show the actual repoMap of current session."
+                       :arguments []}]
+        custom-commands (map (fn [custom]
+                               {:name (:name custom)
+                                :type :custom-prompt
+                                :description (:path custom)
+                                :arguments []})
+                             (custom-commands config (:workspace-folders db)))]
+    (concat mcp-prompts
+            eca-commands
+            custom-commands)))
+
+(defn ^:private get-custom-command [command args custom-commands]
+  (when-let [raw-content (:content (first (filter #(= command (:name %))
+                                                  custom-commands)))]
+    (let [raw-content (string/replace raw-content "$ARGS" (string/join " " args))]
+      (reduce (fn [content [i arg]]
+                (string/replace content (str "$ARG" (inc i)) arg))
+              raw-content
+              (map-indexed vector args)))))
+
+(defn handle-command! [command args chat-id model config db*]
+  (let [db @db*
+        custom-commands (custom-commands config (:workspace-folders db))]
+    (case command
+      "costs" (let [total-input-tokens (get-in db [:chats chat-id :total-input-tokens] 0)
+                    total-input-cache-creation-tokens (get-in db [:chats chat-id :total-input-cache-creation-tokens] nil)
+                    total-input-cache-read-tokens (get-in db [:chats chat-id :total-input-cache-read-tokens] nil)
+                    total-output-tokens (get-in db [:chats chat-id :total-output-tokens] 0)
+                    text (multi-str (str "Total input tokens: " total-input-tokens)
+                                    (when total-input-cache-creation-tokens
+                                      (str "Total input cache creation tokens: " total-input-cache-creation-tokens))
+                                    (when total-input-cache-read-tokens
+                                      (str "Total input cache read tokens: " total-input-cache-read-tokens))
+                                    (str "Total output tokens: " total-output-tokens)
+                                    (str "Total cost: $" (shared/tokens->cost total-input-tokens total-input-cache-creation-tokens total-input-cache-read-tokens total-output-tokens model db)))]
+                {:type :text :text text})
+      "repo-map-show" {:type :text :text (f.index/repo-map db {:as-string? true})}
+
+      ;; else check if a custom command
+      (if-let [custom-command-prompt (get-custom-command command args custom-commands)]
+        {:type :send-prompt
+         :prompt custom-command-prompt}
+        {:type :text
+         :text (str "Unknown command: " command)}))))

src/eca/handlers.clj

@@ -74,10 +74,10 @@
    :eca/chat-query-context
    (f.chat/query-context params db* config)))
 
-(defn chat-query-commands [{:keys [db*]} params]
+(defn chat-query-commands [{:keys [db* config]} params]
   (logger/logging-task
    :eca/chat-query-commands
-   (f.chat/query-commands params db*)))
+   (f.chat/query-commands params db* config)))
 
 (defn chat-tool-call-approve [{:keys [db*]} params]
   (logger/logging-task

src/eca/shared.clj

@@ -44,3 +44,20 @@
        ret))))
 
 (defn multi-str [& strings] (string/join "\n" (remove nil? strings)))
+
+(defn tokens->cost [input-tokens input-cache-creation-tokens input-cache-read-tokens output-tokens model db]
+  (let [normalized-model (if (string/includes? model "/")
+                           (last (string/split model #"/"))
+                           model)
+        {:keys [input-token-cost output-token-cost
+                input-cache-creation-token-cost input-cache-read-token-cost]} (get-in db [:models normalized-model])
+        input-cost (* input-tokens input-token-cost)
+        input-cost (if input-cache-creation-tokens
+                     (+ input-cost (* input-cache-creation-tokens input-cache-creation-token-cost))
+                     input-cost)
+        input-cost (if input-cache-read-tokens
+                     (+ input-cost (* input-cache-read-tokens input-cache-read-token-cost))
+                     input-cost)]
+    (when (and input-token-cost output-token-cost)
+      (format "%.2f" (+ input-cost
+                        (* output-tokens output-token-cost))))))