aidp 0.32.0 → 0.34.0

data/lib/aidp/watch/ci_fix_processor.rb

@@ -58,6 +58,41 @@ module Aidp
 
         # Fetch PR details
         pr_data = @repository_client.fetch_pull_request(number)
+
+        # Check for merge conflicts first - attempt to resolve them
+        if pr_data[:mergeable] == false || pr_data[:merge_state_status] == "dirty"
+          display_message("⚠️  PR ##{number} has merge conflicts. Attempting to resolve...", type: :warn)
+          Aidp.log_info("ci_fix_processor", "merge_conflicts_detected_attempting_resolution",
+            pr_number: number,
+            mergeable: pr_data[:mergeable],
+            merge_state_status: pr_data[:merge_state_status])
+
+          # Attempt to resolve merge conflicts
+          merge_fix_result = resolve_merge_conflicts(pr_data: pr_data)
+
+          if merge_fix_result[:success]
+            display_message("✅ Merge conflicts resolved. Continuing to check CI status...", type: :success)
+            # Re-fetch PR data after merge resolution
+            pr_data = @repository_client.fetch_pull_request(number)
+          else
+            # Failed to resolve conflicts
+            post_merge_conflict_failure_comment(pr_data, merge_fix_result)
+            @state_store.record_ci_fix(number, {
+              status: "merge_conflicts_unresolved",
+              timestamp: Time.now.utc.iso8601,
+              reason: merge_fix_result[:reason] || "Failed to resolve merge conflicts"
+            })
+
+            # Remove the label so user knows it was processed
+            begin
+              @repository_client.remove_labels(number, @ci_fix_label)
+            rescue
+              nil
+            end
+            return
+          end
+        end
+
         ci_status = @repository_client.fetch_ci_status(number)
 
         Aidp.log_debug("ci_fix_processor", "ci_status_fetched",
@@ -87,13 +122,21 @@ module Aidp
         end
 
         # Get failed checks
+        # Log all checks before filtering to help debug detection issues
+        Aidp.log_debug("ci_fix_processor", "all_checks_before_filtering",
+          pr_number: number,
+          ci_state: ci_status[:state],
+          total_checks: ci_status[:checks]&.length || 0,
+          all_checks_detailed: ci_status[:checks]&.map { |c| {name: c[:name], status: c[:status], conclusion: c[:conclusion]} })
+
         failed_checks = ci_status[:checks].select { |check| check[:conclusion] == "failure" }
 
         Aidp.log_debug("ci_fix_processor", "failed_checks_filtered",
           pr_number: number,
           total_checks: ci_status[:checks]&.length || 0,
           failed_count: failed_checks.length,
-          failed_checks: failed_checks.map { |c| c[:name] })
+          failed_checks: failed_checks.map { |c| c[:name] },
+          non_failure_checks: ci_status[:checks]&.reject { |c| c[:conclusion] == "failure" }&.map { |c| {name: c[:name], conclusion: c[:conclusion]} })
 
         if failed_checks.empty?
           display_message("⚠️  No specific failed checks found for PR ##{number}.", type: :warn)
@@ -180,6 +223,84 @@ module Aidp
         {success: false, error: e.message, backtrace: e.backtrace&.first(5)}
       end
 
+      def resolve_merge_conflicts(pr_data:)
+        display_message("🔍 Analyzing merge conflicts...", type: :info)
+
+        # Setup worktree for the PR branch
+        working_dir = setup_pr_worktree(pr_data)
+
+        # Get conflicted files
+        Dir.chdir(working_dir) do
+          # Attempt merge to trigger conflict markers
+          run_git(["fetch", "origin", pr_data[:base_ref]], allow_failure: true)
+          run_git(["merge", "origin/#{pr_data[:base_ref]}"], allow_failure: true)
+
+          # Check for conflicts
+          status_output = run_git(%w[status --porcelain])
+          conflicted_files = status_output.lines
+            .select { |line| line.start_with?("UU ", "AA ", "DD ") || line.include?("both modified") }
+            .map { |line| line.split.last }
+
+          if conflicted_files.empty?
+            Aidp.log_warn("ci_fix_processor", "no_conflict_markers_found",
+              pr_number: pr_data[:number],
+              status_output: status_output)
+            return {success: false, reason: "No conflict markers found in working tree"}
+          end
+
+          display_message("Found #{conflicted_files.length} conflicted file(s):", type: :info)
+          conflicted_files.each { |f| display_message("  - #{f}", type: :muted) }
+
+          # Read conflict content from each file
+          conflicts = conflicted_files.map do |file|
+            if File.exist?(file)
+              content = File.read(file)
+              {
+                file: file,
+                content: content,
+                has_markers: content.include?("<<<<<<<")
+              }
+            else
+              {file: file, content: nil, has_markers: false}
+            end
+          end
+
+          # Use AI to resolve conflicts
+          resolution = analyze_conflicts_with_ai(
+            pr_data: pr_data,
+            conflicts: conflicts
+          )
+
+          if resolution[:can_resolve]
+            # Apply resolutions
+            resolution[:resolutions].each do |res|
+              file_path = File.join(working_dir, res["file"])
+              File.write(file_path, res["resolved_content"])
+              run_git(["add", res["file"]])
+              display_message("  ✓ Resolved #{res["file"]}", type: :muted)
+            end
+
+            # Complete the merge
+            commit_message = build_merge_commit_message(pr_data, resolution)
+            run_git(["commit", "-m", commit_message], allow_failure: true)
+
+            # Push the resolution
+            run_git(["push", "origin", pr_data[:head_ref]])
+
+            display_message("✅ Merge conflicts resolved and pushed", type: :success)
+            {success: true, resolution: resolution, files_resolved: conflicted_files.length}
+          else
+            {success: false, reason: resolution[:reason] || "AI could not resolve conflicts"}
+          end
+        end
+      rescue => e
+        Aidp.log_error("ci_fix_processor", "merge_conflict_resolution_failed",
+          pr_number: pr_data[:number],
+          error: e.message,
+          backtrace: e.backtrace&.first(5))
+        {success: false, error: e.message}
+      end
+
       def analyze_failures_with_ai(pr_data:, failures:)
         provider_name = @provider_name || detect_default_provider
         provider = Aidp::ProviderManager.get_provider(provider_name)
@@ -210,6 +331,109 @@ module Aidp
         {can_fix: false, reason: "AI analysis error: #{e.message}"}
       end
 
+      def analyze_conflicts_with_ai(pr_data:, conflicts:)
+        provider_name = @provider_name || detect_default_provider
+        provider = Aidp::ProviderManager.get_provider(provider_name)
+
+        user_prompt = build_merge_conflict_prompt(pr_data: pr_data, conflicts: conflicts)
+        full_prompt = "#{merge_conflict_system_prompt}\n\n#{user_prompt}"
+
+        response = provider.send_message(prompt: full_prompt)
+        content = response.to_s.strip
+
+        # Extract JSON from response
+        json_content = extract_json(content)
+
+        # Parse JSON response
+        parsed = JSON.parse(json_content)
+
+        {
+          can_resolve: parsed["can_resolve"],
+          reason: parsed["reason"],
+          strategy: parsed["strategy"],
+          resolutions: parsed["resolutions"] || []
+        }
+      rescue JSON::ParserError => e
+        Aidp.log_error("ci_fix_processor", "Failed to parse merge conflict AI response",
+          error: e.message, content: content)
+        {can_resolve: false, reason: "Failed to parse AI response"}
+      rescue => e
+        Aidp.log_error("ci_fix_processor", "Merge conflict AI analysis failed", error: e.message)
+        {can_resolve: false, reason: "AI analysis error: #{e.message}"}
+      end
+
+      def merge_conflict_system_prompt
+        <<~PROMPT
+          You are an expert at resolving Git merge conflicts. Your task is to analyze conflicted files and produce clean, resolved versions.
+
+          When analyzing merge conflicts:
+          1. Understand the intent of both the current changes (HEAD) and incoming changes (base branch)
+          2. Look for semantic conflicts beyond just text differences
+          3. Prefer to keep both changes when they serve different purposes
+          4. Remove duplicate code or conflicting implementations
+          5. Maintain code style and conventions from the existing codebase
+
+          Respond in JSON format:
+          {
+            "can_resolve": true/false,
+            "reason": "Why you can or cannot resolve these conflicts",
+            "strategy": "Brief description of your resolution strategy",
+            "resolutions": [
+              {
+                "file": "path/to/file",
+                "resolved_content": "Complete file content with conflicts resolved",
+                "description": "What changes were made to resolve the conflict"
+              }
+            ]
+          }
+
+          ONLY set can_resolve to true if you are confident the resolution:
+          - Maintains the intent of both branches
+          - Doesn't introduce bugs or break functionality
+          - Follows the project's coding style
+          - Compiles/parses correctly
+
+          DO NOT attempt to resolve if:
+          - The conflicts involve complex business logic you don't understand
+          - The changes are fundamentally incompatible
+          - The resolution would require significant refactoring
+          - There's insufficient context to make a safe decision
+        PROMPT
+      end
+
+      def build_merge_conflict_prompt(pr_data:, conflicts:)
+        conflict_details = conflicts.map do |c|
+          if c[:content] && c[:has_markers]
+            "File: #{c[:file]}\n```\n#{c[:content]}\n```"
+          else
+            "File: #{c[:file]}\n(No conflict markers found or file doesn't exist)"
+          end
+        end.join("\n\n")
+
+        <<~PROMPT
+          Resolve merge conflicts for PR ##{pr_data[:number]}: #{pr_data[:title]}
+
+          Base branch: #{pr_data[:base_ref]}
+          PR branch: #{pr_data[:head_ref]}
+
+          Conflicted files:
+          #{conflict_details}
+
+          Analyze the conflicts and provide resolved versions of each file.
+        PROMPT
+      end
+
+      def build_merge_commit_message(pr_data, resolution)
+        <<~MESSAGE.strip
+          aidp: resolve merge conflicts for PR ##{pr_data[:number]}
+
+          #{resolution[:strategy] || "Automatically resolved merge conflicts"}
+
+          Files resolved:
+          #{resolution[:resolutions].map { |r| "- #{r["file"]}: #{r["description"]}" }.join("\n")}
+        MESSAGE
+      end
+
       def ci_fix_system_prompt
         <<~PROMPT
           You are an expert CI/CD troubleshooter. Your task is to analyze CI failures and propose fixes.
@@ -324,20 +548,31 @@ module Aidp
         slug = "pr-#{pr_number}-ci-fix"
         display_message("🌿 Creating worktree for PR ##{pr_number}: #{head_ref}", type: :info)
 
-        # Fetch the branch first
+        # Fetch the branch first to ensure we have the latest refs
         Dir.chdir(@project_dir) do
           run_git(%w[fetch origin])
         end
 
-        # Create worktree
+        # Create worktree - Worktree.create will automatically use origin/head_ref
+        # as base if the branch only exists on the remote (e.g., PRs from Claude Code Web)
         result = Aidp::Worktree.create(
           slug: slug,
           project_dir: @project_dir,
           branch: head_ref,
-          base_branch: nil # Branch already exists, no base needed
+          base_branch: nil
         )
 
         worktree_path = result[:path]
+
+        # Ensure the local branch tracks the remote and has latest changes
+        # This handles cases where the branch was created from origin/branch
+        Dir.chdir(worktree_path) do
+          # Set upstream tracking if not already set
+          run_git(["branch", "--set-upstream-to=origin/#{head_ref}", head_ref], allow_failure: true)
+          # Pull any changes that may have been pushed since fetch
+          run_git(%w[pull --ff-only], allow_failure: true)
+        end
+
         Aidp.log_debug("ci_fix_processor", "worktree_created", pr_number: pr_number, branch: head_ref, path: worktree_path)
         display_message("✅ Worktree created at #{worktree_path}", type: :success)
 
@@ -484,6 +719,29 @@ module Aidp
         @repository_client.post_comment(pr_data[:number], comment)
       end
 
+      def post_merge_conflict_failure_comment(pr_data, merge_fix_result)
+        reason = merge_fix_result[:reason] || merge_fix_result[:error] || "Unknown error"
+
+        comment = <<~COMMENT
+          #{COMMENT_HEADER}
+
+          ⚠️  This PR has merge conflicts that could not be automatically resolved.
+
+          **Reason:** #{reason}
+
+          **Next Steps:**
+          1. Manually resolve the merge conflicts in this PR
+          2. Run `git merge origin/#{pr_data[:base_ref]}` locally to see conflicts
+          3. Resolve conflicts in each file
+          4. Commit and push the resolved changes
+          5. Re-add the `#{@ci_fix_label}` label to retry automated fixes
+
+          **Tip:** Use `git status` to see which files have conflicts, and look for conflict markers (`<<<<<<<`, `=======`, `>>>>>>>`) in those files.
+        COMMENT
+
+        @repository_client.post_comment(pr_data[:number], comment)
+      end
+
       def run_git(args, allow_failure: false)
         stdout, stderr, status = Open3.capture3("git", *Array(args))
         raise "git #{args.join(" ")} failed: #{stderr.strip}" unless status.success? || allow_failure

data/lib/aidp/watch/feedback_collector.rb

@@ -0,0 +1,191 @@
+# frozen_string_literal: true
+
+require_relative "../evaluations"
+
+module Aidp
+  module Watch
+    # Collects user feedback via GitHub reactions and converts to evaluations
+    #
+    # Monitors reactions on AIDP-posted comments:
+    # - 👍 (+1) = good rating
+    # - 👎 (-1) = bad rating
+    # - 😕 (confused) = neutral rating
+    #
+    # @example
+    #   collector = FeedbackCollector.new(
+    #     repository_client: client,
+    #     state_store: store,
+    #     project_dir: Dir.pwd
+    #   )
+    #   collector.collect_feedback
+    class FeedbackCollector
+      # Mapping from GitHub reaction content to evaluation rating
+      REACTION_RATINGS = {
+        "+1" => "good",
+        "-1" => "bad",
+        "confused" => "neutral",
+        "heart" => "good",
+        "hooray" => "good",
+        "rocket" => "good",
+        "eyes" => "neutral"
+      }.freeze
+
+      # Feedback prompt text to include in comments
+      FEEDBACK_PROMPT = <<~PROMPT.strip
+        ---
+        **Rate this output**: React with 👍 (good), 👎 (bad), or 😕 (neutral) to help improve AIDP.
+      PROMPT
+
+      def initialize(repository_client:, state_store:, project_dir: Dir.pwd)
+        @repository_client = repository_client
+        @state_store = state_store
+        @project_dir = project_dir
+        @evaluation_storage = Evaluations::EvaluationStorage.new(project_dir: project_dir)
+
+        Aidp.log_debug("feedback_collector", "initialize",
+          repo: repository_client.full_repo, project_dir: project_dir)
+      end
+
+      # Collect feedback from all tracked comments
+      #
+      # @return [Array<Hash>] List of new evaluations recorded
+      def collect_feedback
+        Aidp.log_debug("feedback_collector", "collect_feedback_start")
+
+        tracked_comments = @state_store.tracked_comments
+        return [] if tracked_comments.empty?
+
+        new_evaluations = []
+
+        tracked_comments.each do |comment_info|
+          evaluations = process_comment_reactions(comment_info)
+          new_evaluations.concat(evaluations)
+        end
+
+        Aidp.log_debug("feedback_collector", "collect_feedback_complete",
+          tracked_count: tracked_comments.size, new_evaluations: new_evaluations.size)
+
+        new_evaluations
+      end
+
+      # Process reactions on a specific comment and create evaluations
+      #
+      # @param comment_info [Hash] Comment tracking info from state store
+      # @return [Array<Hash>] New evaluations created
+      def process_comment_reactions(comment_info)
+        comment_id = comment_info[:comment_id] || comment_info["comment_id"]
+        return [] unless comment_id
+
+        processor_type = comment_info[:processor_type] || comment_info["processor_type"]
+        target_number = comment_info[:number] || comment_info["number"]
+
+        Aidp.log_debug("feedback_collector", "process_comment",
+          comment_id: comment_id, processor_type: processor_type, number: target_number)
+
+        # Fetch reactions from GitHub
+        reactions = @repository_client.fetch_comment_reactions(comment_id)
+        return [] if reactions.empty?
+
+        # Get already-processed reaction IDs
+        processed_ids = @state_store.processed_reaction_ids(comment_id)
+
+        new_evaluations = []
+
+        reactions.each do |reaction|
+          reaction_id = reaction[:id]
+          next if processed_ids.include?(reaction_id)
+
+          rating = reaction_to_rating(reaction[:content])
+          next unless rating
+
+          # Create evaluation record
+          evaluation = create_evaluation(
+            rating: rating,
+            processor_type: processor_type,
+            target_number: target_number,
+            reaction: reaction
+          )
+
+          if evaluation
+            new_evaluations << evaluation
+            @state_store.mark_reaction_processed(comment_id, reaction_id)
+          end
+        end
+
+        new_evaluations
+      end
+
+      # Convert GitHub reaction content to evaluation rating
+      #
+      # @param content [String] GitHub reaction content (e.g., "+1", "-1", "confused")
+      # @return [String, nil] Rating or nil if not mappable
+      def reaction_to_rating(content)
+        REACTION_RATINGS[content]
+      end
+
+      # Append feedback prompt to a comment body
+      #
+      # @param body [String] Original comment body
+      # @return [String] Comment body with feedback prompt
+      def self.append_feedback_prompt(body)
+        "#{body}\n\n#{FEEDBACK_PROMPT}"
+      end
+
+      private
+
+      def create_evaluation(rating:, processor_type:, target_number:, reaction:)
+        repo = @repository_client.full_repo
+
+        context = {
+          watch: {
+            repo: repo,
+            number: target_number,
+            processor_type: processor_type
+          },
+          feedback_source: "github_reaction",
+          reaction: {
+            content: reaction[:content],
+            user: reaction[:user],
+            created_at: reaction[:created_at]
+          },
+          environment: {
+            aidp_version: defined?(Aidp::VERSION) ? Aidp::VERSION : nil
+          },
+          timestamp: Time.now.iso8601
+        }
+
+        record = Evaluations::EvaluationRecord.new(
+          rating: rating,
+          comment: "Feedback via GitHub reaction (#{reaction[:content]}) by #{reaction[:user]}",
+          target_type: processor_type,
+          target_id: "#{repo}##{target_number}",
+          context: context
+        )
+
+        result = @evaluation_storage.store(record)
+
+        if result[:success]
+          Aidp.log_info("feedback_collector", "evaluation_recorded",
+            id: record.id, rating: rating, user: reaction[:user],
+            processor_type: processor_type, target: "#{repo}##{target_number}")
+
+          {
+            id: record.id,
+            rating: rating,
+            user: reaction[:user],
+            processor_type: processor_type,
+            target: "#{repo}##{target_number}"
+          }
+        else
+          Aidp.log_error("feedback_collector", "evaluation_store_failed",
+            error: result[:error], reaction_id: reaction[:id])
+          nil
+        end
+      rescue => e
+        Aidp.log_error("feedback_collector", "create_evaluation_failed",
+          error: e.message, reaction: reaction)
+        nil
+      end
+    end
+  end
+end