Support dynamic string content in configs

Related to #200

Author: ericdallo

CHANGELOG.md

@@ -2,6 +2,8 @@
 
 ## Unreleased
 
+- Support dynamic string parse (`${file:/path/to/something}` and `${env:MY_ENV}`) in all configs with string values. #200
+
 ## 0.82.1
 
 - Fix custom tools output to return stderr when tool error. #219

docs/configuration.md

@@ -45,6 +45,13 @@ There are multiples ways to configure ECA:
     ```bash
     ECA_CONFIG='{"myConfig": "my_value"}' eca server
     ```
+    
+!!! info "Dynamic string contents"
+
+    It's possible to retrieve content of any configs with a string value using the `${key:value}` approach, being `key`:
+
+    - `file`: `${file:/path/to/my-file}` or `${file:../rel-path/to/my-file}` to get a file content
+    - `env`: `${env:MY_ENV}` to get a system env value
 
 ## Providers / Models
 
@@ -231,7 +238,7 @@ Placeholders in the format `{{argument_name}}` within the `command` string will
     {
       "customTools": {
         "file-search": {
-          "description": "Finds files within a directory that match a specific name pattern.",
+          "description": "${file:tools/my-tool.md}",
           "command": "find {{directory}} -name {{pattern}}",
           "schema": {
             "properties": {
@@ -373,6 +380,10 @@ Examples:
 
 === "Ring bell sound when pending tool call approval"
 
+    ```javascript title="~/.config/eca/hooks/my-hook.sh"
+    [[ $(jq '.approval == "ask"' <<< "$1") ]] && canberra-gtk-play -i complete
+    ```
+
     ```javascript title="~/.config/eca/config.json"
     {
       "hooks": {
@@ -382,7 +393,7 @@ Examples:
           "actions": [
             {
               "type": "shell",
-              "shell": "[[ $(jq '.approval == \"ask\"' <<< \"$1\") ]] && canberra-gtk-play -i complete"
+              "shell": "${file:hooks/my-hook.sh}"
             }
           ]
         }

src/eca/config.clj

@@ -8,12 +8,14 @@
 
   When `:config-file` from cli option is passed, it uses that instead of searching default locations."
   (:require
+   [babashka.fs :as fs]
    [camel-snake-kebab.core :as csk]
    [cheshire.core :as json]
    [cheshire.factory :as json.factory]
    [clojure.core.memoize :as memoize]
    [clojure.java.io :as io]
    [clojure.string :as string]
+   [clojure.walk :as walk]
    [eca.logger :as logger]
    [eca.messenger :as messenger]
    [eca.shared :as shared :refer [multi-str]])
@@ -157,6 +159,35 @@
 (defn get-env [env] (System/getenv env))
 (defn get-property [property] (System/getProperty property))
 
+(defn ^:private parse-dynamic-string
+  "Given a string and a current working directory, look for patterns replacing its content:
+  - `${env:SOME-ENV}`: Replace with a env
+  - `${file:/some/path}`: Replace with a file content checking from cwd if relative"
+  [s cwd]
+  (some-> s
+          (string/replace #"\$\{env:([^}]+)\}"
+                          (fn [[_match env-var]]
+                            (or (get-env env-var) "")))
+          (string/replace #"\$\{file:([^}]+)\}"
+                          (fn [[_match file-path]]
+                            (try
+                              (slurp (str (if (fs/absolute? file-path)
+                                            file-path
+                                            (fs/path cwd file-path))))
+                              (catch Exception _
+                                (logger/warn logger-tag "File not found when parsing string:" s)
+                                ""))))))
+
+(defn ^:private parse-dynamic-string-values
+  "walk through config parsing dynamic string contents if value is a string."
+  [config cwd]
+  (walk/postwalk
+   (fn [x]
+     (if (string? x)
+       (parse-dynamic-string x cwd)
+       x))
+   config))
+
 (def ^:private ttl-cache-config-ms 5000)
 
 (defn ^:private safe-read-json-string [raw-string config-dyn-var]
@@ -194,7 +225,8 @@
 (defn ^:private config-from-global-file* []
   (let [config-file (global-config-file)]
     (when (.exists config-file)
-      (safe-read-json-string (slurp config-file) (var *global-config-error*)))))
+      (some-> (safe-read-json-string (slurp config-file) (var *global-config-error*))
+              (parse-dynamic-string-values (global-config-dir))))))
 
 (def ^:private config-from-global-file (memoize/ttl config-from-global-file* :ttl/threshold ttl-cache-config-ms))
 
@@ -203,9 +235,11 @@
    (fn [final-config {:keys [uri]}]
      (merge
       final-config
-      (let [config-file (io/file (shared/uri->filename uri) ".eca" "config.json")]
+      (let [config-dir (io/file (shared/uri->filename uri) ".eca")
+            config-file (io/file config-dir "config.json")]
         (when (.exists config-file)
-          (safe-read-json-string (slurp config-file) (var *local-config-error*))))))
+          (some-> (safe-read-json-string (slurp config-file) (var *local-config-error*))
+                  (parse-dynamic-string-values config-dir))))))
    {}
    roots))
 
@@ -235,7 +269,7 @@
   [normalization-rules m]
   (let [kc-paths (set (:kebab-case normalization-rules))
         str-paths (set (:stringfy normalization-rules))
-        ; match a current path against a rule path with :ANY wildcard
+                                        ; match a current path against a rule path with :ANY wildcard
         matches-path? (fn [rule-path cur-path]
                         (and (= (count rule-path) (count cur-path))
                              (every? true?

src/eca/features/tools/custom.clj

@@ -2,7 +2,6 @@
   (:require
    [babashka.process :as p]
    [clojure.string :as string]
-   [eca.features.tools.util :as tools.util]
    [eca.logger :as logger]
    [eca.shared :as shared]))
 

test/eca/config_test.clj

@@ -1,5 +1,6 @@
 (ns eca.config-test
   (:require
+   [babashka.fs :as fs]
    [clojure.test :refer [deftest is testing]]
    [eca.config :as config]
    [eca.logger :as logger]
@@ -184,3 +185,82 @@
                                            :b [:bar]}
                                           {:c 3
                                            :b []})))))
+
+(deftest parse-dynamic-string-test
+  (testing "returns nil for nil input"
+    (is (nil? (#'config/parse-dynamic-string nil "/tmp"))))
+
+  (testing "returns string unchanged when no patterns"
+    (is (= "hello world" (#'config/parse-dynamic-string "hello world" "/tmp"))))
+
+  (testing "replaces environment variable patterns"
+    (with-redefs [config/get-env (fn [env-var]
+                                   (case env-var
+                                     "TEST_VAR" "test-value"
+                                     "ANOTHER_VAR" "another-value"
+                                     nil))]
+      (is (= "test-value" (#'config/parse-dynamic-string "${env:TEST_VAR}" "/tmp")))
+      (is (= "prefix test-value suffix" (#'config/parse-dynamic-string "prefix ${env:TEST_VAR} suffix" "/tmp")))
+      (is (= "test-value and another-value" (#'config/parse-dynamic-string "${env:TEST_VAR} and ${env:ANOTHER_VAR}" "/tmp")))))
+
+  (testing "replaces undefined env var with empty string"
+    (with-redefs [config/get-env (constantly nil)]
+      (is (= "" (#'config/parse-dynamic-string "${env:UNDEFINED_VAR}" "/tmp")))
+      (is (= "prefix  suffix" (#'config/parse-dynamic-string "prefix ${env:UNDEFINED_VAR} suffix" "/tmp")))))
+
+  (testing "replaces file pattern with file content - absolute path"
+    (with-redefs [fs/absolute? (fn [path] (= path "/absolute/file.txt"))
+                  slurp (fn [path]
+                          (if (= (str path) "/absolute/file.txt")
+                            "test file content"
+                            (throw (ex-info "File not found" {}))))]
+      (is (= "test file content" (#'config/parse-dynamic-string "${file:/absolute/file.txt}" "/tmp")))))
+
+  (testing "replaces file pattern with file content - relative path"
+    (with-redefs [fs/absolute? (fn [_] false)
+                  fs/path (fn [cwd file-path] (str cwd "/" file-path))
+                  slurp (fn [path]
+                          (if (= path "/tmp/test.txt")
+                            "relative file content"
+                            (throw (ex-info "File not found" {}))))]
+      (is (= "relative file content" (#'config/parse-dynamic-string "${file:test.txt}" "/tmp")))))
+
+  (testing "replaces file pattern with empty string when file not found"
+    (with-redefs [logger/warn (fn [& _] nil)
+                  fs/absolute? (fn [_] true)
+                  slurp (fn [_] (throw (ex-info "File not found" {})))]
+      (is (= "" (#'config/parse-dynamic-string "${file:/nonexistent/file.txt}" "/tmp")))
+      (is (= "prefix  suffix" (#'config/parse-dynamic-string "prefix ${file:/nonexistent/file.txt} suffix" "/tmp")))))
+
+  (testing "handles multiple file patterns"
+    (with-redefs [fs/absolute? (fn [_] true)
+                  slurp (fn [path]
+                          (case (str path)
+                            "/file1.txt" "content1"
+                            "/file2.txt" "content2"
+                            (throw (ex-info "File not found" {}))))]
+      (is (= "content1 and content2"
+             (#'config/parse-dynamic-string "${file:/file1.txt} and ${file:/file2.txt}" "/tmp")))))
+
+  (testing "handles mixed env and file patterns"
+    (with-redefs [config/get-env (fn [env-var]
+                                   (when (= env-var "TEST_VAR") "env-value"))
+                  fs/absolute? (fn [_] true)
+                  slurp (fn [path]
+                          (if (= (str path) "/file.txt")
+                            "file-value"
+                            (throw (ex-info "File not found" {}))))]
+      (is (= "env-value and file-value"
+             (#'config/parse-dynamic-string "${env:TEST_VAR} and ${file:/file.txt}" "/tmp")))))
+
+  (testing "handles patterns within longer strings"
+    (with-redefs [config/get-env (fn [env-var]
+                                   (when (= env-var "API_KEY") "secret123"))]
+      (is (= "Bearer secret123" (#'config/parse-dynamic-string "Bearer ${env:API_KEY}" "/tmp")))))
+
+  (testing "handles empty string input"
+    (is (= "" (#'config/parse-dynamic-string "" "/tmp"))))
+
+  (testing "preserves content with escaped-like patterns that don't match"
+    (is (= "${notenv:VAR}" (#'config/parse-dynamic-string "${notenv:VAR}" "/tmp")))
+    (is (= "${env:}" (#'config/parse-dynamic-string "${env:}" "/tmp")))))