Add limit to repoMap with default of 800 total entries and 50 per dir.

ericdallo · ericdallo · commit 0e625c4efc33 · 2025-08-15T17:58:34.000-03:00
Fixes #35
diff --git a/docs/configuration.md b/docs/configuration.md
@@ -194,6 +194,10 @@ interface Config {
         ignoreFiles: [{
             type: string;
         }];
+        repoMap?: {
+            maxTotalEntries?: number;
+            maxEntriesPerDir?: number;
+        };
     };
 }
 ```
@@ -231,7 +235,11 @@ interface Config {
   "index" : {
     "ignoreFiles" : [ {
       "type" : "gitignore"
-    } ]
+    } ],
+    "repoMap": {
+      "maxTotalEntries": 800,
+      "maxEntriesPerDir": 50
+    }
   }
 }
 ```
diff --git a/src/eca/config.clj b/src/eca/config.clj
@@ -46,7 +46,9 @@
    :chat {:welcomeMessage "Welcome to ECA!\n\nType '/' for commands\n\n"}
    :agentFileRelativePath "AGENT.md"
    :customProviders {}
-   :index {:ignoreFiles [{:type :gitignore}]}})
+   :index {:ignoreFiles [{:type :gitignore}]
+           :repoMap {:maxTotalEntries 800
+                     :maxEntriesPerDir 50}}})
 
 (defn get-env [env] (System/getenv env))
 (defn get-property [property] (System/getProperty property))
diff --git a/src/eca/features/chat.clj b/src/eca/features/chat.clj
@@ -348,7 +348,7 @@
         chosen-model (or model (default-model db config))
         rules (f.rules/all config (:workspace-folders db))
         refined-contexts (f.context/raw-contexts->refined contexts db config)
-        repo-map* (delay (f.index/repo-map db {:as-string? true}))
+        repo-map* (delay (f.index/repo-map db config {:as-string? true}))
         instructions (f.prompt/build-instructions refined-contexts rules repo-map* (or behavior (:chat-default-behavior db)) config)
         chat-ctx {:chat-id chat-id
                   :request-id request-id
diff --git a/src/eca/features/commands.clj b/src/eca/features/commands.clj
@@ -72,18 +72,19 @@
                                     (dissoc :server))))
         eca-commands [{:name "init"
                        :type :native
-                       :description "Create/update the AGENT.md file teaching LLM about the project"}
+                       :description "Create/update the AGENT.md file teaching LLM about the project"
+                       :arguments []}
                       {:name "costs"
                        :type :native
                        :description "Total costs of the current chat session."
-                       {:name "resume"
-                        :type :native
-                        :description "Resume the chats from this session workspaces."
-                        :arguments []}
-                       {:name "repo-map-show"
-                        :type :native
-                        :description "Actual repoMap of current session."
-                        :arguments []}
+                       :arguments []}
+                      {:name "resume"
+                       :type :native
+                       :description "Resume the chats from this session workspaces."
+                       :arguments []}
+                      {:name "repo-map-show"
+                       :type :native
+                       :description "Actual repoMap of current session."
                        :arguments []}
                       {:name "prompt-show"
                        :type :native
@@ -136,7 +137,7 @@
                 {:type :chat-messages
                  :chats {chat-id [{:role "system" :content [{:type :text :text text}]}]}})
       "repo-map-show" {:type :chat-messages
-                       :chats {chat-id [{:role "system" :content [{:type :text :text (f.index/repo-map db {:as-string? true})}]}]}}
+                       :chats {chat-id [{:role "system" :content [{:type :text :text (f.index/repo-map db config {:as-string? true})}]}]}}
       "prompt-show" {:type :chat-messages
                      :chats {chat-id [{:role "system" :content [{:type :text :text instructions}]}]}}
 
diff --git a/src/eca/features/index.clj b/src/eca/features/index.clj
@@ -37,44 +37,89 @@
    file-paths
    (get-in config [:index :ignoreFiles])))
 
-(defn insert-path [tree parts]
+(defn ^:private insert-path [tree parts]
   (if (empty? parts)
     tree
     (let [head (first parts)
           tail (rest parts)]
       (update tree head #(insert-path (or % {}) tail)))))
 
-(defn tree->str
-  ([tree] (tree->str tree 0))
-  ([tree indent]
-   (let [indent-str (fn [level] (apply str (repeat (* 1 level) " ")))]
-     (apply str
-            (mapcat (fn [[k v]]
-                      (let [current-line (str (indent-str indent) k "\n")
-                            children-str (when (seq v)
-                                           (tree->str v (inc indent)))]
-                        [current-line children-str]))
-                    (sort tree))))))
+;; Count how many nodes (lines) a tree would render
+(defn ^:private tree-count [tree]
+  (reduce (fn [cnt [_k v]]
+            (let [self 1
+                  children (if (seq v) (tree-count v) 0)]
+              (+ cnt self children)))
+          0
+          tree))
 
-(defn repo-map [db & {:keys [as-string?]}]
-  (let [tree (reduce
-              (fn [t {:keys [uri]}]
-                (let [root-filename (shared/uri->filename uri)
-                      files (git-ls-files root-filename)]
-                  (merge t
-                         {root-filename
-                          (reduce
-                           (fn [tree path]
-                             (insert-path tree (clojure.string/split path #"/")))
-                           {}
-                           files)})))
-              {}
-              (:workspace-folders db))]
-    (if as-string?
-      (tree->str tree)
-      tree)))
+;; Render tree with limits: global max entries and per-directory max entries (non-root only)
+(defn ^:private tree->str-limited
+  [tree max-total-entries max-entries-per-dir]
+  (let [indent-str (fn [level] (apply str (repeat (* 1 level) " ")))
+        remaining (atom max-total-entries)
+        printed-lines (atom 0)       ;; all printed lines (nodes + indicator lines)
+        printed-actual (atom 0)      ;; only actual tree nodes
+        sb (StringBuilder.)
+         ;; emit a single line if we still have remaining budget
+        emit-line (fn [^String s]
+                    (when (pos? @remaining)
+                      (.append sb s)
+                      (swap! remaining dec)
+                      (swap! printed-lines inc)))
+        emit-node (fn [^String s]
+                    (when (pos? @remaining)
+                      (.append sb s)
+                      (swap! remaining dec)
+                      (swap! printed-lines inc)
+                      (swap! printed-actual inc)))
+         ;; recursive emit of a level (all entries in map m)
+        emit-level (fn emit-level [m indent-level root?]
+                     (let [entries (sort m)
+                            ;; Apply per-dir limit to the current level if not root
+                           entries-vec (vec entries)
+                           [to-show hidden] (if root?
+                                              [entries-vec []]
+                                              [(subvec entries-vec 0 (min (count entries-vec) max-entries-per-dir))
+                                               (subvec entries-vec (min (count entries-vec) max-entries-per-dir))])]
+                       (doseq [[k v] to-show]
+                         (when (pos? @remaining)
+                           (emit-node (str (indent-str indent-level) k "\n"))
+                           (when (seq v)
+                             (emit-level v (inc indent-level) false))))
+                       (when (and (seq hidden) (pos? @remaining) (not root?))
+                         (emit-line (str (indent-str indent-level) "... truncated output ("
+                                         (count hidden) " more entries)\n")))))]
+    (emit-level tree 0 true)
+     ;; Compute total possible nodes and append global truncation line if needed
+    (let [total (tree-count tree)
+          omitted (- total @printed-actual)]
+      (when (pos? omitted)
+        (.append sb (str "... truncated output (" omitted " more entries)\n"))))
+    (str sb)))
+
+(defn repo-map
+  ([db config] (repo-map db config {}))
+  ([db config {:keys [as-string?]}]
+   (let [tree (reduce
+               (fn [t {:keys [uri]}]
+                 (let [root-filename (shared/uri->filename uri)
+                       files (git-ls-files root-filename)]
+                   (merge t
+                          {root-filename
+                           (reduce
+                            (fn [tree path]
+                              (insert-path tree (clojure.string/split path #"/")))
+                            {}
+                            files)})))
+               {}
+               (:workspace-folders db))]
+     (if as-string?
+       (let [{:keys [maxTotalEntries maxEntriesPerDir]} (get-in config [:index :repoMap])]
+         (tree->str-limited tree maxTotalEntries maxEntriesPerDir))
+       tree))))
 
 (comment
   (require 'user)
   (user/with-workspace-root "file:///home/greg/dev/eca"
-    (println (repo-map user/*db* {:as-string? true}))))
+    (println (repo-map user/*db* {:max-total-entries 1000 :max-entries-per-dir 200} {:as-string? true}))))
diff --git a/test/eca/features/index_test.clj b/test/eca/features/index_test.clj
@@ -2,6 +2,7 @@
   (:require
    [babashka.fs :as fs]
    [clojure.java.shell :as shell]
+   [clojure.string :as string]
    [clojure.test :refer [deftest is testing]]
    [eca.features.index :as f.index]
    [eca.shared :refer [multi-str]]
@@ -41,13 +42,51 @@
             {"README.md" {}
              "src" {"eca" {"core.clj" {}}}
              "test" {"eca" {"core_test.clj" {}}}}}
-           (eca.features.index/repo-map {:workspace-folders [{:uri (h/file-uri "file:///fake/repo")}]})))))
+           (eca.features.index/repo-map {:workspace-folders [{:uri (h/file-uri "file:///fake/repo")}]} {})))))
   (testing "returns string tree with as-string? true"
     (with-redefs [f.index/git-ls-files (constantly ["foo.clj" "bar/baz.clj"])]
       (is (= (multi-str (h/file-path "/fake/repo")
                         " bar"
                         "  baz.clj"
                         " foo.clj"
                         "")
-             (eca.features.index/repo-map {:workspace-folders [{:uri (h/file-uri "file:///fake/repo")}]}
+             (eca.features.index/repo-map {:workspace-folders [{:uri (h/file-uri "file:///fake/repo")}]} 
+                                          {:index {:repoMap {:maxEntriesPerDir 50 :maxTotalEntries 800}}}
                                           {:as-string? true}))))))
+
+(deftest repo-map-truncation-test
+  (testing "per-directory truncation shows indicator and global truncated line"
+    (with-redefs [f.index/git-ls-files (constantly ["AGENT.md"
+                                                    "src/a.clj"
+                                                    "src/b.clj"
+                                                    "src/c.clj"
+                                                    "src/d.clj"
+                                                    "src/e.clj"
+                                                    "src/f.clj"
+                                                    "src/g.clj"
+                                                    "src/h.clj"])]
+      (let [out (eca.features.index/repo-map {:workspace-folders [{:uri (h/file-uri "file:///fake/repo")}]} 
+                                             {:index {:repoMap {:maxTotalEntries 800
+                                                                 :maxEntriesPerDir 3}}}
+                                             {:as-string? true})]
+        (is (string/includes? out (str (h/file-path "/fake/repo") "\n")))
+        ;; Under src, only first 3 children (sorted) and a per-dir truncated line should appear
+        (is (string/includes? out " src\n"))
+        (is (string/includes? out "  a.clj\n"))
+        (is (string/includes? out "  b.clj\n"))
+        (is (string/includes? out "  c.clj\n"))
+        (is (string/includes? out "  ... truncated output (5 more entries)\n"))
+        ;; A final global truncated line should also be present
+        (is (string/includes? out "\n... truncated output (")))))
+  (testing "global truncation appends final truncated line"
+    (with-redefs [f.index/git-ls-files (constantly ["AGENT.md"
+                                                    "CHANGELOG.md"
+                                                    "LICENSE"
+                                                    "src/a.clj"
+                                                    "src/b.clj"])]
+      (let [out (eca.features.index/repo-map {:workspace-folders [{:uri (h/file-uri "file:///fake/repo")}]} 
+                                             {:index {:repoMap {:maxTotalEntries 3
+                                                                 :maxEntriesPerDir 800}}}
+                                             {:as-string? true})]
+        ;; Contains a global truncated line
+        (is (string/includes? out "\n... truncated output ("))))))
