aidp 0.34.1 → 0.39.3

data/lib/aidp/watch/rebase_processor.rb

@@ -0,0 +1,245 @@
+require "aidp/watch/base_processor"
+require "aidp/worktree"
+require "aidp/pr_worktree_manager"
+
+module Aidp
+  module Watch
+    # Processor for handling 'aidp-rebase' label on GitHub PRs
+    # Automatically rebases the PR branch against its target branch
+    class RebaseProcessor < BaseProcessor
+      DEFAULT_REBASE_LABEL = "aidp-rebase".freeze
+
+      def initialize(
+        repository_client:,
+        state_store: nil,
+        worktree_manager: nil,
+        ai_decision_engine: AIDecisionEngine.new,
+        label_config: {},
+        verbose: false,
+        shell_executor: nil
+      )
+        super(
+          repository_client: repository_client,
+          state_store: state_store,
+          label_config: label_config,
+          verbose: verbose
+        )
+        @worktree_manager = worktree_manager || Aidp::PRWorktreeManager.new
+        @ai_decision_engine = ai_decision_engine
+        @shell_executor = shell_executor || Aidp::ShellExecutor.new
+        @rebase_label = label_config[:rebase_trigger] ||
+          label_config["rebase_trigger"] ||
+          DEFAULT_REBASE_LABEL
+
+        Aidp.log_debug(
+          "rebase_processor",
+          "initialized",
+          rebase_label: @rebase_label
+        )
+      end
+
+      def can_process?(work_item)
+        return false unless work_item.respond_to?(:pr?) && work_item.pr?
+        work_item.labels.include?(@rebase_label)
+      end
+
+      def process(work_item)
+        Aidp.log_debug(
+          "rebase_processor",
+          "processing_work_item",
+          pr_number: work_item.number,
+          branch: work_item.data[:head][:ref]
+        )
+
+        begin
+          # Fetch PR details
+          pr_details = @repository_client.get_pull_request(work_item.number)
+          base_branch = pr_details[:base][:ref]
+          head_branch = pr_details[:head][:ref]
+
+          # Create worktree for rebasing
+          worktree_path = @worktree_manager.create_pr_worktree(
+            pr_number: work_item.number,
+            base_branch: base_branch,
+            head_branch: head_branch
+          )
+
+          # Attempt rebase with intelligent conflict resolution
+          rebase_result = perform_rebase(worktree_path, base_branch, head_branch)
+
+          # Post results to PR
+          post_rebase_status(work_item.number, rebase_result)
+
+          Aidp.log_debug(
+            "rebase_processor",
+            "rebase_completed",
+            pr_number: work_item.number,
+            result: rebase_result
+          )
+
+          rebase_result
+        rescue => e
+          # Handle and log rebase failures
+          handle_rebase_error(work_item.number, e)
+          false
+        ensure
+          # Remove rebase label after processing (success or failure)
+          @repository_client.remove_labels(
+            work_item.number,
+            [@rebase_label]
+          )
+
+          # Cleanup: remove temporary worktree
+          @worktree_manager.cleanup_pr_worktree(work_item.number)
+        end
+      end
+
+      private
+
+      def with_worktree_context(worktree_path)
+        if Dir.exist?(worktree_path)
+          Dir.chdir(worktree_path) { yield }
+        else
+          yield
+        end
+      end
+
+      def perform_rebase(worktree_path, base_branch, head_branch)
+        Aidp.log_debug(
+          "rebase_processor",
+          "performing_rebase",
+          worktree_path: worktree_path,
+          base_branch: base_branch,
+          head_branch: head_branch
+        )
+
+        # Use PRWorktreeManager's method to perform rebase and conflict resolution
+        with_worktree_context(worktree_path) do
+          # Fetch the latest changes
+          @shell_executor.system("git fetch origin")
+
+          # Attempt to rebase
+          rebase_command = "git rebase origin/#{base_branch}"
+          rebase_output = @shell_executor.system(rebase_command)
+
+          unless rebase_output
+            # Conflict resolution using AI
+            conflict_files = detect_conflicting_files(worktree_path)
+
+            if !conflict_files.empty?
+              # Use AI-powered conflict resolution
+              resolution = resolve_conflicts(worktree_path, base_branch, conflict_files)
+
+              # If resolution is successful, continue with the rebase
+              if resolution
+                # Stage resolved files and continue rebase
+                # GIT_EDITOR=true prevents editor from opening during automated rebase
+                quoted_files = conflict_files.map { |f| "\"#{f}\"" }.join(" ")
+                @shell_executor.system("git add #{quoted_files}")
+                @shell_executor.system({"GIT_EDITOR" => "true"}, "git rebase --continue")
+              else
+                return false
+              end
+            else
+              # No conflicts, but rebase failed
+              return false
+            end
+          end
+
+          # Push the rebased branch
+          @shell_executor.system("git push -f origin #{head_branch}")
+        end
+
+        true
+      end
+
+      def detect_conflicting_files(worktree_path)
+        # Use git to list conflicting files
+        `cd #{worktree_path} && git diff --name-only --diff-filter=U`.split("\n")
+      end
+
+      def resolve_conflicts(worktree_path, base_branch, conflict_files)
+        Aidp.log_debug(
+          "rebase_processor",
+          "resolving_conflicts",
+          worktree_path: worktree_path,
+          base_branch: base_branch
+        )
+
+        # Use AIDecisionEngine to analyze and resolve merge conflicts
+        conflict_resolution = @ai_decision_engine.resolve_merge_conflict(
+          base_branch_path: worktree_path,
+          conflict_files: conflict_files
+        )
+
+        apply_conflict_resolution(worktree_path, conflict_resolution)
+      end
+
+      def apply_conflict_resolution(worktree_path, conflict_resolution)
+        Aidp.log_debug(
+          "rebase_processor",
+          "applying_conflict_resolution",
+          resolution: conflict_resolution
+        )
+
+        # Apply AI-generated conflict resolution
+        conflict_resolution.each do |file, resolution|
+          File.write(File.join(worktree_path, file), resolution)
+        end
+
+        # Stage and continue rebase
+        # GIT_EDITOR=true prevents editor from opening during automated rebase
+        @shell_executor.system("cd #{worktree_path} && git add .")
+        @shell_executor.system({"GIT_EDITOR" => "true"}, "cd #{worktree_path} && git rebase --continue")
+      end
+
+      def post_rebase_status(pr_number, rebase_result, error_detail = nil)
+        status_method = rebase_result ? :add_success_status : :add_failure_status
+        description = if rebase_result
+          "PR successfully rebased"
+        elsif error_detail
+          error_detail
+        else
+          "Rebase failed"
+        end
+
+        @repository_client.send(
+          status_method,
+          pr_number,
+          context: "aidp/rebase",
+          description: description
+        )
+
+        comment_text = if rebase_result
+          "✅ PR has been successfully rebased against the target branch."
+        elsif error_detail
+          "❌ Automatic rebase failed with error: `#{error_detail}`\n\n" \
+          "Please check the PR and rebase manually."
+        else
+          "❌ Automatic rebase failed. Manual intervention required."
+        end
+
+        @repository_client.post_comment(pr_number, comment_text)
+      end
+
+      def handle_rebase_error(pr_number, error)
+        Aidp.log_debug(
+          "rebase_processor",
+          "rebase_error",
+          pr_number: pr_number,
+          error_message: error.message,
+          error_class: error.class
+        )
+
+        # Extract the error message for the status
+        error_message = if error.is_a?(StandardError)
+          error.message
+        else
+          "Unknown error"
+        end
+
+        post_rebase_status(pr_number, false, error_message)
+      end
+    end
+  end
+end

data/lib/aidp/watch/round_robin_scheduler.rb

@@ -0,0 +1,150 @@
+# frozen_string_literal: true
+
+require_relative "work_item"
+
+module Aidp
+  module Watch
+    # Schedules work items using a round-robin strategy across all tagged
+    # issues and PRs. Processes one iteration per work item before rotating
+    # to the next, ensuring fair distribution of attention.
+    #
+    # Priority handling:
+    # - aidp-plan items receive higher priority in rotation
+    # - Within the same priority, items are processed in queue order
+    #
+    # Paused items (aidp-needs-input label) are skipped during their turn
+    # but remain in the queue for later processing.
+    class RoundRobinScheduler
+      attr_reader :queue, :last_processed_key
+
+      def initialize(state_store:)
+        @state_store = state_store
+        @queue = []
+        @last_processed_key = state_store.round_robin_last_key
+
+        Aidp.log_debug("round_robin_scheduler", "initialized",
+          last_key: @last_processed_key)
+      end
+
+      # Refresh the queue with current work items from GitHub.
+      # Maintains position in rotation when possible.
+      #
+      # @param work_items [Array<WorkItem>] Current work items from all processors
+      def refresh_queue(work_items)
+        Aidp.log_debug("round_robin_scheduler", "refresh_queue.start",
+          incoming_count: work_items.size,
+          current_queue_size: @queue.size)
+
+        # Sort by priority (primary) and key (secondary) for deterministic ordering
+        # This ensures consistent queue order across refreshes
+        @queue = work_items.sort_by { |item| [item.priority, item.key] }
+
+        Aidp.log_debug("round_robin_scheduler", "refresh_queue.complete",
+          queue_size: @queue.size,
+          priorities: @queue.map(&:priority).uniq.sort)
+      end
+
+      # Get the next work item to process using round-robin rotation.
+      # Skips paused items but keeps them in queue.
+      #
+      # @param paused_numbers [Array<Integer>] Issue/PR numbers that are paused
+      # @return [WorkItem, nil] Next item to process, or nil if none available
+      def next_item(paused_numbers: [])
+        return nil if @queue.empty?
+
+        Aidp.log_debug("round_robin_scheduler", "next_item.start",
+          queue_size: @queue.size,
+          paused_count: paused_numbers.size,
+          last_key: @last_processed_key)
+
+        # Find starting position based on last processed key
+        start_index = find_start_index
+
+        # Iterate through queue starting from rotation point
+        @queue.size.times do |offset|
+          index = (start_index + offset) % @queue.size
+          item = @queue[index]
+
+          # Skip paused items
+          if paused_numbers.include?(item.number)
+            Aidp.log_debug("round_robin_scheduler", "next_item.skip_paused",
+              key: item.key, number: item.number)
+            next
+          end
+
+          Aidp.log_debug("round_robin_scheduler", "next_item.selected",
+            key: item.key, number: item.number, processor_type: item.processor_type)
+
+          return item
+        end
+
+        Aidp.log_debug("round_robin_scheduler", "next_item.all_paused",
+          queue_size: @queue.size)
+        nil
+      end
+
+      # Mark a work item as processed and persist the rotation state.
+      #
+      # @param item [WorkItem] The item that was just processed
+      def mark_processed(item)
+        @last_processed_key = item.key
+        @state_store.record_round_robin_position(
+          last_key: item.key,
+          processed_at: Time.now.utc.iso8601
+        )
+
+        Aidp.log_debug("round_robin_scheduler", "mark_processed",
+          key: item.key, number: item.number)
+      end
+
+      # Check if there are any non-paused items in the queue.
+      #
+      # @param paused_numbers [Array<Integer>] Issue/PR numbers that are paused
+      # @return [Boolean] True if there's work to do
+      def work?(paused_numbers: [])
+        @queue.any? { |item| !paused_numbers.include?(item.number) }
+      end
+
+      # Get queue statistics for debugging/monitoring.
+      #
+      # @return [Hash] Queue statistics
+      def stats
+        by_processor = @queue.group_by(&:processor_type)
+        by_priority = @queue.group_by(&:priority)
+
+        {
+          total: @queue.size,
+          by_processor: by_processor.transform_values(&:size),
+          by_priority: by_priority.transform_values(&:size),
+          last_processed_key: @last_processed_key
+        }
+      end
+
+      private
+
+      # Find the index to start searching from based on last processed item.
+      # Returns the index AFTER the last processed item for round-robin.
+      #
+      # Empty queue safety: This method returns 0 for empty queues, but the
+      # caller (next_item) guards against empty queues before calling this method.
+      # The modulo operation is safe because we've verified queue.size > 0.
+      #
+      # @return [Integer] Starting index for rotation (0 if queue is empty,
+      #   no last key, or last processed item not found)
+      def find_start_index
+        return 0 if @last_processed_key.nil?
+        return 0 if @queue.empty?
+
+        # Find the last processed item in the current queue
+        last_index = @queue.find_index { |item| item.key == @last_processed_key }
+
+        # If not found (item was removed), start from beginning
+        return 0 unless last_index
+
+        # Start from the next item (wrap around)
+        # Safe: @queue.size > 0 guaranteed by early return on line 136
+        (last_index + 1) % @queue.size
+      end
+    end
+  end
+end