@nbardy/oompa 0.1.0

package/agentnet/src/agentnet/worktree.clj

@@ -0,0 +1,342 @@
+(ns agentnet.worktree
+  "Git worktree management for isolated agent workspaces.
+
+   Each agent gets its own worktree (directory + branch) so they can
+   work in parallel without stepping on each other.
+
+   Lifecycle:
+     1. init-pool!     - Create N worktrees at startup
+     2. acquire!       - Claim a worktree for a task
+     3. (agent works)  - Agent modifies files, commits
+     4. release!       - Mark worktree available, optionally reset
+     5. cleanup-pool!  - Remove all worktrees at shutdown
+
+   Design:
+     - Worktrees live in .workers/ directory
+     - Each worktree has its own branch: work/<worktree-id>
+     - State tracked in .workers/state.edn
+     - All git operations are idempotent"
+  (:require [agentnet.schema :as schema]
+            [babashka.process :as process]
+            [clojure.java.io :as io]
+            [clojure.edn :as edn]
+            [clojure.string :as str]))
+
+;; =============================================================================
+;; Function Specs (Hickey-style: data in, data out)
+;; =============================================================================
+
+;; init-pool! : OrchestratorConfig -> WorktreePool
+;; Creates N worktrees in .workers/ directory, returns pool state
+
+;; acquire! : WorktreePool, TaskId -> [WorktreePool, Worktree | nil]
+;; Claims first available worktree for task, returns updated pool + worktree
+
+;; release! : WorktreePool, WorktreeId, {:reset? bool} -> WorktreePool
+;; Releases worktree back to pool, optionally resets to main
+
+;; sync-to-main! : Worktree -> Worktree
+;; Rebases worktree branch onto main, returns updated worktree
+
+;; status : WorktreeId -> Worktree
+;; Gets current state of worktree
+
+;; cleanup-pool! : WorktreePool -> nil
+;; Removes all worktrees and their branches
+
+;; =============================================================================
+;; Constants
+;; =============================================================================
+
+(def ^:const WORKERS_DIR ".workers")
+(def ^:const STATE_FILE ".workers/state.edn")
+(def ^:const BRANCH_PREFIX "work/")
+
+;; =============================================================================
+;; Git Helpers (pure where possible)
+;; =============================================================================
+
+(defn- git
+  "Run git command, return {:exit :out :err}"
+  [& args]
+  (let [cmd (into ["git"] args)
+        {:keys [exit out err]} (process/sh cmd {:out :string :err :string})]
+    {:exit exit
+     :out (str/trim (or out ""))
+     :err (str/trim (or err ""))}))
+
+(defn- git!
+  "Run git command, throw on failure"
+  [& args]
+  (let [{:keys [exit out err]} (apply git args)]
+    (if (zero? exit)
+      out
+      (throw (ex-info (str "git failed: " err)
+                      {:command args :exit exit :err err})))))
+
+(defn- git-in
+  "Run git command in specific directory"
+  [dir & args]
+  (apply git "-C" dir args))
+
+(defn- git-in!
+  "Run git command in specific directory, throw on failure"
+  [dir & args]
+  (apply git! "-C" dir args))
+
+(defn- current-branch
+  "Get current branch name"
+  ([] (git! "rev-parse" "--abbrev-ref" "HEAD"))
+  ([dir] (git-in! dir "rev-parse" "--abbrev-ref" "HEAD")))
+
+(defn- current-sha
+  "Get current commit SHA"
+  ([] (git! "rev-parse" "HEAD"))
+  ([dir] (git-in! dir "rev-parse" "HEAD")))
+
+(defn- branch-exists?
+  "Check if branch exists"
+  [branch]
+  (zero? (:exit (git "rev-parse" "--verify" branch))))
+
+(defn- worktree-exists?
+  "Check if worktree path exists"
+  [path]
+  (let [{:keys [out]} (git "worktree" "list" "--porcelain")]
+    (str/includes? out path)))
+
+;; =============================================================================
+;; State Persistence
+;; =============================================================================
+
+(defn- now-ms []
+  (System/currentTimeMillis))
+
+(defn- ensure-workers-dir! []
+  (.mkdirs (io/file WORKERS_DIR)))
+
+(defn- save-state! [pool]
+  (ensure-workers-dir!)
+  (spit STATE_FILE (pr-str pool))
+  pool)
+
+(defn- load-state []
+  (let [f (io/file STATE_FILE)]
+    (when (.exists f)
+      (edn/read-string (slurp f)))))
+
+;; =============================================================================
+;; Worktree CRUD
+;; =============================================================================
+
+(defn- worktree-path [worktree-id]
+  (str WORKERS_DIR "/" worktree-id))
+
+(defn- worktree-branch [worktree-id]
+  (str BRANCH_PREFIX worktree-id))
+
+(defn- create-worktree!
+  "Create a single worktree with its branch"
+  [worktree-id]
+  (let [path (worktree-path worktree-id)
+        branch (worktree-branch worktree-id)]
+    (ensure-workers-dir!)
+    ;; Remove stale worktree if exists
+    (when (worktree-exists? path)
+      (git! "worktree" "remove" "--force" path))
+    ;; Remove stale branch if exists
+    (when (branch-exists? branch)
+      (git! "branch" "-D" branch))
+    ;; Create fresh worktree with new branch from HEAD
+    (git! "worktree" "add" "-b" branch path "HEAD")
+    {:id worktree-id
+     :path path
+     :branch branch
+     :status :available
+     :current-task nil
+     :created-at (now-ms)
+     :last-used nil}))
+
+(defn- remove-worktree!
+  "Remove a single worktree and its branch"
+  [worktree]
+  (let [{:keys [path branch]} worktree]
+    (when (worktree-exists? path)
+      (git "worktree" "remove" "--force" path))
+    (when (branch-exists? branch)
+      (git "branch" "-D" branch))
+    nil))
+
+(defn- reset-worktree!
+  "Reset worktree to match main branch"
+  [worktree]
+  (let [{:keys [path branch]} worktree
+        main-branch (current-branch)]
+    ;; Fetch latest main
+    (git-in! path "fetch" "." (str main-branch ":" main-branch))
+    ;; Hard reset to main
+    (git-in! path "reset" "--hard" main-branch)
+    ;; Clean untracked files
+    (git-in! path "clean" "-fd")
+    (assoc worktree
+           :status :available
+           :current-task nil
+           :last-used (now-ms))))
+
+(defn- worktree-dirty?
+  "Check if worktree has uncommitted changes"
+  [worktree]
+  (let [{:keys [path]} worktree
+        {:keys [out]} (git-in path "status" "--porcelain")]
+    (not (str/blank? out))))
+
+(defn- refresh-worktree-status
+  "Update worktree status based on git state"
+  [worktree]
+  (let [{:keys [path]} worktree]
+    (cond
+      (not (.exists (io/file path)))
+      (assoc worktree :status :stale)
+
+      (worktree-dirty? worktree)
+      (assoc worktree :status :dirty)
+
+      (:current-task worktree)
+      (assoc worktree :status :busy)
+
+      :else
+      (assoc worktree :status :available))))
+
+;; =============================================================================
+;; Pool Management
+;; =============================================================================
+
+(defn init-pool!
+  "Create a pool of N worktrees. Idempotent - reuses existing if clean."
+  [{:keys [worker-count worktree-root] :as config}]
+  (schema/assert-valid schema/valid-orchestrator-config? config "OrchestratorConfig")
+  (ensure-workers-dir!)
+  (let [existing (or (load-state) [])
+        existing-ids (set (map :id existing))
+        needed-ids (map #(str "worker-" %) (range worker-count))
+        ;; Create missing worktrees
+        pool (mapv (fn [id]
+                     (if (contains? existing-ids id)
+                       (-> (first (filter #(= (:id %) id) existing))
+                           refresh-worktree-status)
+                       (create-worktree! id)))
+                   needed-ids)]
+    (save-state! pool)))
+
+(defn acquire!
+  "Claim an available worktree for a task. Returns [pool worktree] or [pool nil]."
+  [pool task-id]
+  (schema/assert-valid schema/non-blank-string? task-id "TaskId")
+  (if-let [idx (first (keep-indexed
+                        (fn [i wt]
+                          (when (= :available (:status wt)) i))
+                        pool))]
+    (let [worktree (-> (get pool idx)
+                       (assoc :status :busy
+                              :current-task task-id
+                              :last-used (now-ms)))
+          new-pool (assoc pool idx worktree)]
+      (save-state! new-pool)
+      [new-pool worktree])
+    [pool nil]))
+
+(defn release!
+  "Release a worktree back to the pool."
+  [pool worktree-id {:keys [reset?] :or {reset? true}}]
+  (if-let [idx (first (keep-indexed
+                        (fn [i wt]
+                          (when (= (:id wt) worktree-id) i))
+                        pool))]
+    (let [worktree (get pool idx)
+          updated (if reset?
+                    (reset-worktree! worktree)
+                    (assoc worktree
+                           :status :available
+                           :current-task nil))
+          new-pool (assoc pool idx updated)]
+      (save-state! new-pool))
+    pool))
+
+(defn sync-to-main!
+  "Rebase worktree branch onto current main. Returns updated worktree."
+  [worktree]
+  (let [{:keys [path branch]} worktree
+        main (current-branch)]
+    ;; Fetch main into worktree
+    (git-in! path "fetch" "origin" main)
+    ;; Rebase onto main
+    (let [{:keys [exit err]} (git-in path "rebase" (str "origin/" main))]
+      (if (zero? exit)
+        (assoc worktree :status :available)
+        ;; Abort failed rebase
+        (do
+          (git-in path "rebase" "--abort")
+          (throw (ex-info "Rebase failed" {:worktree worktree :error err})))))))
+
+(defn status
+  "Get current status of a worktree by ID"
+  [pool worktree-id]
+  (when-let [worktree (first (filter #(= (:id %) worktree-id) pool))]
+    (refresh-worktree-status worktree)))
+
+(defn cleanup-pool!
+  "Remove all worktrees and clean up state"
+  [pool]
+  (doseq [worktree pool]
+    (remove-worktree! worktree))
+  (when (.exists (io/file STATE_FILE))
+    (io/delete-file STATE_FILE))
+  nil)
+
+(defn list-worktrees
+  "List all worktrees with current status"
+  [pool]
+  (mapv refresh-worktree-status pool))
+
+;; =============================================================================
+;; Convenience Functions
+;; =============================================================================
+
+(defn with-worktree
+  "Execute function with an acquired worktree, auto-release on completion.
+
+   Usage:
+     (with-worktree pool task-id
+       (fn [worktree]
+         (do-work-in (:path worktree))))"
+  [pool task-id f]
+  (let [[pool' worktree] (acquire! pool task-id)]
+    (if worktree
+      (try
+        (let [result (f worktree)]
+          [(release! pool' (:id worktree) {:reset? false}) result])
+        (catch Exception e
+          [(release! pool' (:id worktree) {:reset? true}) nil]))
+      (throw (ex-info "No available worktrees" {:pool pool :task-id task-id})))))
+
+(defn commit-in-worktree!
+  "Create a commit in the worktree"
+  [worktree message]
+  (let [{:keys [path]} worktree]
+    (git-in! path "add" "-A")
+    (let [{:keys [exit]} (git-in path "diff" "--cached" "--quiet")]
+      (when-not (zero? exit)  ; there are staged changes
+        (git-in! path "commit" "-m" message)))))
+
+(defn diff-in-worktree
+  "Get the diff of uncommitted changes in worktree"
+  [worktree]
+  (let [{:keys [path]} worktree]
+    (:out (git-in path "diff"))))
+
+(defn log-in-worktree
+  "Get commit log for worktree branch (since divergence from main)"
+  [worktree]
+  (let [{:keys [path branch]} worktree
+        main (current-branch)]
+    (:out (git-in path "log" "--oneline" (str main ".." branch)))))

package/bin/oompa.js

@@ -0,0 +1,37 @@
+#!/usr/bin/env node
+"use strict";
+
+const fs = require("node:fs");
+const path = require("node:path");
+const { spawnSync } = require("node:child_process");
+
+const packageRoot = path.resolve(__dirname, "..");
+const swarmScript = path.join(packageRoot, "swarm.bb");
+const classpath = path.join(packageRoot, "agentnet", "src");
+const argv = process.argv.slice(2);
+
+if (!fs.existsSync(swarmScript) || !fs.existsSync(classpath)) {
+  console.error("oompa package installation is incomplete.");
+  process.exit(1);
+}
+
+const result = spawnSync("bb", ["--classpath", classpath, swarmScript, ...argv], {
+  stdio: "inherit",
+  cwd: process.cwd(),
+  env: process.env
+});
+
+if (result.error) {
+  if (result.error.code === "ENOENT") {
+    console.error("Babashka (bb) is required. Install: https://github.com/babashka/babashka");
+  } else {
+    console.error(`Failed to run bb: ${result.error.message}`);
+  }
+  process.exit(1);
+}
+
+if (typeof result.status === "number") {
+  process.exit(result.status);
+}
+
+process.exit(1);

package/config/prompts/cto.md

@@ -0,0 +1,45 @@
+{context_header}
+
+<rules>
+  <prompt_metadata>
+    Type: Codebase Consolidation & Review
+    Purpose: Unify style, simplify interfaces, clarify data model invariants
+    Paradigm: Metamorphic Refactoring with Semantic Invariants
+    Constraints: Patch-only output; allowed paths = {targets}; sandboxed FS
+    Objective: {mode_hint} with emphasis on hotspots last {recent_sec}s
+  </prompt_metadata>
+
+  <think privacy="internal">?(trace types, data flows, invariants) → !(minimal behavior-preserving refactor)</think>
+
+  <context>
+Queue:
+{queue_md}
+
+Hotspots:
+{recent_files_md}
+
+Diffstat:
+{diffstat_md}
+
+Next work:
+{next_work_md}
+  </context>
+
+  <answer_operator>
+    If {mode_hint} == "review":
+      - Inspect `.agent/patch.diff` (or repo deltas if empty); decide approve vs change.
+      - If acceptable, create empty `.agent/{approval_token}`.
+      - Else, write concise bullets to `.agent/review.txt` (no chain-of-thought).
+    Else:
+      - Identify the highest leverage consolidation from context.
+      - Emit unified diff to `.agent/patch.diff` (no prose).
+      - Emit `.agent/meta.json` with touched files and summary.
+  </answer_operator>
+
+  <checklist>
+    - Respect allowed paths only: {targets}
+    - Prefer deletions/simplifications over additions.
+    - Preserve behaviour unless requirement allows otherwise.
+    - Update docs/tests only if the change requires it.
+  </checklist>
+</rules>

package/config/prompts/engineer.md

@@ -0,0 +1,44 @@
+{context_header}
+
+<rules>
+  <prompt_metadata>
+    Type: Implementation & Local Refactor
+    Purpose: Deliver focused patches; reduce local entropy
+    Paradigm: Small, Composable Transformations
+    Constraints: Patch-only; allowed paths = {targets}
+    Objective: complete assigned task or propose safe maintenance
+  </prompt_metadata>
+
+  <think privacy="internal">?(spec → invariants → tests → diff) → !(smallest-correct-change)</think>
+
+  <context>
+Queue:
+{queue_md}
+
+Hotspots:
+{recent_files_md}
+
+Diffstat:
+{diffstat_md}
+
+Next work:
+{next_work_md}
+  </context>
+
+  <answer_operator>
+    If task provided:
+      - Implement the requirement with minimal surface area.
+      - Update tests/docs only if necessary for the change.
+      - Emit `.agent/patch.diff` and `.agent/meta.json`.
+    Else:
+      - Choose one maintenance action tied to recent hotspots.
+      - Keep the diff minimal; respect policy constraints.
+  </answer_operator>
+
+  <checklist>
+    - Allowed paths only: {targets}
+    - No direct file edits outside `.agent/*`.
+    - Capture patch via unified diff; no prose in diff.
+    - Ensure new names/types align with existing style.
+  </checklist>
+</rules>

package/config/prompts/executor.md

@@ -0,0 +1,32 @@
+Goal: Execute tasks from tasks/pending/
+Process: Claim task (mv pending/ → current/), execute, complete (mv current/ → complete/)
+Method: Isolate changes to your worktree, commit and merge when complete
+
+## Your Role
+
+You are an executor. You:
+- Claim and execute tasks
+- Do NOT create new tasks
+- Do NOT plan or design
+- Just execute what's assigned
+
+## Workflow
+
+1. Pick a task from tasks/pending/
+2. Move it to tasks/current/
+3. Execute the task in your worktree
+4. Commit your changes
+5. Move task to tasks/complete/
+6. Merge your worktree to main
+
+## Guidelines
+
+- Focus on one task at a time
+- Follow the task description exactly
+- If a task is unclear, skip it (leave in pending/)
+- Keep changes minimal and focused
+
+## Exit Condition
+
+When tasks/pending/ is empty:
+Output: __DONE__

package/config/prompts/planner.md

@@ -0,0 +1,35 @@
+Goal: Break spec.md into executable tasks
+Process: Create tasks in tasks/pending/*.edn
+Method: Do NOT write code. Only create and refine tasks.
+
+## Your Role
+
+You are a planner. You:
+- Read spec.md to understand the goal
+- Create small, focused tasks in tasks/pending/
+- Monitor progress by checking tasks/complete/
+- Refine or split tasks that are too large
+- Do NOT execute tasks yourself
+
+## Task Creation
+
+Write .edn files to tasks/pending/:
+```edn
+{:id "task-001"
+ :summary "Add user authentication"
+ :description "Implement JWT-based auth for the API"
+ :files ["src/auth.py" "tests/test_auth.py"]
+ :acceptance ["Login endpoint returns token" "Tests pass"]}
+```
+
+## Guidelines
+
+- Keep tasks small (1-2 files max)
+- Be specific about acceptance criteria
+- Consider dependencies between tasks
+- Check what's already complete before creating duplicates
+
+## Exit Condition
+
+When spec.md is fully covered by tasks and all are complete:
+Output: __DONE__

package/config/prompts/reviewer.md

@@ -0,0 +1,49 @@
+Goal: Review changes for correctness before merge
+Process: Check diff against task requirements
+Method: Approve, request changes, or reject
+
+## Your Role
+
+You are a reviewer. You:
+- Check code changes for correctness
+- Verify changes match the intended task
+- Look for obvious bugs or issues
+- Do NOT write code yourself
+
+## Review Criteria
+
+1. **Correctness**: Does the code work as intended?
+2. **Completeness**: Does it fully address the task?
+3. **Quality**: No obvious bugs, security issues, or regressions?
+4. **Focus**: Changes are minimal and on-target?
+
+## Response Format
+
+Respond with ONE of:
+
+**APPROVED** - Changes are good to merge
+```
+APPROVED
+- Clean implementation
+- Tests pass
+```
+
+**NEEDS_CHANGES** - Fixable issues found
+```
+NEEDS_CHANGES
+- Issue 1: description
+- Issue 2: description
+```
+
+**REJECTED** - Fundamentally wrong approach
+```
+REJECTED
+- Reason: wrong approach, should use X instead
+```
+
+## Guidelines
+
+- Be concise and specific
+- List actionable items for NEEDS_CHANGES
+- Err on the side of APPROVED for minor style issues
+- REJECTED is for wrong direction, not small bugs

package/config/prompts/worker.md

@@ -0,0 +1,31 @@
+Goal: Match spec.md
+Process: Create/claim tasks in tasks/{pending,current,complete}/*.edn
+Method: Isolate changes to your worktree, commit and merge when complete
+
+## Task Management
+
+Check tasks/pending/ for available work:
+- To claim: move file from pending/ to current/
+- To complete: move file from current/ to complete/
+- To create: write new .edn file to pending/
+
+Task file format:
+```edn
+{:id "task-001"
+ :summary "Short description"
+ :description "Detailed description"
+ :files ["src/foo.py"]}
+```
+
+## Workflow
+
+1. Check if tasks/pending/ has tasks
+2. If yes: claim one (mv to current/), execute it, complete it (mv to complete/)
+3. If no: check spec.md for gaps, create new tasks if needed
+4. Commit changes to your worktree
+5. Merge your worktree branch to main
+
+## Exit Condition
+
+When spec.md is fully satisfied and no more tasks are needed:
+Output: __DONE__

package/oompa.example.json

@@ -0,0 +1,18 @@
+{
+  "review_model": "codex:codex-5.2",
+
+  "workers": [
+    {
+      "model": "claude:opus-4.5",
+      "iterations": 5,
+      "count": 1,
+      "prompt": "config/prompts/planner.md"
+    },
+    {
+      "model": "codex:codex-5.2-mini",
+      "iterations": 10,
+      "count": 3,
+      "prompt": "config/prompts/executor.md"
+    }
+  ]
+}

package/package.json

@@ -0,0 +1,45 @@
+{
+  "name": "@nbardy/oompa",
+  "version": "0.1.0",
+  "description": "Git-worktree multi-agent swarm orchestrator for Codex and Claude",
+  "license": "MIT",
+  "type": "commonjs",
+  "bin": {
+    "oompa": "bin/oompa.js"
+  },
+  "files": [
+    "bin/",
+    "swarm.bb",
+    "agentnet/src/",
+    "config/prompts/",
+    "oompa.example.json",
+    "README.md"
+  ],
+  "scripts": {
+    "check": "node bin/oompa.js check",
+    "help": "node bin/oompa.js help",
+    "pack:dry": "npm pack --dry-run"
+  },
+  "engines": {
+    "node": ">=18"
+  },
+  "keywords": [
+    "agents",
+    "swarm",
+    "worktree",
+    "codex",
+    "claude",
+    "babashka"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/nbardy/oompa.git"
+  },
+  "bugs": {
+    "url": "https://github.com/nbardy/oompa/issues"
+  },
+  "homepage": "https://github.com/nbardy/oompa#readme",
+  "publishConfig": {
+    "access": "public"
+  }
+}