brainiac-basecamp 0.0.1

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

@@ -0,0 +1,200 @@
+# frozen_string_literal: true
+
+require "json"
+
+module Brainiac
+  module Plugins
+    module Basecamp
+      # Parses Basecamp todolist-based epics.
+      #
+      # Epic structure (Option C):
+      #   Todolist: "Epic: Build Auth System"
+      #     Todo: "#1234 — Set up auth models"
+      #       Description: <a href="https://app.fizzy.do/org/cards/1234">Fizzy #1234</a>
+      #                    [depends:none] or [depends:1234,1235]
+      #     Todo: "#1235 — Add API endpoints"
+      #       Description: ...
+      #
+      # Each todo in the list = one work item linked to a Fizzy card.
+      # Dependencies are declared in the todo description or title.
+      module Epic
+        # Represents a single task within an epic (one todo → one Fizzy card).
+        Task = Struct.new(:todo_id, :title, :fizzy_card, :depends_on, :status, :completed,
+                          :description, :assignees, :due_on, keyword_init: true)
+
+        class << self
+          # Parse todos from a todolist into structured tasks with dependency graph.
+          #
+          # @param todos [Array<Hash>] Raw todo data from Basecamp API
+          # @return [Array<Task>] Parsed tasks with card refs and dependencies
+          def parse_todos(todos)
+            todos.map do |todo|
+              title = todo["title"] || todo["content"] || ""
+              description = todo["description"] || ""
+              todo_id = todo["id"]
+              completed = todo["completed"] || false
+              assignees = (todo["assignees"] || []).map { |a| a["name"] || a["id"].to_s }
+              due_on = todo["due_on"]
+
+              fizzy_card = extract_fizzy_card(title) || extract_fizzy_card_from_description(description)
+              depends_on = extract_dependencies(title)
+              depends_on = extract_dependencies(description) if depends_on.empty?
+
+              Task.new(
+                todo_id: todo_id,
+                title: title,
+                fizzy_card: fizzy_card,
+                depends_on: depends_on,
+                status: completed ? :complete : :pending,
+                completed: completed,
+                description: description,
+                assignees: assignees,
+                due_on: due_on
+              )
+            end
+          end
+
+          # Determine which tasks are unblocked (all dependencies satisfied).
+          #
+          # @param tasks [Array<Task>] All tasks in the epic
+          # @return [Array<Task>] Tasks ready to be worked on
+          def unblocked_tasks(tasks)
+            completed_cards = tasks.select { |t| t.status == :complete }.map(&:fizzy_card).compact
+
+            tasks.select do |task|
+              task.status == :pending &&
+                task.fizzy_card &&
+                task.depends_on.all? { |dep| completed_cards.include?(dep) }
+            end
+          end
+
+          # Build a full dependency graph from tasks.
+          #
+          # @param tasks [Array<Task>] All tasks
+          # @return [Hash] Graph structure for visualization/debugging
+          def dependency_graph(tasks)
+            completed_cards = tasks.select { |t| t.status == :complete }.map(&:fizzy_card).compact
+
+            {
+              total: tasks.size,
+              complete: tasks.count { |t| t.status == :complete },
+              pending: tasks.count { |t| t.status == :pending },
+              in_flight: tasks.count { |t| t.status == :in_flight },
+              blocked: tasks.count do |t|
+                t.status == :pending &&
+                  t.depends_on.any? { |dep| !completed_cards.include?(dep) }
+              end,
+              unblocked: unblocked_tasks(tasks).size,
+              tasks: tasks.map do |t|
+                {
+                  todo_id: t.todo_id,
+                  fizzy_card: t.fizzy_card,
+                  title: t.title,
+                  status: t.status,
+                  depends_on: t.depends_on,
+                  assignees: t.assignees,
+                  due_on: t.due_on
+                }
+              end
+            }
+          end
+
+          # Generate a rich text HTML description for a todo linked to a Fizzy card.
+          #
+          # @param fizzy_card [Integer] Fizzy card number
+          # @param fizzy_account_id [String] Fizzy account ID (for URL)
+          # @param depends_on [Array<Integer>] Card numbers this task depends on
+          # @param agent [String, nil] Agent name assigned to this task
+          # @return [String] HTML description
+          def build_todo_description(fizzy_card:, fizzy_account_id:, depends_on: [], agent: nil)
+            lines = []
+            lines << "<div>"
+            lines << "<strong>Fizzy:</strong> <a href=\"https://app.fizzy.do/#{fizzy_account_id}/cards/#{fizzy_card}\">##{fizzy_card}</a><br>"
+
+            if depends_on.any?
+              dep_links = depends_on.map { |d| "<a href=\"https://app.fizzy.do/#{fizzy_account_id}/cards/#{d}\">##{d}</a>" }
+              lines << "<strong>Depends on:</strong> #{dep_links.join(', ')}<br>"
+            else
+              lines << "<strong>Depends on:</strong> none<br>"
+            end
+
+            lines << "<strong>Agent:</strong> #{agent}<br>" if agent
+            lines << "</div>"
+            lines.join("\n")
+          end
+
+          private
+
+          # Extract Fizzy card number from title.
+          # Supports formats:
+          #   "#1234 — Description"
+          #   "#1234"
+          #   "Fizzy 1234"
+          #   "Fizzy #1234"
+          #
+          # @param text [String]
+          # @return [Integer, nil]
+          def extract_fizzy_card(text)
+            # Try "#NNNN" format first (more explicit)
+            if (match = text.match(/\A#(\d+)/) || text.match(/#(\d+)/))
+              return match[1].to_i
+            end
+
+            # Try "Fizzy NNNN" or "Fizzy #NNNN" format
+            if (match = text.match(/Fizzy\s+#?(\d+)/i))
+              return match[1].to_i
+            end
+
+            nil
+          end
+
+          # Extract Fizzy card from a rich text description (look for link to fizzy.do).
+          #
+          # @param description [String] HTML description
+          # @return [Integer, nil]
+          def extract_fizzy_card_from_description(description)
+            return nil if description.nil? || description.empty?
+
+            # Look for fizzy.do card URLs
+            if (match = description.match(%r{app\.fizzy\.do/[^/]+/cards/(\d+)}))
+              return match[1].to_i
+            end
+
+            # Fallback: look for "#NNNN" in description text
+            if (match = description.match(/#(\d+)/))
+              return match[1].to_i
+            end
+
+            nil
+          end
+
+          # Extract dependency card numbers from text (title or description).
+          # Supports:
+          #   [depends:1234,1235]
+          #   Depends on: #1234, #1235
+          #   <strong>Depends on:</strong> #1234, #1235
+          #
+          # @param text [String]
+          # @return [Array<Integer>]
+          def extract_dependencies(text)
+            return [] if text.nil? || text.empty?
+
+            # Try [depends:N,N] format
+            if (match = text.match(/\[depends:([\d,]+)\]/))
+              return match[1].split(",").map(&:strip).map(&:to_i)
+            end
+
+            # Try "Depends on:" format (handles HTML tags around it)
+            # Strip HTML tags first for matching
+            stripped = text.gsub(/<[^>]+>/, "")
+            if (match = stripped.match(/Depends on:\s*((?:#\d+[\s,]*)+)/i))
+              return match[1].scan(/#(\d+)/).flatten.map(&:to_i)
+            end
+
+            []
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,271 @@
+# frozen_string_literal: true
+
+require "open3"
+
+module Brainiac
+  module Plugins
+    module Basecamp
+      # Manages epic branches — one per repo involved in the epic.
+      # Handles creation, PR auto-merge, and final PR to main.
+      module EpicBranch
+        BRAINIAC_DIR = ENV.fetch("BRAINIAC_DIR", File.join(Dir.home, ".brainiac"))
+
+        class << self
+          # Create epic branches for all repos involved in an epic.
+          # Called when orchestration starts.
+          #
+          # @param epic [Hash] Epic state
+          # @param project_repos [Hash<String, String>] project_key => repo_path mapping
+          # @return [Hash<String, String>] project_key => epic branch name
+          def create_epic_branches(epic, project_repos)
+            slug = branch_slug(epic["title"])
+            branches = {}
+
+            project_repos.each do |project_key, repo_path|
+              branch_name = "epic/#{slug}"
+              default_branch = detect_default_branch(repo_path)
+
+              # Fetch latest
+              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
+                # Branch exists — make sure we have it locally
+                run_git("fetch", "origin", "#{branch_name}:#{branch_name}", chdir: repo_path)
+                LOG.info "[Basecamp:EpicBranch] Reusing existing epic branch '#{branch_name}' in #{project_key}" if defined?(LOG)
+              else
+                # Create new branch from default branch
+                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] Created epic branch '#{branch_name}' in #{project_key}" if defined?(LOG)
+              end
+
+              branches[project_key] = branch_name
+            end
+
+            branches
+          end
+
+          # Auto-merge a task PR into the epic branch.
+          # Called after a task completes and its PR is ready.
+          #
+          # @param repo_path [String] Path to the repo
+          # @param branch_name [String] The task's branch name
+          # @param epic_branch [String] The epic branch to merge into
+          # @return [Boolean] Whether the merge succeeded
+          def merge_task_into_epic(repo_path:, branch_name:, epic_branch:)
+            # Find the PR for this branch
+            pr_number = find_pr_for_branch(repo_path: repo_path, branch: branch_name, base: epic_branch)
+            unless pr_number
+              LOG.warn "[Basecamp:EpicBranch] No PR found for branch '#{branch_name}' targeting '#{epic_branch}'" if defined?(LOG)
+              return false
+            end
+
+            # Merge the PR (don't use --delete-branch — worktree cleanup handles branch deletion)
+            stdout, stderr, status = Open3.capture3(
+              "gh", "pr", "merge", pr_number.to_s, "--merge",
+              chdir: repo_path
+            )
+
+            if status.success?
+              LOG.info "[Basecamp:EpicBranch] Merged PR ##{pr_number} into '#{epic_branch}'" if defined?(LOG)
+              true
+            else
+              LOG.error "[Basecamp:EpicBranch] Failed to merge PR ##{pr_number}: #{stderr.strip}" if defined?(LOG)
+              false
+            end
+          rescue StandardError => e
+            LOG.error "[Basecamp:EpicBranch] Merge failed: #{e.message}" if defined?(LOG)
+            false
+          end
+
+          # Open final PRs from epic branches to main for each repo.
+          # Called when all epic tasks are complete.
+          #
+          # @param epic [Hash] Epic state
+          # @param project_repos [Hash<String, String>] project_key => repo_path
+          # @param epic_branches [Hash<String, String>] project_key => epic branch name
+          # @return [Array<Hash>] Created PR info [{project, pr_number, url}]
+          def open_final_prs(epic, project_repos, epic_branches)
+            prs = []
+
+            epic_branches.each do |project_key, epic_branch|
+              repo_path = project_repos[project_key]
+              next unless repo_path
+
+              default_branch = detect_default_branch(repo_path)
+
+              # Check if epic branch has commits ahead of main
+              run_git("fetch", "origin", chdir: repo_path)
+              ahead = run_git("rev-list", "--count", "origin/#{default_branch}..origin/#{epic_branch}", chdir: repo_path).strip.to_i
+
+              if ahead.zero?
+                LOG.info "[Basecamp:EpicBranch] No changes in '#{epic_branch}' for #{project_key}, skipping final PR" if defined?(LOG)
+                next
+              end
+
+              # Open the PR
+              title = epic["title"].sub(/^Epic:\s*/i, "")
+              task_count = (epic["tasks"] || []).count { |t| t.dig("project") == project_key || project_repos.size == 1 }
+
+              pr_body = build_final_pr_body(epic, project_key)
+
+              stdout, stderr, status = Open3.capture3(
+                "gh", "pr", "create",
+                "--base", default_branch,
+                "--head", epic_branch,
+                "--title", "[Epic] #{title}",
+                "--body", pr_body,
+                chdir: repo_path
+              )
+
+              if status.success?
+                pr_url = stdout.strip
+                pr_number = pr_url.split("/").last
+                LOG.info "[Basecamp:EpicBranch] Final PR opened: #{pr_url}" if defined?(LOG)
+                prs << { project: project_key, pr_number: pr_number, url: pr_url, epic_branch: epic_branch }
+              else
+                LOG.error "[Basecamp:EpicBranch] Failed to open final PR for #{project_key}: #{stderr.strip}" if defined?(LOG)
+              end
+            end
+
+            prs
+          end
+
+          # Get the epic branch for a given card number (if it's in an active epic).
+          #
+          # @param card_number [Integer, String] Fizzy card number
+          # @return [String, nil] Epic branch name or nil
+          def 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"
+
+            epic_branches = epic["epic_branches"] || {}
+            return nil if epic_branches.empty?
+
+            # Find the project for this card's task
+            task = epic["tasks"]&.find { |t| t["fizzy_card"] == card_number.to_i }
+            return nil unless task
+
+            project_key = task["project"]
+
+            # 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
+
+            # Multi-project epic but no project on task — can't determine which branch
+            nil
+          end
+
+          private
+
+          # Generate a URL-safe slug from the epic title.
+          def branch_slug(title)
+            title
+              .sub(/^Epic:\s*/i, "")
+              .downcase
+              .gsub(/[^a-z0-9\s-]/, "")
+              .gsub(/\s+/, "-")
+              .gsub(/-+/, "-")
+              .slice(0, 50)
+              .sub(/-$/, "")
+          end
+
+          # Find a PR for a given branch targeting a specific base.
+          # IMPORTANT: Only returns PRs that actually target the expected base branch.
+          # Will NOT return PRs targeting main/master to prevent accidental merges.
+          def find_pr_for_branch(repo_path:, branch:, base:)
+            # Try exact match first
+            stdout, _stderr, status = Open3.capture3(
+              "gh", "pr", "list", "--head", branch, "--base", base, "--json", "number", "--jq", ".[0].number",
+              chdir: repo_path
+            )
+            if status.success? && !stdout.strip.empty?
+              return stdout.strip.to_i
+            end
+
+            # Try prefix match (branch might be "fizzy-1168" but actual is "fizzy-1168-slug")
+            card_num = branch.match(/fizzy-(\d+)/)[1] rescue nil
+            if card_num
+              # Search with base filter
+              stdout, _stderr, status = Open3.capture3(
+                "gh", "pr", "list", "--base", base, "--json", "number,headRefName",
+                "--jq", ".[] | select(.headRefName | startswith(\"fizzy-#{card_num}\")) | .number",
+                chdir: repo_path
+              )
+              if status.success? && !stdout.strip.empty?
+                return stdout.strip.split("\n").first.to_i
+              end
+
+              # Check if there's a PR targeting the WRONG base (e.g., main instead of epic branch)
+              # This is a safeguard — we refuse to merge PRs that target the wrong branch
+              stdout, _stderr, status = Open3.capture3(
+                "gh", "pr", "list", "--json", "number,headRefName,baseRefName",
+                "--jq", ".[] | select(.headRefName | startswith(\"fizzy-#{card_num}\"))",
+                chdir: repo_path
+              )
+              if status.success? && !stdout.strip.empty?
+                # Found a PR but it targets the wrong base — log warning and refuse to auto-merge
+                pr_data = JSON.parse("[#{stdout.strip.gsub("\n", ",")}]").first rescue nil
+                if pr_data
+                  actual_base = pr_data["baseRefName"]
+                  pr_number = pr_data["number"]
+                  if actual_base != base
+                    LOG.error "[Basecamp:EpicBranch] SAFEGUARD: PR ##{pr_number} targets '#{actual_base}' " \
+                              "but expected '#{base}'. Refusing to auto-merge to prevent accidental merge to main. " \
+                              "Fix: close the PR and reopen targeting '#{base}', or manually retarget with: " \
+                              "`gh pr edit #{pr_number} --base #{base}`" if defined?(LOG)
+                    return nil
+                  end
+                end
+              end
+            end
+
+            nil
+          end
+
+          # Build the body for the final epic PR.
+          def build_final_pr_body(epic, project_key)
+            tasks = (epic["tasks"] || []).select { |t| t["project"] == project_key || true }
+            lines = []
+            lines << "## Epic: #{epic['title']}"
+            lines << ""
+            lines << "Automated epic completion — all tasks in this epic have been completed."
+            lines << ""
+            lines << "### Tasks"
+            tasks.each do |task|
+              lines << "- [x] #{task['title']} (Fizzy ##{task['fizzy_card']})"
+            end
+            lines << ""
+            lines << "---"
+            lines << "*Opened by brainiac-basecamp epic orchestrator*"
+            lines.join("\n")
+          end
+
+          # Detect the default branch for a repo.
+          def detect_default_branch(repo_path)
+            ref = `git -C #{repo_path} symbolic-ref --short refs/remotes/origin/HEAD 2>/dev/null`.strip
+            ref.empty? ? "main" : ref.sub("origin/", "")
+          end
+
+          # Run a git command, raising on failure.
+          def run_git(*args, chdir:)
+            stdout, stderr, status = Open3.capture3("git", *args, chdir: chdir)
+            unless status.success?
+              raise "git #{args.first} failed: #{stderr.strip}"
+            end
+            stdout
+          rescue Errno::ENOENT
+            raise "git not found"
+          end
+        end
+      end
+    end
+  end
+end