aidp 0.33.0 → 0.34.0

data/lib/aidp/watch/auto_merger.rb

@@ -0,0 +1,274 @@
+# frozen_string_literal: true
+
+require_relative "../message_display"
+
+module Aidp
+  module Watch
+    # Automatically merges sub-issue PRs when CI passes and conditions are met.
+    # Never auto-merges parent PRs - those require human review.
+    class AutoMerger
+      include Aidp::MessageDisplay
+
+      # Labels that indicate PR type
+      PARENT_PR_LABEL = "aidp-parent-pr"
+      SUB_PR_LABEL = "aidp-sub-pr"
+
+      # Default configuration
+      DEFAULT_CONFIG = {
+        enabled: true,
+        sub_issue_prs_only: true,
+        require_ci_success: true,
+        require_reviews: 0,
+        merge_method: "squash",
+        delete_branch: true
+      }.freeze
+
+      attr_reader :repository_client, :state_store
+
+      def initialize(repository_client:, state_store:, config: {})
+        @repository_client = repository_client
+        @state_store = state_store
+        @config = DEFAULT_CONFIG.merge(config)
+      end
+
+      # Check if a PR can be auto-merged
+      # @param pr_number [Integer] The PR number
+      # @return [Hash] Result with :can_merge flag and :reason
+      def can_auto_merge?(pr_number)
+        Aidp.log_debug("auto_merger", "checking_can_auto_merge", pr_number: pr_number)
+
+        return {can_merge: false, reason: "Auto-merge is disabled"} unless @config[:enabled]
+
+        # Fetch PR details
+        pr = begin
+          @repository_client.fetch_pull_request(pr_number)
+        rescue => e
+          Aidp.log_error("auto_merger", "Failed to fetch PR", pr_number: pr_number, error: e.message)
+          return {can_merge: false, reason: "Failed to fetch PR: #{e.message}"}
+        end
+
+        # Check if it's a parent PR (never auto-merge)
+        if pr[:labels].include?(PARENT_PR_LABEL)
+          Aidp.log_debug("auto_merger", "skipping_parent_pr", pr_number: pr_number)
+          return {can_merge: false, reason: "Parent PRs require human review"}
+        end
+
+        # Check if sub-PRs only mode requires the sub-PR label
+        if @config[:sub_issue_prs_only] && !pr[:labels].include?(SUB_PR_LABEL)
+          Aidp.log_debug("auto_merger", "not_a_sub_pr", pr_number: pr_number)
+          return {can_merge: false, reason: "Not a sub-issue PR (missing #{SUB_PR_LABEL} label)"}
+        end
+
+        # Check PR state
+        unless pr[:state] == "open" || pr[:state] == "OPEN"
+          return {can_merge: false, reason: "PR is not open (state: #{pr[:state]})"}
+        end
+
+        # Check mergeability
+        if pr[:mergeable] == false
+          return {can_merge: false, reason: "PR has merge conflicts"}
+        end
+
+        # Check CI status
+        if @config[:require_ci_success]
+          ci_status = @repository_client.fetch_ci_status(pr_number)
+          unless ci_status[:state] == "success"
+            Aidp.log_debug("auto_merger", "ci_not_passed",
+              pr_number: pr_number, ci_state: ci_status[:state])
+            return {can_merge: false, reason: "CI has not passed (status: #{ci_status[:state]})"}
+          end
+        end
+
+        # All checks passed
+        Aidp.log_debug("auto_merger", "can_auto_merge", pr_number: pr_number)
+        {can_merge: true, reason: "All merge conditions met"}
+      end
+
+      # Attempt to merge a PR
+      # @param pr_number [Integer] The PR number
+      # @return [Hash] Result with :success flag, :reason, and optional :merge_sha
+      def merge_pr(pr_number)
+        Aidp.log_debug("auto_merger", "attempting_merge", pr_number: pr_number)
+
+        # Verify can merge
+        eligibility = can_auto_merge?(pr_number)
+        unless eligibility[:can_merge]
+          return {success: false, reason: eligibility[:reason]}
+        end
+
+        begin
+          result = @repository_client.merge_pull_request(
+            pr_number,
+            merge_method: @config[:merge_method]
+          )
+
+          Aidp.log_info("auto_merger", "pr_merged",
+            pr_number: pr_number, merge_method: @config[:merge_method])
+          display_message("✅ Auto-merged PR ##{pr_number}", type: :success)
+
+          # Post comment about auto-merge
+          post_merge_comment(pr_number)
+
+          # Update parent issue/PR if this was a sub-issue PR
+          update_parent_after_merge(pr_number)
+
+          {success: true, reason: "Successfully merged", result: result}
+        rescue => e
+          Aidp.log_error("auto_merger", "merge_failed",
+            pr_number: pr_number, error: e.message)
+          display_message("❌ Failed to auto-merge PR ##{pr_number}: #{e.message}", type: :error)
+          {success: false, reason: "Merge failed: #{e.message}"}
+        end
+      end
+
+      # Process all eligible PRs for auto-merge
+      # @param prs [Array<Hash>] Array of PR data with :number keys
+      # @return [Hash] Summary with :merged, :skipped, :failed counts
+      def process_auto_merge_candidates(prs)
+        Aidp.log_debug("auto_merger", "processing_candidates", count: prs.size)
+
+        merged = 0
+        skipped = 0
+        failed = 0
+
+        prs.each do |pr|
+          pr_number = pr[:number]
+
+          eligibility = can_auto_merge?(pr_number)
+          unless eligibility[:can_merge]
+            Aidp.log_debug("auto_merger", "skipping_pr",
+              pr_number: pr_number, reason: eligibility[:reason])
+            skipped += 1
+            next
+          end
+
+          result = merge_pr(pr_number)
+          if result[:success]
+            merged += 1
+          else
+            failed += 1
+          end
+        end
+
+        summary = {merged: merged, skipped: skipped, failed: failed}
+        Aidp.log_info("auto_merger", "processing_complete", **summary)
+        display_message("🔀 Auto-merge: #{merged} merged, #{skipped} skipped, #{failed} failed",
+          type: :info)
+        summary
+      end
+
+      # List all PRs with the sub-PR label that are candidates for auto-merge
+      # @return [Array<Hash>] PRs that might be eligible for auto-merge
+      def list_sub_pr_candidates
+        @repository_client.list_pull_requests(labels: [SUB_PR_LABEL], state: "open")
+      rescue => e
+        Aidp.log_error("auto_merger", "Failed to list sub-PR candidates", error: e.message)
+        []
+      end
+
+      private
+
+      def post_merge_comment(pr_number)
+        comment = <<~COMMENT
+          ✅ This PR was automatically merged by AIDP after CI passed.
+
+          Merge method: `#{@config[:merge_method]}`
+
+          ---
+          _Sub-issue PRs are automatically merged when CI passes. Parent PRs always require human review._
+        COMMENT
+
+        begin
+          @repository_client.post_comment(pr_number, comment)
+        rescue => e
+          Aidp.log_warn("auto_merger", "Failed to post merge comment",
+            pr_number: pr_number, error: e.message)
+        end
+      end
+
+      def update_parent_after_merge(pr_number)
+        # Find the parent issue for this sub-PR
+        # The sub-PR should target the parent's branch, so we can identify it
+
+        # First, check if we have hierarchy data
+        build_data = @state_store.find_build_by_pr(pr_number)
+        return unless build_data
+
+        issue_number = build_data[:issue_number]
+        parent_number = @state_store.parent_issue(issue_number)
+        return unless parent_number
+
+        Aidp.log_debug("auto_merger", "updating_parent_after_merge",
+          sub_issue: issue_number, parent: parent_number)
+
+        # Check if all sub-issues are now complete
+        sub_issues = @state_store.sub_issues(parent_number)
+        all_complete = sub_issues.all? do |sub_number|
+          sub_build = @state_store.workstream_for_issue(sub_number)
+          sub_build && sub_build[:status] == "completed"
+        end
+
+        if all_complete
+          notify_parent_ready_for_review(parent_number)
+        end
+      rescue => e
+        Aidp.log_warn("auto_merger", "Failed to update parent after merge",
+          pr_number: pr_number, error: e.message)
+      end
+
+      def notify_parent_ready_for_review(parent_number)
+        Aidp.log_info("auto_merger", "all_sub_issues_complete", parent: parent_number)
+
+        comment = <<~COMMENT
+          🎉 All sub-issue PRs have been merged!
+
+          The parent PR is now ready for final review and merge to main.
+
+          ### Sub-Issues Completed
+          #{format_sub_issues_list(parent_number)}
+
+          **Next Steps:**
+          1. Review the combined changes in the parent PR
+          2. Ensure all integration tests pass
+          3. Merge the parent PR manually
+
+          ---
+          _Parent PRs are never auto-merged and require human review._
+        COMMENT
+
+        begin
+          @repository_client.post_comment(parent_number, comment)
+          display_message("📋 Notified parent issue ##{parent_number} that all sub-PRs are merged",
+            type: :success)
+
+          # Mark the parent PR as ready for review if it's still draft
+          parent_build = @state_store.workstream_for_issue(parent_number)
+          if parent_build && parent_build[:pr_url]
+            pr_number = parent_build[:pr_url].split("/").last.to_i
+            begin
+              @repository_client.mark_pr_ready_for_review(pr_number)
+              display_message("✅ Marked parent PR ##{pr_number} as ready for review", type: :success)
+            rescue => e
+              Aidp.log_warn("auto_merger", "Failed to mark parent PR ready",
+                pr_number: pr_number, error: e.message)
+            end
+          end
+        rescue => e
+          Aidp.log_warn("auto_merger", "Failed to notify parent",
+            parent: parent_number, error: e.message)
+        end
+      end
+
+      def format_sub_issues_list(parent_number)
+        sub_issues = @state_store.sub_issues(parent_number)
+        return "_No sub-issues found_" if sub_issues.empty?
+
+        sub_issues.map do |sub_number|
+          build = @state_store.workstream_for_issue(sub_number)
+          pr_link = build&.dig(:pr_url) || "No PR"
+          "- ##{sub_number}: #{pr_link}"
+        end.join("\n")
+      end
+    end
+  end
+end

data/lib/aidp/watch/auto_pr_processor.rb

@@ -7,19 +7,35 @@ module Aidp
   module Watch
     # Handles the aidp-auto label on PRs by chaining review and CI-fix flows
     # until the PR is ready for human review.
+    #
+    # Completion criteria:
+    # - Automated review completed (or already processed)
+    # - CI passing (success or skipped states accepted)
+    # - Iteration cap not exceeded (default: 20)
+    #
+    # When complete:
+    # - Converts draft PR to ready for review
+    # - Requests the label-adder as reviewer
+    # - Posts completion comment
+    # - Removes aidp-auto label
     class AutoPrProcessor
       include Aidp::MessageDisplay
 
       DEFAULT_AUTO_LABEL = "aidp-auto"
+      DEFAULT_ITERATION_CAP = 20
+      PASSING_CI_STATES = %w[success skipped].freeze
 
-      def initialize(repository_client:, state_store:, review_processor:, ci_fix_processor:, label_config: {}, verbose: false)
+      def initialize(repository_client:, state_store:, review_processor:, ci_fix_processor:,
+        label_config: {}, iteration_cap: nil, verbose: false, prompt: nil)
         @repository_client = repository_client
         @state_store = state_store
         @review_processor = review_processor
         @ci_fix_processor = ci_fix_processor
         @state_extractor = GitHubStateExtractor.new(repository_client: repository_client)
         @verbose = verbose
+        @prompt = prompt
         @auto_label = label_config[:auto_trigger] || label_config["auto_trigger"] || DEFAULT_AUTO_LABEL
+        @iteration_cap = iteration_cap || DEFAULT_ITERATION_CAP
       end
 
       def process(pr)
@@ -27,6 +43,19 @@ module Aidp
         Aidp.log_debug("auto_pr_processor", "process_started", pr: number, title: pr[:title])
         display_message("🤖 Running autonomous review/CI loop for PR ##{number}", type: :info)
 
+        # Record this iteration
+        iteration = @state_store.record_auto_pr_iteration(number)
+        Aidp.log_debug("auto_pr_processor", "iteration_recorded", pr: number, iteration: iteration, cap: @iteration_cap)
+
+        # Check iteration cap
+        if iteration > @iteration_cap
+          Aidp.log_warn("auto_pr_processor", "iteration_cap_reached",
+            pr: number, iteration: iteration, cap: @iteration_cap)
+          display_message("⚠️  PR ##{number} reached iteration cap (#{@iteration_cap}), marking ready", type: :warn)
+          finalize_pr(pr_number: number, reason: :iteration_cap_reached)
+          return
+        end
+
         # Run review and CI fix flows. Each processor is responsible for its own guards.
         @review_processor.process(pr)
         @ci_fix_processor.process(pr)
@@ -37,7 +66,7 @@ module Aidp
         display_message("❌ aidp-auto failed on PR ##{pr[:number]}: #{e.message}", type: :error)
       end
 
-      attr_reader :auto_label
+      attr_reader :auto_label, :iteration_cap
 
       private
 
@@ -46,25 +75,114 @@ module Aidp
         ci_status = @repository_client.fetch_ci_status(pr_number)
 
         review_done = @state_extractor.review_completed?(pr_data) || @state_store.review_processed?(pr_number)
-        ci_passing = ci_status[:state] == "success"
+        ci_passing = ci_state_passing?(ci_status)
 
         Aidp.log_debug("auto_pr_processor", "completion_check",
           pr: pr_number,
           review_done: review_done,
-          ci_state: ci_status[:state])
+          ci_state: ci_status[:state],
+          ci_passing: ci_passing)
 
         return unless review_done && ci_passing
 
-        post_completion_comment(pr_number)
+        finalize_pr(pr_number: pr_number, reason: :completion_criteria_met)
+      end
+
+      # Check if CI state indicates passing (success or skipped)
+      # @param ci_status [Hash] CI status from repository_client
+      # @return [Boolean] True if CI is considered passing
+      def ci_state_passing?(ci_status)
+        state = ci_status[:state]
+
+        # Direct state match
+        return true if PASSING_CI_STATES.include?(state)
+
+        # Check individual checks - all must be success or skipped
+        checks = ci_status[:checks] || []
+        return false if checks.empty?
+
+        checks.all? do |check|
+          conclusion = check[:conclusion]
+          PASSING_CI_STATES.include?(conclusion)
+        end
+      end
+
+      def finalize_pr(pr_number:, reason:)
+        Aidp.log_info("auto_pr_processor", "finalizing_pr",
+          pr: pr_number, reason: reason)
+
+        # Convert draft to ready if needed
+        convert_draft_to_ready(pr_number)
+
+        # Request reviewer (label-adder)
+        request_label_adder_as_reviewer(pr_number)
+
+        # Post completion comment
+        post_completion_comment(pr_number, reason: reason)
+
+        # Remove auto label
         remove_auto_label(pr_number)
+
+        # Mark as completed in state store
+        @state_store.complete_auto_pr(pr_number, reason: reason.to_s)
+
+        display_message("✅ PR ##{pr_number} ready for human review", type: :success)
+      end
+
+      def convert_draft_to_ready(pr_number)
+        # Attempt the conversion and let it fail gracefully if already ready
+        # The gh CLI will return an error if PR is not a draft
+        success = @repository_client.mark_pr_ready_for_review(pr_number)
+        if success
+          display_message("📋 Converted PR ##{pr_number} from draft to ready", type: :info)
+        else
+          Aidp.log_debug("auto_pr_processor", "draft_conversion_skipped",
+            pr: pr_number, message: "PR may already be ready for review")
+        end
+      rescue => e
+        Aidp.log_warn("auto_pr_processor", "draft_conversion_failed",
+          pr: pr_number, error: e.message)
       end
 
-      def post_completion_comment(pr_number)
+      def request_label_adder_as_reviewer(pr_number)
+        label_actor = @repository_client.most_recent_pr_label_actor(pr_number)
+
+        unless label_actor
+          Aidp.log_debug("auto_pr_processor", "no_label_actor_found", pr: pr_number)
+          return
+        end
+
+        success = @repository_client.request_reviewers(pr_number, reviewers: [label_actor])
+        if success
+          display_message("👤 Requested @#{label_actor} as reviewer on PR ##{pr_number}", type: :info)
+        else
+          Aidp.log_warn("auto_pr_processor", "reviewer_request_failed",
+            pr: pr_number, reviewer: label_actor)
+        end
+      rescue => e
+        Aidp.log_warn("auto_pr_processor", "reviewer_request_exception",
+          pr: pr_number, error: e.message)
+      end
+
+      def post_completion_comment(pr_number, reason:)
+        iteration = @state_store.auto_pr_iteration_count(pr_number)
+
+        reason_text = case reason
+        when :iteration_cap_reached
+          "Iteration cap (#{@iteration_cap}) reached"
+        when :completion_criteria_met
+          "All completion criteria met"
+        else
+          "Processing complete"
+        end
+
         comment = <<~COMMENT
           ## 🤖 aidp-auto
 
+          #{reason_text} after #{iteration} iteration(s).
+
           - Automated review completed
-          - CI is passing
+          - CI is passing (success/skipped)
 
           Marking this PR ready for human review and removing the `#{@auto_label}` label.
         COMMENT

data/lib/aidp/watch/build_processor.rb

@@ -12,6 +12,7 @@ require_relative "../worktree"
 require_relative "../execute/progress"
 require_relative "github_state_extractor"
 require_relative "implementation_verifier"
+require_relative "feedback_collector"
 
 module Aidp
   module Watch
@@ -25,6 +26,8 @@ module Aidp
       IMPLEMENTATION_STEP = "16_IMPLEMENTATION"
 
       attr_reader :build_label, :needs_input_label
+      # Expose state for testability
+      attr_writer :config, :verifier
 
       def initialize(repository_client:, state_store:, project_dir: Dir.pwd, use_workstreams: true, verbose: false, label_config: {})
         @repository_client = repository_client
@@ -525,7 +528,19 @@ module Aidp
           #{plan_value(plan_data, "summary")}
         COMMENT
 
-        @repository_client.post_comment(issue[:number], comment)
+        comment_with_feedback = FeedbackCollector.append_feedback_prompt(comment)
+        result = @repository_client.post_comment(issue[:number], comment_with_feedback)
+        comment_id = result[:id] if result.is_a?(Hash)
+
+        # Track comment for feedback collection
+        if comment_id
+          @state_store.track_comment_for_feedback(
+            comment_id: comment_id,
+            processor_type: "build",
+            number: issue[:number]
+          )
+        end
+
         display_message("🎉 Posted completion comment for issue ##{issue[:number]}", type: :success)
 
         # Keep workstream for review - don't auto-cleanup on success