@nbardy/oompa 0.1.0

package/agentnet/src/agentnet/cli.clj

@@ -0,0 +1,436 @@
+(ns agentnet.cli
+  "Command-line interface for AgentNet orchestrator.
+
+   Usage:
+     ./swarm.bb run                                    # Run all tasks once
+     ./swarm.bb run --workers 4                        # With 4 parallel workers
+     ./swarm.bb loop 20 --harness claude               # 20 iterations with Claude
+     ./swarm.bb loop --workers claude:5 codex:4 --iterations 20  # Mixed harnesses
+     ./swarm.bb swarm oompa.json                       # Multi-model from config
+     ./swarm.bb prompt \"...\"                          # Ad-hoc task
+     ./swarm.bb status                                 # Show last run
+     ./swarm.bb worktrees                              # List worktree status
+     ./swarm.bb cleanup                                # Remove all worktrees"
+  (:require [agentnet.orchestrator :as orchestrator]
+            [agentnet.worktree :as worktree]
+            [agentnet.worker :as worker]
+            [agentnet.tasks :as tasks]
+            [agentnet.agent :as agent]
+            [clojure.string :as str]
+            [clojure.java.io :as io]
+            [cheshire.core :as json]))
+
+;; =============================================================================
+;; Argument Parsing
+;; =============================================================================
+
+(defn- parse-int [s default]
+  (try
+    (Integer/parseInt s)
+    (catch Exception _ default)))
+
+(defn- make-swarm-id
+  "Generate a short run-level swarm ID."
+  []
+  (subs (str (java.util.UUID/randomUUID)) 0 8))
+
+(defn- parse-worker-spec
+  "Parse 'harness:count' into {:harness :claude, :count 5}.
+   Throws on invalid format."
+  [s]
+  (let [[harness count-str] (str/split s #":" 2)
+        h (keyword harness)
+        cnt (parse-int count-str 0)]
+    (when-not (#{:codex :claude} h)
+      (throw (ex-info (str "Unknown harness in worker spec: " s ". Use 'codex:N' or 'claude:N'") {})))
+    (when (zero? cnt)
+      (throw (ex-info (str "Invalid count in worker spec: " s ". Use format 'harness:count'") {})))
+    {:harness h :count cnt}))
+
+(defn- worker-spec? [s]
+  "Check if string looks like 'harness:count' format"
+  (and (string? s)
+       (not (str/starts-with? s "--"))
+       (str/includes? s ":")
+       (re-matches #"[a-z]+:\d+" s)))
+
+(defn- collect-worker-specs
+  "Collect consecutive worker specs from args. Returns [specs remaining-args]."
+  [args]
+  (loop [specs []
+         remaining args]
+    (if-let [arg (first remaining)]
+      (if (worker-spec? arg)
+        (recur (conj specs (parse-worker-spec arg)) (next remaining))
+        [specs remaining])
+      [specs remaining])))
+
+(defn parse-args [args]
+  (loop [opts {:workers 2
+               :harness :codex
+               :model nil
+               :dry-run false
+               :iterations 1
+               :worker-specs nil}
+         remaining args]
+    (if-let [arg (first remaining)]
+      (cond
+        ;; --workers can take either N or harness:count specs
+        (= arg "--workers")
+        (let [next-arg (second remaining)]
+          (if (worker-spec? next-arg)
+            ;; Collect all worker specs: --workers claude:5 codex:4
+            (let [[specs rest] (collect-worker-specs (next remaining))]
+              (recur (assoc opts :worker-specs specs) rest))
+            ;; Simple count: --workers 4
+            (recur (assoc opts :workers (parse-int next-arg 2))
+                   (nnext remaining))))
+
+        (= arg "--iterations")
+        (recur (assoc opts :iterations (parse-int (second remaining) 1))
+               (nnext remaining))
+
+        (= arg "--harness")
+        (let [h (keyword (second remaining))]
+          (when-not (#{:codex :claude} h)
+            (throw (ex-info (str "Unknown harness: " (second remaining) ". Use 'codex' or 'claude'") {})))
+          (recur (assoc opts :harness h)
+                 (nnext remaining)))
+
+        (= arg "--model")
+        (recur (assoc opts :model (second remaining))
+               (nnext remaining))
+
+        ;; Legacy flags (still supported)
+        (= arg "--claude")
+        (recur (assoc opts :harness :claude)
+               (next remaining))
+
+        (= arg "--codex")
+        (recur (assoc opts :harness :codex)
+               (next remaining))
+
+        (= arg "--dry-run")
+        (recur (assoc opts :dry-run true)
+               (next remaining))
+
+        (= arg "--keep-worktrees")
+        (recur (assoc opts :keep-worktrees true)
+               (next remaining))
+
+        (= arg "--")
+        {:opts opts :args (vec (next remaining))}
+
+        (str/starts-with? arg "--")
+        (throw (ex-info (str "Unknown option: " arg) {:arg arg}))
+
+        :else
+        {:opts opts :args (vec remaining)})
+      {:opts opts :args []})))
+
+;; =============================================================================
+;; Commands
+;; =============================================================================
+
+(defn cmd-run
+  "Run orchestrator once"
+  [opts args]
+  (let [swarm-id (make-swarm-id)]
+    (if-let [specs (:worker-specs opts)]
+    ;; Mixed worker specs: --workers claude:5 codex:4
+    (let [workers (mapcat
+                    (fn [spec]
+                      (let [{:keys [harness count]} spec]
+                        (map-indexed
+                          (fn [idx _]
+                            (worker/create-worker
+                              {:id (format "%s-%d" (name harness) idx)
+                               :swarm-id swarm-id
+                               :harness harness
+                               :model (:model opts)
+                               :iterations 1}))
+                          (range count))))
+                    specs)]
+      (println (format "Running once with mixed workers (swarm %s):" swarm-id))
+      (doseq [spec specs]
+        (println (format "  %dx %s" (:count spec) (name (:harness spec)))))
+      (println)
+      (worker/run-workers! workers))
+    ;; Simple mode
+    (do
+      (println (format "Swarm ID: %s" swarm-id))
+      (orchestrator/run-once! (assoc opts :swarm-id swarm-id))))))
+
+(defn cmd-loop
+  "Run orchestrator N times"
+  [opts args]
+  (let [swarm-id (make-swarm-id)
+        iterations (or (some-> (first args) (parse-int nil))
+                       (:iterations opts)
+                       20)]
+    (if-let [specs (:worker-specs opts)]
+      ;; Mixed worker specs: --workers claude:5 codex:4
+      (let [workers (mapcat
+                      (fn [spec]
+                        (let [{:keys [harness count]} spec]
+                          (map-indexed
+                            (fn [idx _]
+                              (worker/create-worker
+                                {:id (format "%s-%d" (name harness) idx)
+                                 :swarm-id swarm-id
+                                 :harness harness
+                                 :model (:model opts)
+                                 :iterations iterations}))
+                            (range count))))
+                      specs)]
+        (println (format "Starting %d iterations with mixed workers (swarm %s):" iterations swarm-id))
+        (doseq [spec specs]
+          (println (format "  %dx %s" (:count spec) (name (:harness spec)))))
+        (println)
+        (worker/run-workers! workers))
+      ;; Simple mode: --workers N --harness X
+      (let [model-str (if (:model opts)
+                        (format " (model: %s)" (:model opts))
+                        "")]
+        (println (format "Starting %d iterations with %s harness%s..."
+                         iterations (name (:harness opts)) model-str))
+        (println (format "Swarm ID: %s" swarm-id))
+        (orchestrator/run-loop! iterations (assoc opts :swarm-id swarm-id))))))
+
+(defn cmd-prompt
+  "Run ad-hoc prompt as single task"
+  [opts args]
+  (let [prompt-text (str/join " " args)]
+    (when (str/blank? prompt-text)
+      (println "Error: prompt text required")
+      (System/exit 1))
+    ;; Create temporary task
+    (let [task {:id (format "prompt-%d" (System/currentTimeMillis))
+                :summary prompt-text
+                :targets ["src" "tests" "docs"]
+                :priority 1}]
+      ;; Write to temporary tasks file
+      (spit "config/tasks.edn" (pr-str [task]))
+      ;; Run
+      (orchestrator/run-once! opts))))
+
+(defn cmd-status
+  "Show status of last run"
+  [opts args]
+  (let [runs-dir (io/file "runs")
+        files (when (.exists runs-dir)
+                (->> (.listFiles runs-dir)
+                     (filter #(.isFile %))
+                     (sort-by #(.lastModified %) >)))]
+    (if-let [latest (first files)]
+      (do
+        (println (format "Latest run: %s" (.getName latest)))
+        (println)
+        (with-open [r (io/reader latest)]
+          (let [entries (mapv #(json/parse-string % true) (line-seq r))
+                by-status (group-by :status entries)]
+            (doseq [[status tasks] (sort-by first by-status)]
+              (println (format "%s: %d" (name status) (count tasks))))
+            (println)
+            (println (format "Total: %d tasks" (count entries))))))
+      (println "No runs found."))))
+
+(defn cmd-worktrees
+  "List worktree status"
+  [opts args]
+  (let [state-file (io/file ".workers/state.edn")]
+    (if (.exists state-file)
+      (let [pool (read-string (slurp state-file))
+            pool' (worktree/list-worktrees pool)]
+        (println "Worktrees:")
+        (doseq [{:keys [id path status current-task]} pool']
+          (println (format "  %s: %s%s"
+                           id
+                           (name status)
+                           (if current-task
+                             (str " [" current-task "]")
+                             "")))))
+      (println "No worktrees initialized."))))
+
+(defn cmd-cleanup
+  "Remove all worktrees"
+  [opts args]
+  (let [state-file (io/file ".workers/state.edn")]
+    (if (.exists state-file)
+      (let [pool (read-string (slurp state-file))]
+        (println "Removing worktrees...")
+        (worktree/cleanup-pool! pool)
+        (println "Done."))
+      (println "No worktrees to clean up."))))
+
+(defn cmd-context
+  "Print current context (for debugging prompts)"
+  [opts args]
+  (let [ctx (orchestrator/build-context [])]
+    (println (:context_header ctx))))
+
+(defn cmd-check
+  "Check if agent backends are available"
+  [opts args]
+  (println "Checking agent backends...")
+  (doseq [agent-type [:codex :claude]]
+    (let [available? (agent/check-available agent-type)]
+      (println (format "  %s: %s"
+                       (name agent-type)
+                       (if available? "✓ available" "✗ not found"))))))
+
+(defn- parse-model-string
+  "Parse 'harness:model' string into {:harness :model}"
+  [s]
+  (if (and s (str/includes? s ":"))
+    (let [[h m] (str/split s #":" 2)]
+      {:harness (keyword h) :model m})
+    {:harness :codex :model s}))
+
+(defn cmd-swarm
+  "Run multiple worker configs from oompa.json in parallel"
+  [opts args]
+  (let [config-file (or (first args) "oompa.json")
+        f (io/file config-file)
+        swarm-id (make-swarm-id)]
+    (when-not (.exists f)
+      (println (format "Config file not found: %s" config-file))
+      (println)
+      (println "Create oompa.json with format:")
+      (println "{")
+      (println "  \"review_model\": \"codex:codex-5.2\",")
+      (println "  \"workers\": [")
+      (println "    {\"model\": \"codex:codex-5.2-mini\", \"iterations\": 10, \"count\": 3},")
+      (println "    {\"model\": \"codex:codex-5.2\", \"iterations\": 5, \"count\": 1, \"prompt\": \"prompts/planner.md\"}")
+      (println "  ]")
+      (println "}")
+      (System/exit 1))
+    (let [config (json/parse-string (slurp f) true)
+          review-model (some-> (:review_model config) parse-model-string)
+          worker-configs (:workers config)
+
+          ;; Expand worker configs by count
+          expanded-workers (mapcat (fn [wc]
+                                     (let [cnt (or (:count wc) 1)]
+                                       (repeat cnt (dissoc wc :count))))
+                                   worker-configs)
+
+          ;; Convert to worker format
+          workers (map-indexed
+                    (fn [idx wc]
+                      (let [{:keys [harness model]} (parse-model-string (:model wc))]
+                        (worker/create-worker
+                          {:id (str "w" idx)
+                           :swarm-id swarm-id
+                           :harness harness
+                           :model model
+                           :iterations (or (:iterations wc) 10)
+                           :custom-prompt (:prompt wc)
+                           :review-harness (:harness review-model)
+                           :review-model (:model review-model)})))
+                    expanded-workers)]
+
+      (println (format "Swarm config from %s:" config-file))
+      (println (format "  Swarm ID: %s" swarm-id))
+      (when review-model
+        (println (format "  Review: %s:%s" (name (:harness review-model)) (:model review-model))))
+      (println (format "  Workers: %d total" (count workers)))
+      (doseq [[idx wc] (map-indexed vector worker-configs)]
+        (let [{:keys [harness model]} (parse-model-string (:model wc))]
+          (println (format "    - %dx %s:%s (%d iters%s)"
+                           (or (:count wc) 1)
+                           (name harness)
+                           model
+                           (or (:iterations wc) 10)
+                           (if (:prompt wc) (str ", " (:prompt wc)) "")))))
+      (println)
+
+      ;; Run workers using new worker module
+      (worker/run-workers! workers))))
+
+(defn cmd-tasks
+  "Show task status"
+  [opts args]
+  (tasks/ensure-dirs!)
+  (let [status (tasks/status-summary)]
+    (println "Task Status:")
+    (println (format "  Pending:  %d" (:pending status)))
+    (println (format "  Current:  %d" (:current status)))
+    (println (format "  Complete: %d" (:complete status)))
+    (println)
+    (when (pos? (:pending status))
+      (println "Pending tasks:")
+      (doseq [t (tasks/list-pending)]
+        (println (format "  - %s: %s" (:id t) (:summary t)))))
+    (when (pos? (:current status))
+      (println "In-progress tasks:")
+      (doseq [t (tasks/list-current)]
+        (println (format "  - %s: %s" (:id t) (:summary t)))))))
+
+(defn cmd-help
+  "Print usage information"
+  [opts args]
+  (println "AgentNet Orchestrator")
+  (println)
+  (println "Usage: ./swarm.bb <command> [options]")
+  (println)
+  (println "Commands:")
+  (println "  run              Run all tasks once")
+  (println "  loop N           Run N iterations")
+  (println "  swarm [file]     Run multiple worker configs from oompa.json (parallel)")
+  (println "  tasks            Show task status (pending/current/complete)")
+  (println "  prompt \"...\"     Run ad-hoc prompt")
+  (println "  status           Show last run summary")
+  (println "  worktrees        List worktree status")
+  (println "  cleanup          Remove all worktrees")
+  (println "  context          Print context block")
+  (println "  check            Check agent backends")
+  (println "  help             Show this help")
+  (println)
+  (println "Options:")
+  (println "  --workers N              Number of parallel workers (default: 2)")
+  (println "  --workers H:N [H:N ...]  Mixed workers by harness (e.g., claude:5 codex:4)")
+  (println "  --iterations N           Number of iterations per worker (default: 1)")
+  (println "  --harness {codex,claude} Agent harness to use (default: codex)")
+  (println "  --model MODEL            Model to use (e.g., codex-5.2, opus-4.5)")
+  (println "  --dry-run                Skip actual merges")
+  (println "  --keep-worktrees         Don't cleanup worktrees after run")
+  (println)
+  (println "Examples:")
+  (println "  ./swarm.bb loop 10 --harness codex --model codex-5.2-mini --workers 3")
+  (println "  ./swarm.bb loop --workers claude:5 codex:4 --iterations 20")
+  (println "  ./swarm.bb swarm oompa.json  # Run multi-model config"))
+
+;; =============================================================================
+;; Main Entry Point
+;; =============================================================================
+
+(def commands
+  {"run" cmd-run
+   "loop" cmd-loop
+   "swarm" cmd-swarm
+   "tasks" cmd-tasks
+   "prompt" cmd-prompt
+   "status" cmd-status
+   "worktrees" cmd-worktrees
+   "cleanup" cmd-cleanup
+   "context" cmd-context
+   "check" cmd-check
+   "help" cmd-help})
+
+(defn -main [& args]
+  (let [[cmd & rest-args] args]
+    (if-let [handler (get commands cmd)]
+      (let [{:keys [opts args]} (parse-args rest-args)]
+        (try
+          (handler opts args)
+          (catch Exception e
+            (binding [*out* *err*]
+              (println (format "Error: %s" (.getMessage e))))
+            (System/exit 1))))
+      (do
+        (cmd-help {} [])
+        (when cmd
+          (println)
+          (println (format "Unknown command: %s" cmd)))
+        (System/exit (if cmd 1 0))))))

package/agentnet/src/agentnet/core.clj

@@ -0,0 +1,211 @@
+(ns agentnet.core
+  "Context assembly utilities shared by the AgentNet orchestrator."
+  (:require [agentnet.notes :as notes]
+            [babashka.process :as process]
+            [clojure.java.io :as io]
+            [clojure.string :as str]))
+
+(defn now-ms []
+  (System/currentTimeMillis))
+
+(defn format-ago
+  "Return human-readable relative time string for epoch milliseconds."
+  [^long ts-ms]
+  (let [delta (max 0 (- (now-ms) ts-ms))
+        s (long (/ delta 1000))]
+    (cond
+      (< s 15) "just now"
+      (< s 60) (str s "s ago")
+      :else (let [m (long (/ s 60))]
+              (cond
+                (< m 60) (str m "m ago")
+                :else (let [h (long (/ m 60))]
+                        (if (< h 24)
+                          (str h "h ago")
+                          (str (long (/ h 24)) "d ago"))))))))
+
+(defn- git-cmd
+  "Run git command in repo and return trimmed stdout or nil on failure."
+  [repo & args]
+  (try
+    (let [cmd (into ["git" "-C" repo] args)
+          {:keys [exit out]} (process/sh cmd {:out :string :err :string})]
+      (when (zero? exit)
+        (str/trim out)))
+    (catch Exception _ nil)))
+
+(defn- repo-branch [repo]
+  (or (git-cmd repo "rev-parse" "--abbrev-ref" "HEAD") "HEAD"))
+
+(defn- repo-head [repo]
+  (or (git-cmd repo "rev-parse" "--short" "HEAD") "HEAD"))
+
+(defn- bulletize
+  "Render a collection as Markdown bullets; fallback provided when empty."
+  ([items] (bulletize items "- (empty)"))
+  ([items empty-text]
+   (if (seq items)
+     (str/join "\n" (map #(str "- " %) items))
+     empty-text)))
+
+(defn- queue-lines [tasks]
+  (->> tasks
+       (sort-by (juxt (comp (fnil identity 1000) :priority) :id))
+       (map (fn [{:keys [id summary]}]
+              (format "`%s` • %s" id summary)))))
+
+(defn- note->path [{:keys [dir name]}]
+  (str dir "/" name))
+
+(defn- pending-items []
+  (->> (notes/green-ready)
+       (map (fn [note]
+              (let [paths (or (:targets note)
+                              [(note->path note)])]
+                {:id (or (:id note) (:name note))
+                 :age (format-ago (:mtime note))
+                 :files (vec (take 3 paths))})))
+       (take 7)
+       vec))
+
+(defn- recent-notes [recent-sec]
+  (let [cut (- (now-ms) (* 1000 (long (or recent-sec 120))))]
+    (->> ["scratch" "ready_for_review" "notes_FROM_CTO"]
+         (mapcat notes/list-notes)
+         (filter #(>= (:mtime %) cut))
+         (sort-by :mtime >)
+         (take 7)
+         (map (fn [note]
+                {:path (note->path note)
+                 :age (format-ago (:mtime note))}))
+         vec)))
+
+(defn- backlog-entries [tasks]
+  (->> tasks
+       (sort-by (juxt (comp (fnil identity 1000) :priority) :id))
+       (map #(select-keys % [:id :summary]))
+       (remove #(nil? (:id %)))
+       (take 7)
+       vec))
+
+(def default-policy-rules
+  ["patch-only" ".agent/* only" "minimal diff" "respect targets"])
+
+(defn- policy-rules [policy]
+  (let [allow (:allow policy)
+        deny (:deny policy)
+        limit+ (:max-lines-added policy)
+        limit- (:max-lines-deleted policy)
+        files (:max-files policy)
+        custom (remove nil?
+                       [(when (seq allow)
+                          (str "allow:" (str/join "," allow)))
+                        (when (seq deny)
+                          (str "deny:" (str/join "," deny)))
+                        (when limit+
+                          (format "+≤%s lines" limit+))
+                        (when limit-
+                          (format "-≤%s lines" limit-))
+                        (when files
+                          (format "files≤%s" files))])]
+    (->> (concat default-policy-rules custom)
+         (distinct)
+         (take 7)
+         vec)))
+
+(defn- next-work-suggestions [tasks pending hotspots]
+  (let [top-task (first tasks)
+        top-pending (first pending)
+        top-hotspot (first hotspots)
+        suggestions (cond-> []
+                      top-pending
+                      (conj (format "CTO: review %s (%s)" (:id top-pending) (:age top-pending)))
+
+                      top-task
+                      (conj (format "Engineer: pick %s — %s" (:id top-task) (:summary top-task)))
+
+                      top-hotspot
+                      (conj (format "CTO: investigate %s" (:path top-hotspot))))]
+    (take 5 (if (empty? suggestions)
+              ["noop"]
+              suggestions))))
+
+(defn- render-pending [items]
+  (if (seq items)
+    (mapcat (fn [{:keys [id age files]}]
+              [(format "  - id: %s" (pr-str id))
+               (format "    age: %s" age)
+               (format "    files: [%s]" (str/join "," (map pr-str files)))])
+            items)
+    ["  - []"]))
+
+(defn- render-backlog [items]
+  (if (seq items)
+    (map (fn [{:keys [id summary]}]
+           (format "  - {id: %s, summary: %s}" (pr-str id) (pr-str summary)))
+         items)
+    ["  - []"]))
+
+(defn- render-hotspots [items]
+  (if (seq items)
+    (map (fn [{:keys [path age]}]
+           (format "  - {path: %s, age: %s}" (pr-str path) (pr-str age)))
+         items)
+    ["  - []"]))
+
+(defn- render-next-work [items]
+  (if (seq items)
+    (map #(str "  - " (pr-str %)) items)
+    ["  - \"noop\""]))
+
+(defn- render-targets [targets]
+  (format "targets: [%s]" (str/join "," (map pr-str (or targets [])))))
+
+(defn- render-policy [policy]
+  (format "policy: [%s]" (str/join "," (map pr-str policy))))
+
+(defn- sanitize-mode [mode]
+  (if (#{"review" "propose"} mode) mode "propose"))
+
+(defn build-context
+  "Return map of context tokens, including YAML header for prompts."
+  [{:keys [tasks policy repo recent-sec targets mode-hint]}
+   & {:as opts}]
+  (let [repo (or repo ".")
+        recent-sec (long (or recent-sec 180))
+        backlog (backlog-entries tasks)
+        pending (pending-items)
+        hotspots (recent-notes recent-sec)
+        policy-lines (policy-rules (or policy {}))
+        next-work (next-work-suggestions backlog pending hotspots)
+        branch (repo-branch repo)
+        head (repo-head repo)
+        header-lines (concat
+                      ["---  # agent_context"
+                       (format "repo:\n  branch: %s\n  head: %s\n  recent_window: %ss"
+                               branch head recent-sec)
+                       "pending:"]
+                      (render-pending pending)
+                      ["backlog:"]
+                      (render-backlog backlog)
+                      ["hotspots:"]
+                      (render-hotspots hotspots)
+                      [(render-targets (or targets []))
+                       (render-policy policy-lines)
+                       "next_work:"]
+                      (render-next-work next-work)
+                      [(format "mode: %s" (sanitize-mode mode-hint))
+                       "---"])
+        header (str (str/join "\n" header-lines) "\n")
+        queue-md (bulletize (take 7 (queue-lines tasks)))
+        hotspots-md (bulletize (map #(format "`%s` (%s)" (:path %) (:age %))
+                                     hotspots)
+                                "- (none)")
+        next-work-md (bulletize next-work "- noop")
+        diffstat-md "- (quiet)"]
+    {:context_header header
+     :ach_yaml header
+     :queue_md queue-md
+     :recent_files_md hotspots-md
+     :next_work_md next-work-md
+     :diffstat_md diffstat-md}))