bb.edn

{:min-bb-version "1.3.190"

 :paths ["packages/forj-mcp/src"
         "packages/forj-hooks/src"
         "packages/clj-init/src"]

 :deps {cheshire/cheshire {:mvn/version "5.13.0"}}

 :tasks
 {:requires ([babashka.fs :as fs]
             [cheshire.core :as json]
             [clojure.string :as str])

  dev
  {:doc "Start development environment"
   :task (println "forj dev environment - use bb mcp:dev to test MCP server")}

  test
  {:doc "Run all tests"
   :task (do
           (run 'test:mcp)
           (run 'test:hooks)
           (run 'test:skill))}

  test:mcp
  {:doc "Test MCP server"
   :task (shell "bb" "-cp" "packages/forj-mcp/src:packages/forj-hooks/src:packages/forj-mcp/test"
                "-m" "forj.mcp.test-runner")}

  test:hooks
  {:doc "Test hooks"
   :task (shell "bb" "-cp" "packages/forj-mcp/src:packages/forj-hooks/src:packages/forj-hooks/test"
                "-m" "forj.hooks.test-runner")}

  test:skill
  {:doc "Test skill definition"
   :task (shell "bb" "-cp" "packages/forj-skill/test"
                "-m" "forj.skill-test-runner")}

  mcp:dev
  {:doc "Run MCP server in dev mode (for testing)"
   :task (shell "bb" "-cp" "packages/forj-mcp/src:packages/forj-hooks/src" "-m" "forj.mcp.server")}

  mcp:install
  {:doc "Install forj-mcp as bbin script"
   :task (shell "bbin" "install" "." "--as" "forj-mcp" "--main-opts" "['-m' 'forj.mcp.server']")}

  eval
  {:doc "Evaluate Clojure code via forj (usage: bb eval '(+ 1 2)' or bb eval -p 1669 '(+ 1 2)')"
   :requires ([forj.mcp.tools :as tools]
              [cheshire.core :as json])
   :task (let [args *command-line-args*
               [port code] (if (= "-p" (first args))
                             [(parse-long (second args)) (nth args 2)]
                             [nil (first args)])
               result (tools/eval-code {:code code :port port})]
           (if (:success result)
             (println (:value result))
             (do (println "Error:" (:error result))
                 (System/exit 1))))}

  nrepl
  {:doc "Start nREPL server for forj development"
   :task (shell "bb" "--nrepl-server" "1669")}

  logs
  {:doc "View forj logs (tail -f)"
   :task (let [log-dir (str (fs/path (System/getProperty "user.home") ".forj" "logs"))]
           (if (fs/exists? log-dir)
             (shell "tail" "-f" (str (fs/path log-dir "mcp-server.log"))
                    (str (fs/path log-dir "session-start.log")))
             (println "No logs yet. Logs will be written to:" log-dir)))}

  logs:list
  {:doc "List all log files"
   :task (let [log-dir (str (fs/path (System/getProperty "user.home") ".forj" "logs"))]
           (if (fs/exists? log-dir)
             (shell "ls" "-lh" log-dir)
             (println "No logs yet. Logs will be written to:" log-dir)))}

  logs:errors
  {:doc "View error log"
   :task (let [error-log (str (fs/path (System/getProperty "user.home") ".forj" "logs" "errors.log"))]
           (if (fs/exists? error-log)
             (shell "cat" error-log)
             (println "No errors logged yet.")))}

  logs:clear
  {:doc "Clear all logs"
   :task (let [log-dir (str (fs/path (System/getProperty "user.home") ".forj" "logs"))]
           (when (fs/exists? log-dir)
             (doseq [f (fs/glob log-dir "*.log")]
               (fs/delete f))
             (println "Logs cleared.")))}

  cleanup:sessions
  {:doc "Remove session files older than 7 days from ~/.forj/sessions/"
   :task (let [sessions-dir (fs/path (System/getProperty "user.home") ".forj" "sessions")
               cutoff-ms (* 7 24 60 60 1000)
               now (System/currentTimeMillis)]
           (if (fs/exists? sessions-dir)
             (let [old-files (->> (fs/list-dir sessions-dir)
                                  (filter (fn [f]
                                            (let [modified (-> f fs/last-modified-time .toMillis)]
                                              (> (- now modified) cutoff-ms)))))]
               (if (seq old-files)
                 (do
                   (doseq [f old-files]
                     (fs/delete f)
                     (println "Deleted:" (fs/file-name f)))
                   (println (str "\n✓ Removed " (count old-files) " session file(s) older than 7 days.")))
                 (println "No session files older than 7 days found.")))
             (println "No sessions directory found at" (str sessions-dir))))}

  ;; Installation tasks
  install
  {:doc "Install forj. Flags: --claude, --opencode, --droid, --agent-teams. No flags shows interactive menu."
   :task (let [args (set *command-line-args*)
              claude? (contains? args "--claude")
              opencode? (contains? args "--opencode")
              droid? (contains? args "--droid")
              agent-teams? (contains? args "--agent-teams")
              ;; Determine platform choice
              choices (cond
                        ;; Explicit flags - skip menu
                        (or claude? opencode? droid?)
                        (cond-> #{}
                          claude? (conj :claude)
                          opencode? (conj :opencode)
                          droid? (conj :droid))
                        ;; No platform flag - show interactive menu
                        :else (do
                                (println "\n  forj - REPL-driven LLM development for Clojure\n")
                                (println "  Select your platform:\n")
                                (println "    [1] Claude Code (default)")
                                (println "    [2] OpenCode")
                                (println "    [3] Factory Droid")
                                (println "    [4] All")
                                (print "\n  Choice [1]: ")
                                (flush)
                                (let [input (str/trim (or (read-line) ""))]
                                  (case input
                                    "" #{:claude}
                                    "1" #{:claude}
                                    "2" #{:opencode}
                                    "3" #{:droid}
                                    "4" #{:claude :opencode :droid}
                                    (do (println "  Invalid choice, defaulting to Claude Code.")
                                        #{:claude})))))]
           ;; Dispatch based on choices
           (when (contains? choices :claude)
             (run 'install:mcp)
             (run 'install:hooks)
             (run 'install:skill)
             (when agent-teams?
               (run 'install:agent-teams)))
           (when (contains? choices :opencode)
             (run 'install:opencode))
           (when (contains? choices :droid)
             (run 'install:droid))
           (println (str "\n✓ forj installed for "
                         (str/join " + " (cond-> []
                                           (contains? choices :claude) (conj "Claude Code")
                                           (contains? choices :opencode) (conj "OpenCode")
                                           (contains? choices :droid) (conj "Factory Droid")))
                         (when agent-teams? " (with Agent Teams)")
                         "! Restart your editor to activate.")))}

  install:mcp
  {:doc "Install MCP server config via claude CLI (user scope)"
   :task (let [forj-path (System/getProperty "user.dir")
               launcher (str forj-path "/bin/forj-mcp")]
           ;; Remove existing forj config if present (ignore errors)
           (shell {:continue true} "claude" "mcp" "remove" "forj" "--scope" "user")
           ;; Add forj with correct launcher script
           (let [result (shell {:continue true} "claude" "mcp" "add" "forj" launcher "--scope" "user")]
             (if (zero? (:exit result))
               (println "✓ MCP server 'forj' installed (user scope)")
               (do
                 (println "⚠ Failed to install via claude CLI, check if 'claude' is in PATH")
                 (System/exit 1)))))}

  install:hooks
  {:doc "Install base hooks config to ~/.claude/settings.json"
   :task (let [forj-path (System/getProperty "user.dir")
               claude-dir (str (fs/path (System/getProperty "user.home") ".claude"))
               settings-file (str (fs/path claude-dir "settings.json"))
               existing (when (fs/exists? settings-file)
                          (json/parse-string (slurp settings-file) true))
               cp (str forj-path "/packages/forj-mcp/src:" forj-path "/packages/forj-hooks/src")
               hooks-config {:SessionStart [{:hooks [{:type "command"
                                                      :command (str "bb -cp " cp " -m forj.hooks.session-start")}]}]
                             :UserPromptSubmit [{:hooks [{:type "command"
                                                          :command (str "bb -cp " cp " -m forj.hooks.user-prompt")}]}]
                             :PreToolUse [{:matcher "Edit|Write|NotebookEdit"
                                           :hooks [{:type "command"
                                                    :command (str "bb -cp " cp " -m forj.hooks.paren-repair")}]}]}
               forj-permissions ["mcp__forj__*"
                                 "Bash(bb nrepl *)"
                                 "Bash(bb test *)"
                                 "Bash(clj-nrepl-eval *)"
                                 "Bash(clj-paren-repair *)"]
               existing-allow (get-in existing [:permissions :allow] [])
               merged-allow (vec (distinct (concat existing-allow forj-permissions)))
               new-config (-> existing
                              (update :hooks merge hooks-config)
                              (assoc-in [:permissions :allow] merged-allow))]
           (fs/create-dirs claude-dir)
           (spit settings-file (json/generate-string new-config {:pretty true}))
           (println "✓ Hooks config installed to" settings-file)
           (println "✓ forj MCP tools pre-approved (mcp__forj__*)"))}

  install:skill
  {:doc "Install forj skills (/clj-repl, /clj-init, /lisa-loop) to ~/.claude/skills/"
   :task (let [forj-path (System/getProperty "user.dir")
               skills-base (str (fs/path (System/getProperty "user.home") ".claude" "skills"))
               ;; Install clj-repl skill
               clj-repl-dir (str (fs/path skills-base "clj-repl"))
               clj-repl-source (str (fs/path forj-path "packages" "forj-skill" "SKILL.md"))
               _ (fs/create-dirs clj-repl-dir)
               _ (fs/copy clj-repl-source (str (fs/path clj-repl-dir "SKILL.md")) {:replace-existing true})
               _ (println "✓ /clj-repl skill installed to" clj-repl-dir)
               ;; Install clj-init skill (SKILL.md + templates)
               clj-init-dir (str (fs/path skills-base "clj-init"))
               clj-init-source (str (fs/path forj-path "packages" "forj-skill" "clj-init"))
               _ (fs/create-dirs clj-init-dir)
               _ (fs/copy (str (fs/path clj-init-source "SKILL.md"))
                          (str (fs/path clj-init-dir "SKILL.md")) {:replace-existing true})
               ;; Copy modules directory (composable scaffolding)
               modules-source (str (fs/path clj-init-source "modules"))
               modules-dest (str (fs/path clj-init-dir "modules"))
               _ (when (fs/exists? modules-dest)
                   (fs/delete-tree modules-dest))
               _ (fs/copy-tree modules-source modules-dest)
               ;; Copy versions.edn
               _ (fs/copy (str (fs/path clj-init-source "versions.edn"))
                          (str (fs/path clj-init-dir "versions.edn")) {:replace-existing true})
               ;; Copy templates directory (legacy, may remove later)
               templates-source (str (fs/path clj-init-source "templates"))
               templates-dest (str (fs/path clj-init-dir "templates"))
               _ (when (fs/exists? templates-dest)
                   (fs/delete-tree templates-dest))
               _ (when (fs/exists? templates-source)
                   (fs/copy-tree templates-source templates-dest))
               _ (println "✓ /clj-init skill installed to" clj-init-dir)
               ;; Install lisa-loop skill
               lisa-loop-dir (str (fs/path skills-base "lisa-loop"))
               lisa-loop-source (str (fs/path forj-path "packages" "forj-skill" "lisa-loop"))]
           (fs/create-dirs lisa-loop-dir)
           (fs/copy (str (fs/path lisa-loop-source "SKILL.md"))
                    (str (fs/path lisa-loop-dir "SKILL.md")) {:replace-existing true})
           (println "✓ /lisa-loop skill installed to" lisa-loop-dir))}

  install:agent-teams
  {:doc "Install Agent Teams support (experimental): hooks, skill, and env vars"
   :task (let [forj-path (System/getProperty "user.dir")
               claude-dir (str (fs/path (System/getProperty "user.home") ".claude"))
               settings-file (str (fs/path claude-dir "settings.json"))
               existing (when (fs/exists? settings-file)
                          (json/parse-string (slurp settings-file) true))
               cp (str forj-path "/packages/forj-mcp/src:" forj-path "/packages/forj-hooks/src")
               ;; Agent Teams hooks
               at-hooks {:TaskCompleted [{:hooks [{:type "command"
                                                    :command (str "bb -cp " cp " -m forj.hooks.task-completed")}]}]
                         :TeammateIdle [{:hooks [{:type "command"
                                                   :command (str "bb -cp " cp " -m forj.hooks.teammate-idle")}]}]}
               ;; Agent Teams env vars
               existing-env (get existing :env {})
               at-env (merge existing-env
                              {"CLAUDE_CODE_EXPERIMENTAL_AGENT_TEAMS" "1"
                               "FORJ_AGENT_TEAMS" "1"})
               new-config (-> existing
                              (update :hooks merge at-hooks)
                              (assoc :env at-env))]
           ;; Update settings.json with hooks + env
           (spit settings-file (json/generate-string new-config {:pretty true}))
           (println "✓ Agent Teams hooks installed (TaskCompleted, TeammateIdle)")
           (println "✓ Agent Teams env vars set (FORJ_AGENT_TEAMS, CLAUDE_CODE_EXPERIMENTAL_AGENT_TEAMS)")
           ;; Install agent-teams skill
           (let [skills-base (str (fs/path claude-dir "skills"))
                 at-dir (str (fs/path skills-base "lisa-agent-teams"))
                 at-source (str (fs/path forj-path "packages" "forj-skill" "lisa-agent-teams"))]
             (fs/create-dirs at-dir)
             (fs/copy (str (fs/path at-source "SKILL.md"))
                      (str (fs/path at-dir "SKILL.md")) {:replace-existing true})
             (println "✓ /lisa-agent-teams skill installed to" at-dir)))}

  install:opencode
  {:doc "Install forj for OpenCode (runs MCP, skills, and plugin tasks)"
   :task (do
           (run 'install:opencode:mcp)
           (run 'install:opencode:skills)
           (run 'install:opencode:hooks))}

  install:opencode:mcp
  {:doc "Install MCP server config into ~/.config/opencode/opencode.json"
   :task (let [forj-path (System/getProperty "user.dir")
               launcher (str forj-path "/bin/forj-mcp")
               opencode-dir (str (fs/path (System/getProperty "user.home") ".config" "opencode"))
               config-file (str (fs/path opencode-dir "opencode.json"))
               existing (when (fs/exists? config-file)
                          (json/parse-string (slurp config-file) true))
               forj-mcp-entry {:type "local"
                                :command [launcher]
                                :enabled true}
               new-config (-> (or existing {})
                              (assoc-in [:mcp :forj] forj-mcp-entry))]
           (fs/create-dirs opencode-dir)
           (spit config-file (json/generate-string new-config {:pretty true}))
           (println "✓ MCP server 'forj' installed to" config-file))}

  install:opencode:skills
  {:doc "Install forj skills to ~/.config/opencode/skills/"
   :task (let [forj-path (System/getProperty "user.dir")
               skills-base (str (fs/path (System/getProperty "user.home") ".config" "opencode" "skills"))
               ;; Install clj-repl skill
               clj-repl-dir (str (fs/path skills-base "clj-repl"))
               clj-repl-source (str (fs/path forj-path "packages" "forj-skill" "SKILL.md"))
               _ (fs/create-dirs clj-repl-dir)
               _ (fs/copy clj-repl-source (str (fs/path clj-repl-dir "SKILL.md")) {:replace-existing true})
               _ (println "✓ /clj-repl skill installed to" clj-repl-dir)
               ;; Install clj-init skill (SKILL.md + modules + versions.edn + templates)
               clj-init-dir (str (fs/path skills-base "clj-init"))
               clj-init-source (str (fs/path forj-path "packages" "forj-skill" "clj-init"))
               _ (fs/create-dirs clj-init-dir)
               ;; Prefer SKILL.opencode.md for OpenCode, fall back to SKILL.md
               clj-init-skill (let [oc (str (fs/path clj-init-source "SKILL.opencode.md"))]
                                (if (fs/exists? oc) oc (str (fs/path clj-init-source "SKILL.md"))))
               _ (fs/copy clj-init-skill
                          (str (fs/path clj-init-dir "SKILL.md")) {:replace-existing true})
               ;; Copy modules directory
               modules-source (str (fs/path clj-init-source "modules"))
               modules-dest (str (fs/path clj-init-dir "modules"))
               _ (when (fs/exists? modules-dest)
                   (fs/delete-tree modules-dest))
               _ (fs/copy-tree modules-source modules-dest)
               ;; Copy versions.edn
               _ (fs/copy (str (fs/path clj-init-source "versions.edn"))
                          (str (fs/path clj-init-dir "versions.edn")) {:replace-existing true})
               ;; Copy templates directory (legacy, may remove later)
               templates-source (str (fs/path clj-init-source "templates"))
               templates-dest (str (fs/path clj-init-dir "templates"))
               _ (when (fs/exists? templates-dest)
                   (fs/delete-tree templates-dest))
               _ (when (fs/exists? templates-source)
                   (fs/copy-tree templates-source templates-dest))
               _ (println "✓ /clj-init skill installed to" clj-init-dir)
               ;; Install lisa-loop skill
               lisa-loop-dir (str (fs/path skills-base "lisa-loop"))
               lisa-loop-source (str (fs/path forj-path "packages" "forj-skill" "lisa-loop"))
               ;; Prefer SKILL.opencode.md for OpenCode, fall back to SKILL.md
               lisa-loop-skill (let [oc (str (fs/path lisa-loop-source "SKILL.opencode.md"))]
                                 (if (fs/exists? oc) oc (str (fs/path lisa-loop-source "SKILL.md"))))]
           (fs/create-dirs lisa-loop-dir)
           (fs/copy lisa-loop-skill
                    (str (fs/path lisa-loop-dir "SKILL.md")) {:replace-existing true})
           (println "✓ /lisa-loop skill installed to" lisa-loop-dir))}

  install:opencode:hooks
  {:doc "Install OpenCode plugin (hooks) to ~/.opencode/plugins/"
   :task (let [forj-path (System/getProperty "user.dir")
               home (System/getProperty "user.home")
               plugins-dir (str (fs/path home ".opencode" "plugins"))
               plugin-source (str (fs/path forj-path "packages" "forj-opencode" "plugin.js"))
               link-path (str (fs/path plugins-dir "forj.js"))]
           ;; OpenCode scans ~/.opencode/plugins/*.{ts,js} for local plugins
           ;; (NOT ~/.config/opencode/plugins/ - that dir is not scanned)
           (fs/create-dirs plugins-dir)
           (fs/delete-if-exists link-path)
           ;; Clean up old locations
           (doseq [old [(str (fs/path home ".config" "opencode" "plugins" "forj"))
                        (str (fs/path home ".config" "opencode" "plugins" "forj.js"))]]
             (when (fs/exists? old)
               (if (fs/directory? old)
                 (fs/delete-tree old)
                 (fs/delete-if-exists old))
               (println "✓ Removed old plugin at" old)))
           (fs/create-sym-link link-path plugin-source)
           (println "✓ Plugin symlinked to" link-path))}

  ;; Factory Droid installation tasks
  install:droid
  {:doc "Install forj for Factory Droid (runs MCP, skills, and hooks tasks)"
   :task (do
           (run 'install:droid:mcp)
           (run 'install:droid:skills)
           (run 'install:droid:hooks))}

  install:droid:mcp
  {:doc "Install MCP server config via droid CLI"
   :task (let [forj-path (System/getProperty "user.dir")
               launcher (str forj-path "/bin/forj-mcp")]
           ;; Remove existing forj config if present (ignore errors)
           (shell {:continue true} "droid" "mcp" "remove" "forj")
           ;; Add forj with correct launcher script
           (let [result (shell {:continue true} "droid" "mcp" "add" "forj" launcher)]
             (if (zero? (:exit result))
               (println "✓ MCP server 'forj' installed for Factory Droid")
               (do
                 (println "⚠ Failed to install via droid CLI, check if 'droid' is in PATH")
                 (System/exit 1)))))}

  install:droid:hooks
  {:doc "Install hooks config to ~/.factory/settings.json"
   :task (let [forj-path (System/getProperty "user.dir")
               factory-dir (str (fs/path (System/getProperty "user.home") ".factory"))
               settings-file (str (fs/path factory-dir "settings.json"))
               existing (when (fs/exists? settings-file)
                          (json/parse-string (slurp settings-file) true))
               cp (str forj-path "/packages/forj-mcp/src:" forj-path "/packages/forj-hooks/src")
               hooks-config {:SessionStart [{:hooks [{:type "command"
                                                      :command (str "bb -cp " cp " -m forj.hooks.session-start")}]}]
                             :UserPromptSubmit [{:hooks [{:type "command"
                                                          :command (str "bb -cp " cp " -m forj.hooks.user-prompt")}]}]
                             :PreToolUse [{:matcher "Edit|Create"
                                           :hooks [{:type "command"
                                                    :command (str "bb -cp " cp " -m forj.hooks.paren-repair")}]}]}
               forj-allowlist ["bb nrepl *"
                               "bb test *"
                               "clj-nrepl-eval *"
                               "clj-paren-repair *"]
               existing-allow (get existing :commandAllowlist [])
               merged-allow (vec (distinct (concat existing-allow forj-allowlist)))
               new-config (-> (or existing {})
                              (update :hooks merge hooks-config)
                              (assoc :commandAllowlist merged-allow))]
           (fs/create-dirs factory-dir)
           (spit settings-file (json/generate-string new-config {:pretty true}))
           (println "✓ Hooks config installed to" settings-file)
           (println "✓ forj commands added to allowlist"))}

  install:droid:skills
  {:doc "Install forj skills (/clj-repl, /clj-init, /lisa-loop) to ~/.factory/skills/"
   :task (let [forj-path (System/getProperty "user.dir")
               skills-base (str (fs/path (System/getProperty "user.home") ".factory" "skills"))
               ;; Install clj-repl skill
               clj-repl-dir (str (fs/path skills-base "clj-repl"))
               clj-repl-source (str (fs/path forj-path "packages" "forj-skill" "SKILL.md"))
               _ (fs/create-dirs clj-repl-dir)
               _ (fs/copy clj-repl-source (str (fs/path clj-repl-dir "SKILL.md")) {:replace-existing true})
               _ (println "✓ /clj-repl skill installed to" clj-repl-dir)
               ;; Install clj-init skill (SKILL.md + modules + versions.edn + templates)
               clj-init-dir (str (fs/path skills-base "clj-init"))
               clj-init-source (str (fs/path forj-path "packages" "forj-skill" "clj-init"))
               _ (fs/create-dirs clj-init-dir)
               _ (fs/copy (str (fs/path clj-init-source "SKILL.md"))
                          (str (fs/path clj-init-dir "SKILL.md")) {:replace-existing true})
               ;; Copy modules directory
               modules-source (str (fs/path clj-init-source "modules"))
               modules-dest (str (fs/path clj-init-dir "modules"))
               _ (when (fs/exists? modules-dest)
                   (fs/delete-tree modules-dest))
               _ (fs/copy-tree modules-source modules-dest)
               ;; Copy versions.edn
               _ (fs/copy (str (fs/path clj-init-source "versions.edn"))
                          (str (fs/path clj-init-dir "versions.edn")) {:replace-existing true})
               ;; Copy templates directory (legacy)
               templates-source (str (fs/path clj-init-source "templates"))
               templates-dest (str (fs/path clj-init-dir "templates"))
               _ (when (fs/exists? templates-dest)
                   (fs/delete-tree templates-dest))
               _ (when (fs/exists? templates-source)
                   (fs/copy-tree templates-source templates-dest))
               _ (println "✓ /clj-init skill installed to" clj-init-dir)
               ;; Install lisa-loop skill
               lisa-loop-dir (str (fs/path skills-base "lisa-loop"))
               lisa-loop-source (str (fs/path forj-path "packages" "forj-skill" "lisa-loop"))]
           (fs/create-dirs lisa-loop-dir)
           (fs/copy (str (fs/path lisa-loop-source "SKILL.md"))
                    (str (fs/path lisa-loop-dir "SKILL.md")) {:replace-existing true})
           (println "✓ /lisa-loop skill installed to" lisa-loop-dir))}

  check-versions
  {:doc "Check template dependency versions against latest available"
   :task (shell "bb" "-f" "scripts/check_versions.clj")}

  uninstall
  {:doc "Remove forj from all platforms. Flags: --claude, --opencode, --droid. No flags removes all."
   :task (let [args (set *command-line-args*)
               claude? (contains? args "--claude")
               opencode? (contains? args "--opencode")
               droid? (contains? args "--droid")
               any-flag? (or claude? opencode? droid?)
               do-claude? (or claude? (not any-flag?))
               do-opencode? (or opencode? (not any-flag?))
               do-droid? (or droid? (not any-flag?))]
           (when do-claude?
             (run 'uninstall:claude))
           (when do-opencode?
             (run 'uninstall:opencode))
           (when do-droid?
             (run 'uninstall:droid))
           (println (str "\n✓ forj uninstalled"
                         (let [platforms (cond-> []
                                          do-claude? (conj "Claude Code")
                                          do-opencode? (conj "OpenCode")
                                          do-droid? (conj "Factory Droid"))]
                           (str " from " (str/join " + " platforms) "."))
                         " Restart your editor to complete.")))}

  uninstall:claude
  {:doc "Remove forj from Claude Code config"
   :task (let [claude-dir (str (fs/path (System/getProperty "user.home") ".claude"))
               settings-file (str (fs/path claude-dir "settings.json"))
               skills-dir (str (fs/path claude-dir "skills"))
               skill-names ["clj-repl" "clj-init" "lisa-loop" "lisa-agent-teams"]]
           ;; Remove MCP server via claude CLI
           (let [result (shell {:continue true} "claude" "mcp" "remove" "forj" "--scope" "user")]
             (if (zero? (:exit result))
               (println "✓ Removed forj MCP server from Claude Code")
               (println "⚠ forj MCP server not found or already removed")))
           ;; Remove hooks and agent-teams env vars
           (when (fs/exists? settings-file)
             (let [config (json/parse-string (slurp settings-file) true)
                   new-config (-> config
                                  (update :hooks dissoc :SessionStart :UserPromptSubmit :PreToolUse :TaskCompleted :TeammateIdle)
                                  (update :env dissoc "FORJ_AGENT_TEAMS" "CLAUDE_CODE_EXPERIMENTAL_AGENT_TEAMS"))]
               (spit settings-file (json/generate-string new-config {:pretty true}))
               (println "✓ Removed hooks and env vars from" settings-file)))
           ;; Remove all forj skills
           (doseq [name skill-names]
             (let [dir (str (fs/path skills-dir name))]
               (when (fs/exists? dir)
                 (fs/delete-tree dir)
                 (println (str "✓ Removed /" name " skill from Claude Code"))))))}

  uninstall:opencode
  {:doc "Remove forj from OpenCode config"
   :task (let [home (System/getProperty "user.home")
               opencode-dir (str (fs/path home ".config" "opencode"))
               config-file (str (fs/path opencode-dir "opencode.json"))
               skills-dir (str (fs/path opencode-dir "skills"))
               skill-names ["clj-repl" "clj-init" "lisa-loop"]]
           ;; Remove forj MCP entry from opencode.json
           (when (fs/exists? config-file)
             (let [config (json/parse-string (slurp config-file) true)
                   new-config (update config :mcp dissoc :forj)]
               (spit config-file (json/generate-string new-config {:pretty true}))
               (println "✓ Removed forj MCP entry from" config-file)))
           ;; Remove skills
           (doseq [name skill-names]
             (let [dir (str (fs/path skills-dir name))]
               (when (fs/exists? dir)
                 (fs/delete-tree dir)
                 (println (str "✓ Removed /" name " skill from OpenCode")))))
           ;; Remove plugin symlink from ~/.opencode/plugins/
           (let [link-path (str (fs/path home ".opencode" "plugins" "forj.js"))]
             (when (fs/exists? link-path)
               (fs/delete-if-exists link-path)
               (println "✓ Removed forj plugin from" link-path)))
           ;; Clean up old locations
           (doseq [old [(str (fs/path opencode-dir "plugins" "forj"))
                        (str (fs/path opencode-dir "plugins" "forj.js"))]]
             (when (fs/exists? old)
               (if (fs/directory? old)
                 (fs/delete-tree old)
                 (fs/delete-if-exists old))
               (println "✓ Removed old plugin at" old))))}

  uninstall:droid
  {:doc "Remove forj from Factory Droid config"
   :task (let [home (System/getProperty "user.home")
               factory-dir (str (fs/path home ".factory"))
               settings-file (str (fs/path factory-dir "settings.json"))
               skills-dir (str (fs/path factory-dir "skills"))
               skill-names ["clj-repl" "clj-init" "lisa-loop"]]
           ;; Remove MCP server via droid CLI
           (let [result (shell {:continue true} "droid" "mcp" "remove" "forj")]
             (if (zero? (:exit result))
               (println "✓ Removed forj MCP server from Factory Droid")
               (println "⚠ forj MCP server not found or already removed")))
           ;; Remove hooks and allowlist entries
           (when (fs/exists? settings-file)
             (let [config (json/parse-string (slurp settings-file) true)
                   forj-allowlist #{"bb nrepl *" "bb test *" "clj-nrepl-eval *" "clj-paren-repair *"}
                   new-config (-> config
                                  (update :hooks dissoc :SessionStart :UserPromptSubmit :PreToolUse)
                                  (update :commandAllowlist
                                          (fn [allow]
                                            (vec (remove forj-allowlist (or allow []))))))]
               (spit settings-file (json/generate-string new-config {:pretty true}))
               (println "✓ Removed hooks and allowlist entries from" settings-file)))
           ;; Remove all forj skills
           (doseq [name skill-names]
             (let [dir (str (fs/path skills-dir name))]
               (when (fs/exists? dir)
                 (fs/delete-tree dir)
                 (println (str "✓ Removed /" name " skill from Factory Droid"))))))}}}