brainiac-basecamp 0.0.1

data/lib/brainiac/plugins/basecamp.rb

@@ -0,0 +1,314 @@
+# frozen_string_literal: true
+
+require_relative "basecamp/version"
+require_relative "basecamp/metadata"
+require_relative "basecamp/config"
+require_relative "basecamp/client"
+require_relative "basecamp/epic"
+require_relative "basecamp/epic_branch"
+require_relative "basecamp/review_gate"
+require_relative "basecamp/orchestrator"
+require_relative "basecamp/webhook"
+require_relative "basecamp/hooks"
+require_relative "basecamp/prompts"
+require_relative "basecamp/cli"
+
+module Brainiac
+  module Plugins
+    module Basecamp
+      class << self
+        # Called by Brainiac plugin system during server startup.
+        #
+        # @param app [Sinatra::Application] The running Brainiac server
+        def register(app)
+          Config.load!
+
+          # Register lifecycle hooks
+          Hooks.register_all!
+
+          # Register channel prompt (for when agents need Basecamp awareness)
+          Brainiac.register_channel_prompt(:basecamp, Prompts::CHANNEL)
+
+          # Set up routes
+          setup_routes(app)
+
+          # Log active epics on startup and resume them
+          active = Orchestrator.active_epics
+          if active.any?
+            LOG.info "[Basecamp] #{active.size} active epic(s) in progress"
+            active.each { |e| LOG.info "[Basecamp]   - #{e['title']} (#{e['tasks']&.count { |t| t['status'] == 'complete' }}/#{e['tasks']&.size} complete)" }
+
+            # Resume active epics in background after server is ready
+            Thread.new do
+              sleep 10 # Wait for server to fully start
+              resume_active_epics(active)
+            rescue StandardError => e
+              LOG.error "[Basecamp] Error resuming epics: #{e.message}" if defined?(LOG)
+            end
+          end
+
+          LOG.info "[Basecamp] Plugin registered (webhook: /basecamp, review_gate: #{Config.review_gate})"
+        end
+
+        private
+
+        # Resume active epics on server startup.
+        # For each epic, checks task states and takes appropriate action.
+        def resume_active_epics(epics)
+          epics.each do |epic|
+            LOG.info "[Basecamp] Resuming epic: #{epic['title']}" if defined?(LOG)
+
+            # Check if all tasks are complete — finalize the epic
+            if epic["tasks"]&.all? { |t| t["status"] == "complete" }
+              LOG.info "[Basecamp] Resume: all tasks complete — finalizing epic" if defined?(LOG)
+
+              # Mark each Basecamp todo as complete (in case they weren't marked during normal flow)
+              epic["tasks"].each do |task|
+                Orchestrator.send(:mark_todo_complete, epic, task["fizzy_card"])
+              end
+
+              Orchestrator.send(:complete_epic, epic)
+              Orchestrator.send(:save_epic, epic)
+              next
+            end
+
+            epic["tasks"]&.each do |task|
+              card_number = task["fizzy_card"]
+              status = task["status"]
+              LOG.info "[Basecamp] Resume: task ##{card_number} status=#{status}" if defined?(LOG)
+
+              case status
+              when "in_review", "in_flight"
+                # Sync gate state from GitHub and decide next action
+                resume_in_review_task(epic, task)
+              when "final_decision"
+                # Final decision was pending — check if we can merge
+                resume_final_decision_task(epic, task)
+              when "pending"
+                # Check if dependencies are met and dispatch
+                # (This is handled by dispatch_unblocked_tasks normally)
+                next
+              end
+            end
+
+            # Dispatch any unblocked tasks
+            Orchestrator.send(:dispatch_unblocked_tasks, epic)
+          end
+        end
+
+        def resume_in_review_task(epic, task)
+          card_number = task["fizzy_card"]
+          pr_number = task["pr_number"]
+
+          unless pr_number
+            LOG.info "[Basecamp] Task ##{card_number} has no PR yet — skipping resume" if defined?(LOG)
+            return
+          end
+
+          # Get project config for repo path
+          project_key = task["project"]
+          projects_file = File.join(ENV.fetch("BRAINIAC_DIR", File.join(Dir.home, ".brainiac")), "projects.json")
+          projects = File.exist?(projects_file) ? JSON.parse(File.read(projects_file)) : {}
+          repo_path = projects.dig(project_key, "repo_path")
+
+          unless repo_path
+            LOG.warn "[Basecamp] No repo_path for project #{project_key}" if defined?(LOG)
+            return
+          end
+
+          # Sync gate approvals from GitHub
+          sync_result = ReviewGate.sync_from_github(task, repo_path: repo_path)
+          if sync_result[:synced]
+            changes = sync_result[:changes] || {}
+            if changes[:approvals_added]&.any?
+              LOG.info "[Basecamp] Resume: synced approvals for ##{card_number}: #{changes[:approvals_added].join(', ')}" if defined?(LOG)
+            end
+          end
+
+          # Check if all gates have approved
+          if ReviewGate.all_gates_passed?(task)
+            LOG.info "[Basecamp] Resume: all gates passed for ##{card_number} — dispatching final decision" if defined?(LOG)
+            task["status"] = "final_decision"
+            task["awaiting_final_decision"] = true
+            Hooks.send(:save_epic_state, epic)
+            Hooks.send(:dispatch_final_decision, epic, task, {})
+          else
+            # Gates haven't all approved — check if we need to dispatch fixes or wait
+            approvals = task["gate_approvals"]&.size || 0
+            changes = task["changes_requested_by"]&.size || 0
+            LOG.info "[Basecamp] Resume: ##{card_number} has #{approvals} approvals, #{changes} changes_requested — waiting" if defined?(LOG)
+          end
+        end
+
+        def resume_final_decision_task(epic, task)
+          card_number = task["fizzy_card"]
+          LOG.info "[Basecamp] Resume: checking final_decision task ##{card_number}, awaiting=#{task['awaiting_final_decision']}" if defined?(LOG)
+
+          # If awaiting_final_decision is set, re-dispatch
+          # Also handle the case where it's nil but gates are all approved (stale state)
+          if task["awaiting_final_decision"] || ReviewGate.all_gates_passed?(task)
+            LOG.info "[Basecamp] Resume: dispatching final decision for ##{card_number}" if defined?(LOG)
+            task["awaiting_final_decision"] = true
+            Hooks.send(:save_epic_state, epic)
+            Hooks.send(:dispatch_final_decision, epic, task, {})
+          else
+            LOG.info "[Basecamp] Resume: final_decision task ##{card_number} not ready (awaiting=#{task['awaiting_final_decision']}, gates_passed=#{ReviewGate.all_gates_passed?(task)})" if defined?(LOG)
+          end
+        end
+
+        def setup_routes(app)
+          setup_webhook_route(app)
+          setup_api_routes(app)
+        end
+
+        def setup_webhook_route(app)
+          app.post "/basecamp" do
+            content_type :json
+            request.body.rewind
+            payload_body = request.body.read
+
+            begin
+              payload = JSON.parse(payload_body)
+            rescue JSON::ParserError => e
+              LOG.error "[Basecamp] Invalid JSON: #{e.message}"
+              halt 400, { error: "Invalid JSON" }.to_json
+            end
+
+            status_code, body = Webhook.handle(payload)
+            halt status_code, body
+          rescue StandardError => e
+            LOG.error "[Basecamp] Unhandled error: #{e.message}\n#{e.backtrace.first(5).join("\n")}"
+            halt 500, { error: e.message }.to_json
+          end
+        end
+
+        def setup_api_routes(app)
+          # Status endpoint
+          app.get "/api/basecamp" do
+            content_type :json
+            config = Config.current
+            {
+              enabled: true,
+              review_gate: config["review_gate"],
+              bot_accounts: config["bot_accounts"].keys,
+              project_mappings: config["project_mappings"].keys,
+              active_epics: Orchestrator.active_epics.size,
+              total_epics: Orchestrator.all_epics.size
+            }.to_json
+          end
+
+          # List epics
+          app.get "/api/basecamp/epics" do
+            content_type :json
+            epics = params["status"] == "all" ? Orchestrator.all_epics : Orchestrator.active_epics
+            { epics: epics }.to_json
+          end
+
+          # Get specific epic with dependency graph
+          app.get "/api/basecamp/epics/:id" do
+            content_type :json
+            epic = Orchestrator.find_epic(params["id"])
+            halt 404, { error: "Epic not found" }.to_json unless epic
+
+            # Build dependency graph from current state
+            tasks = (epic["tasks"] || []).map do |t|
+              Epic::Task.new(
+                todo_id: t["todo_id"],
+                title: t["title"],
+                fizzy_card: t["fizzy_card"],
+                depends_on: t["depends_on"] || [],
+                status: t["status"]&.to_sym || :pending,
+                completed: t["status"] == "complete"
+              )
+            end
+
+            epic.merge("dependency_graph" => Epic.dependency_graph(tasks)).to_json
+          end
+
+          # Manually trigger an epic (for testing or when webhooks aren't set up)
+          app.post "/api/basecamp/epics" do
+            content_type :json
+            request.body.rewind
+
+            begin
+              payload = JSON.parse(request.body.read)
+            rescue JSON::ParserError
+              halt 400, { error: "Invalid JSON" }.to_json
+            end
+
+            todolist_id = payload["todolist_id"]
+            project_id = payload["project_id"]
+            agent = payload["agent"]
+            title = payload["title"]
+
+            halt 400, { error: "Missing required fields: todolist_id, project_id, agent, title" }.to_json unless todolist_id && project_id && agent && title
+
+            Thread.new do
+              Orchestrator.start_epic(
+                todolist_id: todolist_id,
+                project_id: project_id,
+                agent: agent,
+                title: title
+              )
+            rescue StandardError => e
+              LOG.error "[Basecamp:API] Epic start failed: #{e.message}" if defined?(LOG)
+            end
+
+            { status: "starting", todolist_id: todolist_id, agent: agent }.to_json
+          end
+
+          # Pause/resume an epic
+          app.post "/api/basecamp/epics/:id/pause" do
+            content_type :json
+            epic = Orchestrator.find_epic(params["id"])
+            halt 404, { error: "Epic not found" }.to_json unless epic
+
+            epic["status"] = "paused"
+            epic["paused_at"] = Time.now.iso8601
+            epic["updated_at"] = Time.now.iso8601
+
+            # Save via the epics file
+            save_epic_via_api(epic)
+            { status: "paused", epic_id: epic["id"] }.to_json
+          end
+
+          app.post "/api/basecamp/epics/:id/resume" do
+            content_type :json
+            epic = Orchestrator.find_epic(params["id"])
+            halt 404, { error: "Epic not found" }.to_json unless epic
+
+            epic["status"] = "active"
+            epic["resumed_at"] = Time.now.iso8601
+            epic["updated_at"] = Time.now.iso8601
+
+            save_epic_via_api(epic)
+
+            # Re-trigger dispatch
+            Thread.new { Orchestrator.send(:resolve_and_dispatch, epic) }
+
+            { status: "resumed", epic_id: epic["id"] }.to_json
+          end
+        end
+
+        def save_epic_via_api(epic)
+          epics_file = File.join(
+            ENV.fetch("BRAINIAC_DIR", File.join(Dir.home, ".brainiac")),
+            "basecamp_epics.json"
+          )
+
+          all = if File.exist?(epics_file)
+                  data = JSON.parse(File.read(epics_file))
+                  data["epics"] || []
+                else
+                  []
+                end
+
+          idx = all.index { |e| e["id"] == epic["id"] }
+          all[idx] = epic if idx
+
+          File.write(epics_file, JSON.pretty_generate({ "epics" => all, "updated_at" => Time.now.iso8601 }))
+        end
+      end
+    end
+  end
+end

data/lib/brainiac_basecamp.rb

@@ -0,0 +1,4 @@
+# frozen_string_literal: true
+
+# Brainiac Basecamp Plugin — entry point loaded by RubyGems.
+require_relative "brainiac/plugins/basecamp"

metadata

@@ -0,0 +1,126 @@
+--- !ruby/object:Gem::Specification
+name: brainiac-basecamp
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- Andy Davis
+bindir: bin
+cert_chain: []
+date: 1980-01-02 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: brainiac
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.0.23
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.0.23
+- !ruby/object:Gem::Dependency
+  name: minitest
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.25'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.25'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '13.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '13.0'
+- !ruby/object:Gem::Dependency
+  name: rubocop
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.75'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.75'
+- !ruby/object:Gem::Dependency
+  name: rubocop-performance
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.25'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.25'
+description: Manages epics in Basecamp with autonomous agent orchestration. Tracks
+  dependencies between Fizzy cards, dispatches agents in sequence, and syncs completion
+  status bidirectionally.
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- README.md
+- lib/brainiac/plugins/basecamp.rb
+- lib/brainiac/plugins/basecamp/cli.rb
+- lib/brainiac/plugins/basecamp/client.rb
+- lib/brainiac/plugins/basecamp/config.rb
+- lib/brainiac/plugins/basecamp/epic.rb
+- lib/brainiac/plugins/basecamp/epic_branch.rb
+- lib/brainiac/plugins/basecamp/hooks.rb
+- lib/brainiac/plugins/basecamp/metadata.rb
+- lib/brainiac/plugins/basecamp/orchestrator.rb
+- lib/brainiac/plugins/basecamp/prompts.rb
+- lib/brainiac/plugins/basecamp/review_gate.rb
+- lib/brainiac/plugins/basecamp/version.rb
+- lib/brainiac/plugins/basecamp/webhook.rb
+- lib/brainiac_basecamp.rb
+homepage: https://github.com/stowzilla/brainiac-basecamp
+licenses:
+- MIT
+metadata:
+  rubygems_mfa_required: 'true'
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '3.4'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.6.9
+specification_version: 4
+summary: Basecamp epic orchestration plugin for Brainiac
+test_files: []