aidp 0.27.0 → 0.28.0

data/lib/aidp/watch/change_request_processor.rb

@@ -12,6 +12,9 @@ require_relative "../execute/prompt_manager"
 require_relative "../harness/runner"
 require_relative "../harness/state_manager"
 require_relative "../harness/test_runner"
+require_relative "../worktree"
+require_relative "github_state_extractor"
+require_relative "implementation_verifier"
 
 module Aidp
   module Watch
@@ -32,10 +35,17 @@ module Aidp
       def initialize(repository_client:, state_store:, provider_name: nil, project_dir: Dir.pwd, label_config: {}, change_request_config: {}, safety_config: {}, verbose: false)
         @repository_client = repository_client
         @state_store = state_store
+        @state_extractor = GitHubStateExtractor.new(repository_client: repository_client)
         @provider_name = provider_name
         @project_dir = project_dir
         @verbose = verbose
 
+        # Initialize verifier
+        @verifier = ImplementationVerifier.new(
+          repository_client: repository_client,
+          project_dir: project_dir
+        )
+
         # Load label configuration
         @change_request_label = label_config[:change_request_trigger] || label_config["change_request_trigger"] || DEFAULT_CHANGE_REQUEST_LABEL
         @needs_input_label = label_config[:needs_input] || label_config["needs_input"] || DEFAULT_NEEDS_INPUT_LABEL
@@ -109,19 +119,14 @@ module Aidp
         display_message("❌ Change request processing failed: #{e.message}", type: :error)
         Aidp.log_error("change_request_processor", "Change request failed", pr: pr[:number], error: e.message, backtrace: e.backtrace&.first(10))
 
-        # Post error comment
-        error_comment = <<~COMMENT
-          #{COMMENT_HEADER}
-
-          ❌ Automated change request processing failed: #{e.message}
-
-          Please review the requested changes manually or retry by re-adding the `#{@change_request_label}` label.
-        COMMENT
-        begin
-          @repository_client.post_comment(pr[:number], error_comment)
-        rescue
-          nil
-        end
+        # Record failure state internally but DON'T post error to GitHub
+        # (per issue #280 - error messages should never appear on issues)
+        @state_store.record_change_request(pr[:number], {
+          status: "error",
+          error: e.message,
+          error_class: e.class.name,
+          timestamp: Time.now.utc.iso8601
+        })
       end
 
       private
@@ -143,7 +148,7 @@ module Aidp
 
       def analyze_change_requests(pr_data:, comments:, diff:)
         provider_name = @provider_name || detect_default_provider
-        provider = Aidp::ProviderManager.get_provider(provider_name, use_harness: false)
+        provider = Aidp::ProviderManager.get_provider(provider_name)
 
         user_prompt = build_analysis_prompt(pr_data: pr_data, comments: comments, diff: diff)
         full_prompt = "#{change_request_system_prompt}\n\n#{user_prompt}"
@@ -269,6 +274,28 @@ module Aidp
           end
         end
 
+        # Check if PR is linked to an issue - if so, verify implementation completeness
+        issue_number = @state_extractor.extract_linked_issue(pr[:body])
+        if issue_number
+          display_message("🔗 Found linked issue ##{issue_number} - verifying implementation...", type: :info)
+
+          begin
+            issue = @repository_client.fetch_issue(issue_number)
+            verification_result = @verifier.verify(issue: issue, working_dir: @project_dir)
+
+            unless verification_result[:verified]
+              handle_incomplete_implementation(pr: pr, analysis: analysis, verification_result: verification_result)
+              return
+            end
+
+            display_message("✅ Implementation verified complete", type: :success)
+          rescue => e
+            display_message("⚠️  Verification check failed: #{e.message}", type: :warn)
+            Aidp.log_error("change_request_processor", "Verification failed", pr: pr[:number], error: e.message)
+            # Continue with commit/push even if verification fails
+          end
+        end
+
         # Commit and push
         if commit_and_push(pr, analysis)
           handle_success(pr: pr, analysis: analysis)
@@ -279,7 +306,29 @@ module Aidp
 
       def checkout_pr_branch(pr_data)
         head_ref = pr_data[:head_ref]
+        pr_number = pr_data[:number]
+
+        # Check if a worktree already exists for this branch
+        existing = Aidp::Worktree.find_by_branch(branch: head_ref, project_dir: @project_dir)
+
+        if existing && existing[:active]
+          display_message("🔄 Using existing worktree for branch: #{head_ref}", type: :info)
+          Aidp.log_debug("change_request_processor", "worktree_reused", pr_number: pr_number, branch: head_ref, path: existing[:path])
 
+          # Update @project_dir to point to the worktree
+          @project_dir = existing[:path]
+
+          # Pull latest changes in the worktree
+          Dir.chdir(@project_dir) do
+            run_git(%w[fetch origin], allow_failure: true)
+            run_git(["checkout", head_ref])
+            run_git(%w[pull --ff-only], allow_failure: true)
+          end
+
+          return
+        end
+
+        # Otherwise, use the main worktree
         Dir.chdir(@project_dir) do
           # Fetch latest
           run_git(%w[fetch origin])
@@ -448,6 +497,71 @@ module Aidp
         end
       end
 
+      def handle_incomplete_implementation(pr:, analysis:, verification_result:)
+        display_message("⚠️  Implementation incomplete; creating follow-up tasks.", type: :warn)
+
+        # Create tasks for missing requirements
+        if verification_result[:additional_work] && !verification_result[:additional_work].empty?
+          create_follow_up_tasks(@project_dir, verification_result[:additional_work])
+        end
+
+        # Record state but do not post a separate comment
+        # (verification details will be included in the next summary comment)
+        @state_store.record_change_request(pr[:number], {
+          status: "incomplete_implementation",
+          timestamp: Time.now.utc.iso8601,
+          verification_reasons: verification_result[:reasons],
+          missing_items: verification_result[:missing_items],
+          additional_work: verification_result[:additional_work]
+        })
+
+        display_message("📝 Recorded incomplete implementation status for PR ##{pr[:number]}", type: :info)
+
+        # Keep the label so the work loop continues (do NOT remove it)
+        Aidp.log_info(
+          "change_request_processor",
+          "incomplete_implementation",
+          pr: pr[:number],
+          missing_items: verification_result[:missing_items],
+          additional_work: verification_result[:additional_work]
+        )
+      end
+
+      def create_follow_up_tasks(working_dir, additional_work)
+        return if additional_work.nil? || additional_work.empty?
+
+        tasklist_file = File.join(working_dir, ".aidp", "tasklist.jsonl")
+        FileUtils.mkdir_p(File.dirname(tasklist_file))
+
+        require_relative "../execute/persistent_tasklist"
+        tasklist = Aidp::Execute::PersistentTasklist.new(working_dir)
+
+        additional_work.each do |task_description|
+          tasklist.create(
+            description: task_description,
+            priority: :high,
+            source: "verification"
+          )
+        end
+
+        display_message("📝 Created #{additional_work.length} follow-up task(s) for continued work", type: :info)
+
+        Aidp.log_info(
+          "change_request_processor",
+          "created_follow_up_tasks",
+          task_count: additional_work.length,
+          working_dir: working_dir
+        )
+      rescue => e
+        display_message("⚠️  Failed to create follow-up tasks: #{e.message}", type: :warn)
+        Aidp.log_error(
+          "change_request_processor",
+          "failed_to_create_follow_up_tasks",
+          error: e.message,
+          backtrace: e.backtrace&.first(5)
+        )
+      end
+
       def handle_clarification_needed(pr:, analysis:)
         existing_data = @state_store.change_request_data(pr[:number])
         clarification_count = (existing_data&.dig("clarification_count") || 0) + 1

data/lib/aidp/watch/ci_fix_processor.rb

@@ -11,6 +11,9 @@ require_relative "../harness/config_manager"
 require_relative "../execute/prompt_manager"
 require_relative "../harness/runner"
 require_relative "../harness/state_manager"
+require_relative "../worktree"
+require_relative "github_state_extractor"
+require_relative "ci_log_extractor"
 
 module Aidp
   module Watch
@@ -30,6 +33,7 @@ module Aidp
       def initialize(repository_client:, state_store:, provider_name: nil, project_dir: Dir.pwd, label_config: {}, verbose: false)
         @repository_client = repository_client
         @state_store = state_store
+        @state_extractor = GitHubStateExtractor.new(repository_client: repository_client)
         @provider_name = provider_name
         @project_dir = project_dir
         @verbose = verbose
@@ -41,9 +45,12 @@ module Aidp
       def process(pr)
         number = pr[:number]
 
-        # Check if already processed successfully
-        if @state_store.ci_fix_completed?(number)
+        Aidp.log_debug("ci_fix_processor", "process_started", pr_number: number, pr_title: pr[:title])
+
+        # Check if already processed successfully via GitHub comments
+        if @state_extractor.ci_fix_completed?(pr)
           display_message("ℹ️  CI fix for PR ##{number} already completed. Skipping.", type: :muted)
+          Aidp.log_debug("ci_fix_processor", "already_completed", pr_number: number)
           return
         end
 
@@ -53,9 +60,16 @@ module Aidp
         pr_data = @repository_client.fetch_pull_request(number)
         ci_status = @repository_client.fetch_ci_status(number)
 
+        Aidp.log_debug("ci_fix_processor", "ci_status_fetched",
+          pr_number: number,
+          ci_state: ci_status[:state],
+          check_count: ci_status[:checks]&.length || 0,
+          checks: ci_status[:checks]&.map { |c| {name: c[:name], status: c[:status], conclusion: c[:conclusion]} })
+
         # Check if there are failures
         if ci_status[:state] == "success"
           display_message("✅ CI is passing for PR ##{number}. No fixes needed.", type: :success)
+          Aidp.log_debug("ci_fix_processor", "ci_passing", pr_number: number)
           post_success_comment(pr_data)
           @state_store.record_ci_fix(number, {status: "no_failures", timestamp: Time.now.utc.iso8601})
           begin
@@ -68,14 +82,25 @@ module Aidp
 
         if ci_status[:state] == "pending"
           display_message("⏳ CI is still running for PR ##{number}. Skipping for now.", type: :muted)
+          Aidp.log_debug("ci_fix_processor", "ci_pending", pr_number: number)
           return
         end
 
         # Get failed checks
         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] })
+
         if failed_checks.empty?
           display_message("⚠️  No specific failed checks found for PR ##{number}.", type: :warn)
+          Aidp.log_debug("ci_fix_processor", "no_failed_checks",
+            pr_number: number,
+            ci_state: ci_status[:state],
+            all_checks: ci_status[:checks]&.map { |c| {name: c[:name], conclusion: c[:conclusion]} })
           return
         end
 
@@ -99,31 +124,36 @@ module Aidp
         display_message("❌ CI fix failed: #{e.message}", type: :error)
         Aidp.log_error("ci_fix_processor", "CI fix failed", pr: pr[:number], error: e.message, backtrace: e.backtrace&.first(10))
 
-        # Post error comment
-        error_comment = <<~COMMENT
-          #{COMMENT_HEADER}
-
-          ❌ Automated CI fix failed: #{e.message}
-
-          Please investigate the CI failures manually or retry by re-adding the `#{@ci_fix_label}` label.
-        COMMENT
-        begin
-          @repository_client.post_comment(pr[:number], error_comment)
-        rescue
-          nil
-        end
+        # Record failure state internally but DON'T post error to GitHub
+        # (per issue #280 - error messages should never appear on issues)
+        @state_store.record_ci_fix(pr[:number], {
+          status: "error",
+          error: e.message,
+          error_class: e.class.name,
+          timestamp: Time.now.utc.iso8601
+        })
       end
 
       private
 
       def analyze_and_fix(pr_data:, ci_status:, failed_checks:)
-        # Fetch logs for failed checks (if available)
+        # Extract concise failure information to reduce token usage
+        provider = detect_default_provider
+        provider_manager = Aidp::ProviderManager.get_provider(provider)
+        log_extractor = CiLogExtractor.new(provider_manager: provider_manager)
+
         failure_details = failed_checks.map do |check|
+          Aidp.log_debug("ci_fix_processor", "extracting_logs", check_name: check[:name])
+          extracted = log_extractor.extract_failure_info(
+            check: check,
+            check_run_url: check[:details_url]
+          )
+
           {
             name: check[:name],
-            conclusion: check[:conclusion],
-            output: check[:output],
-            details_url: check[:details_url]
+            summary: extracted[:summary],
+            details: extracted[:details],
+            extraction_method: extracted[:extraction_method]
           }
         end
 
@@ -131,14 +161,14 @@ module Aidp
         analysis = analyze_failures_with_ai(pr_data: pr_data, failures: failure_details)
 
         if analysis[:can_fix]
-          # Checkout the PR branch and apply fixes
-          checkout_pr_branch(pr_data)
+          # Setup worktree for the PR branch
+          working_dir = setup_pr_worktree(pr_data)
 
           # Apply the proposed fixes
-          apply_fixes(analysis[:fixes])
+          apply_fixes(analysis[:fixes], working_dir: working_dir)
 
           # Commit and push
-          if commit_and_push(pr_data, analysis)
+          if commit_and_push(pr_data, analysis, working_dir: working_dir)
             {success: true, analysis: analysis, commit_created: true}
           else
             {success: false, analysis: analysis, reason: "No changes to commit"}
@@ -152,7 +182,7 @@ module Aidp
 
       def analyze_failures_with_ai(pr_data:, failures:)
         provider_name = @provider_name || detect_default_provider
-        provider = Aidp::ProviderManager.get_provider(provider_name, use_harness: false)
+        provider = Aidp::ProviderManager.get_provider(provider_name)
 
         user_prompt = build_ci_analysis_prompt(pr_data: pr_data, failures: failures)
         full_prompt = "#{ci_fix_system_prompt}\n\n#{user_prompt}"
@@ -222,12 +252,20 @@ module Aidp
           #{pr_data[:body]}
 
           **Failed Checks:**
-          #{failures.map { |f| "- #{f[:name]}: #{f[:conclusion]}\n  Output: #{f[:output].inspect}" }.join("\n")}
+          #{failures.map { |f| format_failure_for_prompt(f) }.join("\n\n")}
 
           Please analyze these failures and propose fixes if possible.
         PROMPT
       end
 
+      def format_failure_for_prompt(failure)
+        output = "**Check: #{failure[:name]}**\n"
+        output += "Summary: #{failure[:summary]}\n" if failure[:summary]
+        output += "\nDetails:\n```\n#{failure[:details]}\n```" if failure[:details]
+        output += "\n(Logs extracted using: #{failure[:extraction_method]})" if failure[:extraction_method]
+        output
+      end
+
       def detect_default_provider
         config_manager = Aidp::Harness::ConfigManager.new(@project_dir)
         config_manager.default_provider || "anthropic"
@@ -261,26 +299,54 @@ module Aidp
         end
       end
 
-      def checkout_pr_branch(pr_data)
+      def setup_pr_worktree(pr_data)
         head_ref = pr_data[:head_ref]
+        pr_number = pr_data[:number]
+
+        # Check if a worktree already exists for this branch
+        existing = Aidp::Worktree.find_by_branch(branch: head_ref, project_dir: @project_dir)
+
+        if existing && existing[:active]
+          display_message("🔄 Reusing existing worktree for branch: #{head_ref}", type: :info)
+          Aidp.log_debug("ci_fix_processor", "worktree_reused", pr_number: pr_number, branch: head_ref, path: existing[:path])
+
+          # Pull latest changes in the worktree
+          Dir.chdir(existing[:path]) do
+            run_git(%w[fetch origin], allow_failure: true)
+            run_git(["checkout", head_ref])
+            run_git(%w[pull --ff-only], allow_failure: true)
+          end
 
+          return existing[:path]
+        end
+
+        # Create a new worktree for this PR
+        slug = "pr-#{pr_number}-ci-fix"
+        display_message("🌿 Creating worktree for PR ##{pr_number}: #{head_ref}", type: :info)
+
+        # Fetch the branch first
         Dir.chdir(@project_dir) do
-          # Fetch latest
           run_git(%w[fetch origin])
+        end
 
-          # Checkout the PR branch
-          run_git(["checkout", head_ref])
+        # Create worktree
+        result = Aidp::Worktree.create(
+          slug: slug,
+          project_dir: @project_dir,
+          branch: head_ref,
+          base_branch: nil # Branch already exists, no base needed
+        )
 
-          # Pull latest changes
-          run_git(%w[pull --ff-only], allow_failure: true)
-        end
+        worktree_path = result[:path]
+        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)
 
-        display_message("🌿 Checked out branch: #{head_ref}", type: :info)
+        worktree_path
       end
 
-      def apply_fixes(fixes)
+      def apply_fixes(fixes, working_dir:)
         fixes.each do |fix|
-          file_path = File.join(@project_dir, fix["file"])
+          file_path = File.join(working_dir, fix["file"])
 
           case fix["action"]
           when "create", "edit"
@@ -296,8 +362,8 @@ module Aidp
         end
       end
 
-      def commit_and_push(pr_data, analysis)
-        Dir.chdir(@project_dir) do
+      def commit_and_push(pr_data, analysis, working_dir:)
+        Dir.chdir(working_dir) do
           # Check if there are changes
           status_output = run_git(%w[status --porcelain])
           if status_output.strip.empty?