aidp 0.26.0 → 0.28.0

data/lib/aidp/watch/build_processor.rb

@@ -10,6 +10,8 @@ require_relative "../harness/runner"
 require_relative "../harness/state_manager"
 require_relative "../worktree"
 require_relative "../execute/progress"
+require_relative "github_state_extractor"
+require_relative "implementation_verifier"
 
 module Aidp
   module Watch
@@ -27,6 +29,8 @@ module Aidp
       def initialize(repository_client:, state_store:, project_dir: Dir.pwd, use_workstreams: true, verbose: false, label_config: {})
         @repository_client = repository_client
         @state_store = state_store
+        @state_extractor = GitHubStateExtractor.new(repository_client: repository_client)
+        @verifier = ImplementationVerifier.new(repository_client: repository_client, project_dir: project_dir)
         @project_dir = project_dir
         @use_workstreams = use_workstreams
         @verbose = verbose
@@ -40,7 +44,7 @@ module Aidp
         number = issue[:number]
         display_message("🛠️  Starting implementation for issue ##{number}", type: :info)
 
-        plan_data = ensure_plan_data(number)
+        plan_data = ensure_plan_data(issue)
         return unless plan_data
 
         slug = workstream_slug_for(issue)
@@ -87,27 +91,34 @@ module Aidp
           backtrace: e.backtrace&.first(10)
         )
 
-        # Create error result to pass to handle_failure
-        error_result = {
+        # Record failure state internally but DON'T post error to GitHub
+        # (per issue #280 - error messages should never appear on issues)
+        @state_store.record_build_status(
+          issue[:number],
           status: "error",
-          error: e.message,
-          error_class: e.class.name,
-          message: "Exception during harness execution: #{e.message}"
-        }
-
-        # Handle as failure (posts comment, updates state) but DON'T re-raise
-        handle_failure(issue: issue, slug: slug, result: error_result)
+          details: {
+            error: e.message,
+            error_class: e.class.name,
+            workstream: slug,
+            timestamp: Time.now.utc.iso8601
+          }
+        )
 
         # Note: We intentionally DON'T re-raise here to allow watch mode to continue
-        # The error has been logged, recorded, and reported to GitHub
+        # The error has been logged and recorded internally
       end
 
       private
 
-      def ensure_plan_data(number)
-        data = @state_store.plan_data(number)
+      def ensure_plan_data(issue)
+        # First try to extract from the issue that was passed in (already has comments)
+        data = @state_extractor.extract_plan_data(issue)
+
+        # Fallback to local state store if needed (for backward compatibility)
+        data ||= @state_store.plan_data(issue[:number])
+
         unless data
-          display_message("⚠️  No recorded plan for issue ##{number}. Skipping build trigger.", type: :warn)
+          display_message("⚠️  No recorded plan for issue ##{issue[:number]}. Skipping build trigger.", type: :warn)
         end
         data
       end
@@ -419,11 +430,36 @@ module Aidp
           return
         end
 
+        # Verify implementation completeness before creating PR
+        verification = @verifier.verify(issue: issue, working_dir: working_dir)
+
+        unless verification[:verified]
+          handle_incomplete_implementation(
+            issue: issue,
+            slug: slug,
+            branch_name: branch_name,
+            working_dir: working_dir,
+            verification: verification
+          )
+          return
+        end
+
+        display_message("✅ Implementation verified complete", type: :success)
+
         # Check if PR should be created based on VCS preferences
         # For watch mode, default to creating PRs (set to false to disable)
         vcs_config = config_dig(:work_loop, :version_control) || {}
         auto_create_pr = config_value(vcs_config, :auto_create_pr, true)
 
+        Aidp.log_debug(
+          "build_processor",
+          "evaluating_pr_creation",
+          issue: issue[:number],
+          changes_committed: changes_committed,
+          auto_create_pr: auto_create_pr,
+          gh_available: @repository_client.gh_available?
+        )
+
         pr_url = if !changes_committed
           Aidp.log_info(
             "build_processor",
@@ -441,14 +477,37 @@ module Aidp
             issue: issue[:number],
             branch: branch_name,
             base_branch: base_branch,
-            working_dir: working_dir
+            working_dir: working_dir,
+            gh_available: @repository_client.gh_available?
           )
           create_pull_request(issue: issue, branch_name: branch_name, base_branch: base_branch, working_dir: working_dir)
         else
+          Aidp.log_info(
+            "build_processor",
+            "skipping_pr_vcs_preference",
+            issue: issue[:number],
+            auto_create_pr: auto_create_pr
+          )
           display_message("ℹ️  Skipping PR creation (disabled in VCS preferences)", type: :muted)
           nil
         end
 
+        # Record build status BEFORE posting completion comment
+        @state_store.record_build_status(
+          issue[:number],
+          status: "completed",
+          details: {branch: branch_name, workstream: slug, pr_url: pr_url}
+        )
+
+        # Remove build label BEFORE posting completion comment
+        begin
+          @repository_client.remove_labels(issue[:number], @build_label)
+          display_message("🏷️  Removed '#{@build_label}' label after completion", type: :info)
+        rescue => e
+          display_message("⚠️  Failed to remove build label: #{e.message}", type: :warn)
+          # Don't fail the process if label removal fails
+        end
+
         # Fetch the user who added the most recent label
         label_actor = @repository_client.most_recent_label_actor(issue[:number])
 
@@ -456,6 +515,7 @@ module Aidp
         pr_line = pr_url ? "\n- Pull Request: #{pr_url}" : ""
         actor_tag = label_actor ? "cc @#{label_actor}\n\n" : ""
 
+        # Post completion comment LAST - after all other operations complete successfully
         comment = <<~COMMENT
           ✅ Implementation complete for ##{issue[:number]}.
 
@@ -466,22 +526,8 @@ module Aidp
         COMMENT
 
         @repository_client.post_comment(issue[:number], comment)
-        @state_store.record_build_status(
-          issue[:number],
-          status: "completed",
-          details: {branch: branch_name, workstream: slug, pr_url: pr_url}
-        )
         display_message("🎉 Posted completion comment for issue ##{issue[:number]}", type: :success)
 
-        # Remove build label after successful completion
-        begin
-          @repository_client.remove_labels(issue[:number], @build_label)
-          display_message("🏷️  Removed '#{@build_label}' label after completion", type: :info)
-        rescue => e
-          display_message("⚠️  Failed to remove build label: #{e.message}", type: :warn)
-          # Don't fail the process if label removal fails
-        end
-
         # Keep workstream for review - don't auto-cleanup on success
         if @use_workstreams
           display_message("ℹ️  Workstream #{slug} preserved for review. Remove with: aidp ws rm #{slug}", type: :muted)
@@ -624,6 +670,103 @@ module Aidp
         )
       end
 
+      def handle_incomplete_implementation(issue:, slug:, branch_name:, working_dir:, verification:)
+        display_message("⚠️  Implementation incomplete; scheduling additional work.", type: :warn)
+
+        # Create tasks for missing requirements
+        if verification[:additional_work] && !verification[:additional_work].empty?
+          create_follow_up_tasks(working_dir, verification[:additional_work])
+        end
+
+        # Schedule another agentic work unit
+        enqueue_decider_followup(working_dir)
+
+        workstream_note = @use_workstreams ? " The workstream `#{slug}` has been preserved for continued work." : " The branch has been preserved for continued work."
+
+        # Fetch the user who added the most recent label
+        label_actor = @repository_client.most_recent_label_actor(issue[:number])
+        actor_tag = label_actor ? "cc @#{label_actor}\n\n" : ""
+
+        # Post status comment
+        missing_section = if verification[:missing_items] && !verification[:missing_items].empty?
+          "\n### Missing Requirements\n" + verification[:missing_items].map { |item| "- #{item}" }.join("\n")
+        else
+          ""
+        end
+
+        additional_work_section = if verification[:additional_work] && !verification[:additional_work].empty?
+          "\n### Additional Work Needed\n" + verification[:additional_work].map { |item| "- #{item}" }.join("\n")
+        else
+          ""
+        end
+
+        comment = <<~COMMENT
+          🔄 Implementation in progress for ##{issue[:number]}.
+
+          #{actor_tag}The automated implementation has made progress but is not yet complete. Additional work is needed to fully address the issue requirements.
+
+          ### Verification Result
+          #{verification[:reason]}#{missing_section}#{additional_work_section}
+
+          The work loop will continue automatically to complete the remaining tasks.#{workstream_note}
+        COMMENT
+
+        @repository_client.post_comment(issue[:number], comment)
+        display_message("💬 Posted incomplete implementation status for issue ##{issue[:number]}", type: :info)
+
+        @state_store.record_build_status(
+          issue[:number],
+          status: "incomplete",
+          details: {
+            branch: branch_name,
+            workstream: slug,
+            verification: verification
+          }
+        )
+
+        Aidp.log_info(
+          "build_processor",
+          "incomplete_implementation",
+          issue: issue[:number],
+          branch: branch_name,
+          workstream: slug,
+          missing_items: verification[:missing_items],
+          additional_work: verification[: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,
+            tags: ["auto-generated", "verification"]
+          )
+        end
+
+        Aidp.log_info(
+          "build_processor",
+          "created_follow_up_tasks",
+          working_dir: working_dir,
+          task_count: additional_work.length
+        )
+      rescue => e
+        Aidp.log_warn(
+          "build_processor",
+          "failed_to_create_follow_up_tasks",
+          error: e.message,
+          working_dir: working_dir
+        )
+      end
+
       def stage_and_commit(issue, working_dir: @project_dir)
         commit_created = false
 
@@ -771,6 +914,19 @@ module Aidp
           fallback_to_author: label_actor.nil?
         )
 
+        Aidp.log_debug(
+          "build_processor",
+          "attempting_pr_creation",
+          issue: issue[:number],
+          branch_name: branch_name,
+          base_branch: base_branch,
+          draft: draft,
+          assignee: assignee,
+          gh_available: @repository_client.gh_available?,
+          title: title,
+          body_length: body.length
+        )
+
         output = @repository_client.create_pull_request(
           title: title,
           body: body,
@@ -789,9 +945,34 @@ module Aidp
           branch: branch_name,
           base_branch: base_branch,
           pr_url: pr_url,
-          assignee: assignee
+          assignee: assignee,
+          raw_output: output
         )
         pr_url
+      rescue => e
+        Aidp.log_error(
+          "build_processor",
+          "pr_creation_failed",
+          issue: issue[:number],
+          branch_name: branch_name,
+          base_branch: base_branch,
+          error: e.message,
+          error_class: e.class.name,
+          gh_available: @repository_client.gh_available?,
+          backtrace: e.backtrace&.first(10),
+          assignee: assignee,
+          title: title
+        )
+        display_message("⚠️  Failed to create pull request: #{e.message}", type: :warn)
+
+        # Continue gracefully - PR creation failure shouldn't crash the processor
+        Aidp.log_info(
+          "build_processor",
+          "continuing_after_pr_failure",
+          issue: issue[:number],
+          message: "Implementation complete but PR creation failed"
+        )
+        nil
       end
 
       def gather_test_summary(working_dir: @project_dir)

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