brainiac-basecamp 0.0.11 → 0.0.13

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: d4d21875fecdd7aa33718a8db5fa446800e8a85924490b6716a455b211d79483
-  data.tar.gz: 9601289488c260e891a6df6da2b63be3e9965c9c8235d11c4366622d27a24d0b
+  metadata.gz: 8adcfd4dedeee9ee8fee1e9439e80f7f3917d81ece1c5420a3777619df8d7ab5
+  data.tar.gz: d88eb5a5e18d8bea39522ccfa6c8fbac13b2b50f87a28a29c6c1b8958e4f3eea
 SHA512:
-  metadata.gz: f24339950cce469195888d59fbc7ddecb0b75f9a7f8279df58cc2bb681637916525341ce8b9fc86c2f38bb9e8b1718a27c9f164d14afa4acff9376f4394da3eb
-  data.tar.gz: 39d9128c65180e56fe30e59d6b384dbc9ce2b7648f8586498b88e7e44b4c516fcea6d06b279bc1956373f84f1a8602aa1fb697699a40b98e699b2c6ef2f97c59
+  metadata.gz: 311711ad321fe576e24aeb51d82d9dffc4b9d2b6199b8f6b6242b7405583f224d1686d4b91cc395d3e16985dd73834324cbe539fe216f2eb22962a4f34d05d2d
+  data.tar.gz: 7ccb5d585757a9b87b5dfa88512e44528048c153d4d5e159c4e62baa9c78f904dec5333899abdbaeec46b0a8da0ac6bfbd1cd39ca2530030f1d6e05e3a1d096c

data/lib/brainiac/plugins/basecamp/epic_branch.rb

@@ -156,10 +156,75 @@ module Brainiac
             # If project is set, look up directly
             return epic_branches[project_key] if project_key && epic_branches[project_key]
 
-            # Fallback: if there's only one epic branch, use it (single-project epic)
-            return epic_branches.values.first if epic_branches.size == 1
+            # Fallback: if there's only one epic branch AND the task has no specific project set,
+            # use it (assumed single-project epic).
+            # Do NOT fallback if the task has a specific project that isn't in epic_branches —
+            # that means the branch wasn't created for this repo and we should return nil
+            # (letting the default branch be used) rather than returning a branch from a different repo.
+            return epic_branches.values.first if epic_branches.size == 1 && !project_key
+
+            # Multi-project epic but no matching branch for this task's project — return nil
+            nil
+          end
+
+          # Lazily ensure an epic branch exists for a card's project.
+          # Called when epic_branch_for_card returns nil but the card IS in an active epic.
+          # Creates the branch in the task's repo and registers it in epic state.
+          #
+          # @param card_number [Integer, String] Fizzy card number
+          # @return [String, nil] Epic branch name or nil
+          def ensure_epic_branch_for_card(card_number)
+            epic = Orchestrator.find_epic_for_card(card_number.to_i)
+            return nil unless epic
+            return nil unless epic["review_gate"] == "epic_branch"
+
+            task = epic["tasks"]&.find { |t| t["fizzy_card"] == card_number.to_i }
+            return nil unless task
+
+            project_key = task["project"]
+            return nil unless project_key
 
-            # Multi-project epic but no project on task — can't determine which branch
+            # Already have a branch for this project
+            epic_branches = epic["epic_branches"] || {}
+            return epic_branches[project_key] if epic_branches[project_key]
+
+            # Resolve repo path for this project
+            projects_file = File.join(BRAINIAC_DIR, "projects.json")
+            return nil unless File.exist?(projects_file)
+
+            all_projects = JSON.parse(File.read(projects_file))
+            repo_path = all_projects.dig(project_key, "repo_path")
+            return nil unless repo_path
+
+            # Create the branch
+            slug = branch_slug(epic["title"])
+            branch_name = "epic/#{slug}"
+            default_branch = detect_default_branch(repo_path)
+
+            run_git("fetch", "origin", chdir: repo_path)
+
+            # Check if branch already exists remotely
+            remote_exists = system("git", "ls-remote", "--exit-code", "--heads", "origin", branch_name,
+                                   chdir: repo_path, out: File::NULL, err: File::NULL)
+
+            if remote_exists
+              run_git("fetch", "origin", "#{branch_name}:#{branch_name}", chdir: repo_path)
+              LOG.info "[Basecamp:EpicBranch] Lazy-created: reusing existing '#{branch_name}' in #{project_key}" if defined?(LOG)
+            else
+              run_git("branch", branch_name, "origin/#{default_branch}", chdir: repo_path)
+              run_git("push", "-u", "origin", branch_name, chdir: repo_path)
+              LOG.info "[Basecamp:EpicBranch] Lazy-created: new '#{branch_name}' in #{project_key}" if defined?(LOG)
+            end
+
+            # Register in epic state
+            epic["epic_branches"] ||= {}
+            epic["epic_branches"][project_key] = branch_name
+            epic["updated_at"] = Time.now.iso8601
+            Orchestrator.send(:save_epic, epic)
+
+            branch_name
+          rescue StandardError => e
+            LOG.error "[Basecamp:EpicBranch] Lazy branch creation failed for #{project_key}: #{e.message}" if defined?(LOG)
             nil
           end
 

data/lib/brainiac/plugins/basecamp/hooks.rb

@@ -123,6 +123,18 @@ module Brainiac
               if epic_branches.include?(base_branch)
                 LOG.info "[Basecamp:Hooks] PR merged to epic branch #{base_branch} for card ##{card_number} — advancing" if defined?(LOG)
                 Orchestrator.on_card_completed(card_number)
+              elsif epic_branches.empty?
+                # Fallback: epic_branches was never populated (branch creation failed).
+                # If the task is in final_decision or in_review, the merge still represents
+                # completion — advance the epic regardless of which branch was targeted.
+                task = epic["tasks"].find { |t| t["fizzy_card"] == card_number.to_i }
+                if task && %w[final_decision in_review in_flight].include?(task["status"])
+                  if defined?(LOG)
+                    LOG.warn "[Basecamp:Hooks] epic_branches is empty but PR merged to '#{base_branch}' " \
+                             "for card ##{card_number} (status: #{task['status']}) — advancing anyway (branch creation likely failed)"
+                  end
+                  Orchestrator.on_card_completed(card_number)
+                end
               end
             end
           end
@@ -470,12 +482,17 @@ module Brainiac
           end
 
           # Return the epic branch as the worktree base for cards in an active epic.
+          # If the epic branch doesn't exist for this task's project yet, create it lazily.
           def register_resolve_base_branch
             Brainiac.on(:resolve_base_branch) do |ctx|
               card_number = ctx[:card_number]
               next unless card_number
 
               branch = EpicBranch.epic_branch_for_card(card_number)
+
+              # Lazy creation: if no branch exists for this task's project, create one now
+              branch ||= EpicBranch.ensure_epic_branch_for_card(card_number)
+
               next unless branch
 
               "origin/#{branch}"
@@ -483,12 +500,15 @@ module Brainiac
           end
 
           # Return the epic branch as the PR target for cards in an active epic.
+          # Same lazy-creation logic as resolve_base_branch.
           def register_resolve_pr_target
             Brainiac.on(:resolve_pr_target) do |ctx|
               card_number = ctx[:card_number]
               next unless card_number
 
-              EpicBranch.epic_branch_for_card(card_number)
+              branch = EpicBranch.epic_branch_for_card(card_number)
+              branch ||= EpicBranch.ensure_epic_branch_for_card(card_number)
+              branch
             end
           end
 
@@ -613,13 +633,32 @@ module Brainiac
             github_repo = project_config&.dig("github_repo")
 
             # Check if PR is already merged (handles manual merges, webhook misses, etc.)
-            if github_repo && pr_number
+            if github_repo && pr_number&.to_i&.positive?
               pr_state, = Open3.capture2("gh", "pr", "view", pr_number.to_s, "--repo", github_repo, "--json", "state", "-q", ".state")
               if pr_state.strip == "MERGED"
                 LOG.info "[Basecamp:Hooks] PR ##{pr_number} already merged — marking card ##{card_number} complete" if defined?(LOG)
                 Orchestrator.on_card_completed(card_number)
                 return
               end
+
+              # SAFEGUARD: Verify PR targets the epic branch (not main/master).
+              # If epic_branches is populated and the PR targets the wrong base, retarget it.
+              epic_branches = epic["epic_branches"] || {}
+              expected_base = epic_branches[project_key] || epic_branches.values.first
+              if expected_base
+                actual_base, = Open3.capture2("gh", "pr", "view", pr_number.to_s, "--repo", github_repo, "--json", "baseRefName", "-q",
+".baseRefName")
+                actual_base = actual_base.strip
+                if !actual_base.empty? && actual_base != expected_base
+                  LOG.warn "[Basecamp:Hooks] PR ##{pr_number} targets '#{actual_base}' but expected '#{expected_base}' — retargeting" if defined?(LOG)
+                  _, stderr, status = Open3.capture3("gh", "pr", "edit", pr_number.to_s, "--repo", github_repo, "--base", expected_base)
+                  if status.success?
+                    LOG.info "[Basecamp:Hooks] Retargeted PR ##{pr_number} to '#{expected_base}'" if defined?(LOG)
+                  elsif defined?(LOG)
+                    LOG.error "[Basecamp:Hooks] Failed to retarget PR ##{pr_number}: #{stderr.strip}"
+                  end
+                end
+              end
             end
 
             # Mark task as awaiting final decision
@@ -659,6 +698,17 @@ module Brainiac
             gate_approvals = task["gate_approvals"] || []
             gate_agents = gate_approvals.map { |a| a["agent"] }.join(", ")
 
+            # Determine expected target branch for the prompt
+            epic_branches = epic["epic_branches"] || {}
+            expected_base = epic_branches[project_key] || epic_branches.values.first
+            target_note = if expected_base
+                            "\n**IMPORTANT:** This PR should target `#{expected_base}` (the epic branch). " \
+                              "If `gh pr view #{pr_number} --json baseRefName` shows a different base, " \
+                              "do NOT merge — report the mismatch instead.\n"
+                          else
+                            ""
+                          end
+
             prompt = <<~PROMPT
               ## Final Decision Required — Fizzy Card ##{card_number}
 
@@ -670,7 +720,7 @@ module Brainiac
                  ```
                  gh pr merge #{pr_number} --squash --delete-branch
                  ```
-
+              #{target_note}
               Note: You cannot self-approve PRs you authored. Merge directly since gates have approved.
 
               After merging, update the Fizzy card with a brief status comment.
@@ -741,12 +791,12 @@ module Brainiac
 
             # Guard: don't spawn a duplicate if a session is already running for this task
             session_alive = if defined?(session_active?)
-                             session_active?(card_key)
-                           elsif Object.respond_to?(:session_active?, true)
-                             Object.send(:session_active?, card_key)
-                           else
-                             false
-                           end
+                              session_active?(card_key)
+                            elsif Object.respond_to?(:session_active?, true)
+                              Object.send(:session_active?, card_key)
+                            else
+                              false
+                            end
 
             if session_alive
               LOG.info "[Basecamp:Hooks] Session already active for #{card_key} — skipping dispatch" if defined?(LOG)
@@ -785,11 +835,11 @@ module Brainiac
             prompt = <<~PROMPT
               ## Changes Requested — Fizzy Card ##{card_number}
 
-              Review gates have requested changes on your PR#{pr_number ? " ##{pr_number}" : ""}.
+              Review gates have requested changes on your PR#{" ##{pr_number}" if pr_number}.
               Reviewers who requested changes: #{changers}
 
               Your job:
-              1. Read the review feedback: #{pr_number ? "`gh pr view #{pr_number} --comments`" : "check the Fizzy card comments"}
+              1. Read the review feedback: #{pr_number ? "`gh pr view #{pr_number} --comments`" : 'check the Fizzy card comments'}
               2. Address all requested changes
               3. Commit and push your fixes
 

data/lib/brainiac/plugins/basecamp/orchestrator.rb

@@ -764,14 +764,43 @@ module Brainiac
           end
 
           # Create epic branches for all projects involved in this epic.
+          # CRITICAL: If this fails, epic_branches will be empty and agents will
+          # open PRs against the default branch instead of the epic branch.
+          # We log loudly and retry resolution of project repos if initial attempt fails.
           def create_epic_branches_for(epic)
             project_repos = resolve_project_repos(epic)
-            return if project_repos.empty?
+
+            if project_repos.empty?
+              # Fallback: try to resolve from the basecamp project mapping directly
+              mapped_project = Config.brainiac_project_for(epic["basecamp_project_id"])
+              if mapped_project
+                projects_file = File.join(BRAINIAC_DIR, "projects.json")
+                all_projects = File.exist?(projects_file) ? JSON.parse(File.read(projects_file)) : {}
+                repo = all_projects.dig(mapped_project, "repo_path")
+                project_repos = { mapped_project => repo } if repo
+              end
+            end
+
+            if project_repos.empty?
+              LOG.error "[Basecamp:Orchestrator] Cannot create epic branches — no project repos resolved. " \
+                        "Tasks have projects: #{(epic['tasks'] || []).map { |t| t['project'] }.compact.uniq.inspect}. " \
+                        "Epic will proceed WITHOUT epic branches — PRs will target the default branch!" if defined?(LOG)
+              log_event(epic, "branches_failed", "No project repos resolved — epic branches not created")
+              return
+            end
 
             epic["epic_branches"] = EpicBranch.create_epic_branches(epic, project_repos)
-            log_event(epic, "branches_created", "Epic branches: #{epic['epic_branches'].values.uniq.join(', ')}")
+
+            if epic["epic_branches"].empty?
+              LOG.error "[Basecamp:Orchestrator] create_epic_branches returned empty — branch creation failed" if defined?(LOG)
+              log_event(epic, "branches_failed", "Branch creation returned empty for repos: #{project_repos.keys.join(', ')}")
+            else
+              log_event(epic, "branches_created", "Epic branches: #{epic['epic_branches'].values.uniq.join(', ')}")
+            end
           rescue StandardError => e
-            LOG.error "[Basecamp:Orchestrator] Failed to create epic branches: #{e.message}" if defined?(LOG)
+            LOG.error "[Basecamp:Orchestrator] Failed to create epic branches: #{e.class}: #{e.message}" \
+                      "\n#{e.backtrace.first(3).join("\n")}" if defined?(LOG)
+            log_event(epic, "branches_failed", "Exception: #{e.message}")
           end
 
           # Open final PRs from epic branches to main.

data/lib/brainiac/plugins/basecamp/version.rb

@@ -3,7 +3,7 @@
 module Brainiac
   module Plugins
     module Basecamp
-      VERSION = "0.0.11"
+      VERSION = "0.0.13"
     end
   end
 end

data/lib/brainiac/plugins/basecamp.rb

@@ -1,5 +1,6 @@
 # frozen_string_literal: true
 
+require "open3"
 require_relative "basecamp/version"
 require_relative "basecamp/metadata"
 require_relative "basecamp/config"
@@ -99,16 +100,27 @@ module Brainiac
 
             case status
             when "final_decision"
-              # Check if PR is already merged
-              if pr_number && project_key
+              # Check if PR is already merged — resolve pr_number first if missing/zero
+              effective_pr = pr_number
+              if (effective_pr.nil? || effective_pr.zero?) && project_key
+                resolved = resolve_pr_for_task(task)
+                if resolved
+                  task["pr_number"] = resolved[:number]
+                  task["pr_repo"] = resolved[:repo] if resolved[:repo]
+                  effective_pr = resolved[:number]
+                  LOG.info "[Basecamp:HealthCheck] Resolved PR ##{effective_pr} for card ##{card_number}" if defined?(LOG)
+                end
+              end
+
+              if effective_pr&.positive? && project_key
                 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)) : {}
                 github_repo = projects.dig(project_key, "github_repo")
 
                 if github_repo
-                  pr_state, = Open3.capture2("gh", "pr", "view", pr_number.to_s, "--repo", github_repo, "--json", "state", "-q", ".state")
+                  pr_state, = Open3.capture2("gh", "pr", "view", effective_pr.to_s, "--repo", github_repo, "--json", "state", "-q", ".state")
                   if pr_state.strip == "MERGED"
-                    LOG.info "[Basecamp:HealthCheck] PR ##{pr_number} merged but task ##{card_number} stuck in final_decision — healing" if defined?(LOG)
+                    LOG.info "[Basecamp:HealthCheck] PR ##{effective_pr} merged but task ##{card_number} stuck in final_decision — healing" if defined?(LOG)
                     Orchestrator.on_card_completed(card_number)
                     healed_any = true
                   end
@@ -388,6 +400,35 @@ module Brainiac
           card_number = task["fizzy_card"]
           LOG.info "[Basecamp] Resume: checking final_decision task ##{card_number}, awaiting=#{task['awaiting_final_decision']}" if defined?(LOG)
 
+          # First, resolve PR number if missing or zero (branch creation may have failed)
+          pr_number = task["pr_number"]
+          if (pr_number.nil? || pr_number.zero?) && task["project"]
+            resolved_pr = resolve_pr_for_task(task)
+            if resolved_pr
+              task["pr_number"] = resolved_pr[:number]
+              task["pr_repo"] = resolved_pr[:repo] if resolved_pr[:repo]
+              pr_number = resolved_pr[:number]
+              LOG.info "[Basecamp] Resume: resolved PR ##{pr_number} for card ##{card_number}" if defined?(LOG)
+            end
+          end
+
+          # Check if PR is already merged (handles manual merges, webhook misses, agent merges to wrong branch)
+          if pr_number&.positive?
+            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)) : {}
+            github_repo = projects.dig(project_key, "github_repo")
+
+            if github_repo
+              pr_state, = Open3.capture2("gh", "pr", "view", pr_number.to_s, "--repo", github_repo, "--json", "state", "-q", ".state")
+              if pr_state.strip == "MERGED"
+                LOG.info "[Basecamp] Resume: PR ##{pr_number} already merged — marking card ##{card_number} complete" if defined?(LOG)
+                Orchestrator.on_card_completed(card_number)
+                return
+              end
+            end
+          end
+
           # 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)
@@ -400,6 +441,38 @@ module Brainiac
           end
         end
 
+        # Resolve a PR number for a task by searching GitHub for matching branch patterns.
+        # Used when pr_number is 0 or nil (e.g., branch creation failed so PR was never tracked).
+        def resolve_pr_for_task(task)
+          card_number = task["fizzy_card"]
+          project_key = task["project"]
+          return nil unless project_key
+
+          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")
+          github_repo = projects.dig(project_key, "github_repo")
+          return nil unless repo_path
+
+          # Search for PR by fizzy-NNNN branch pattern (any state)
+          stdout, _, status = Open3.capture3(
+            "gh", "pr", "list", "--state", "all",
+            "--json", "number,headRefName,state",
+            "--jq", ".[] | select(.headRefName | startswith(\"fizzy-#{card_number}\")) | [.number, .state] | @tsv",
+            chdir: repo_path
+          )
+          return nil unless status.success? && !stdout.strip.empty?
+
+          # Take the first match
+          number, _state = stdout.strip.split("\n").first.split("\t")
+          return nil unless number
+
+          { number: number.to_i, repo: github_repo }
+        rescue StandardError => e
+          LOG.warn "[Basecamp] Error resolving PR for card ##{card_number}: #{e.message}" if defined?(LOG)
+          nil
+        end
+
         def setup_routes(app)
           setup_webhook_route(app)
           setup_api_routes(app)

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: brainiac-basecamp
 version: !ruby/object:Gem::Version
-  version: 0.0.11
+  version: 0.0.13
 platform: ruby
 authors:
 - Andy Davis