aidp 0.23.0 → 0.25.0

data/lib/aidp/watch/build_processor.rb

@@ -2,11 +2,14 @@
 
 require "open3"
 require "time"
+require "fileutils"
 
 require_relative "../message_display"
 require_relative "../execute/prompt_manager"
 require_relative "../harness/runner"
+require_relative "../harness/state_manager"
 require_relative "../worktree"
+require_relative "../execute/progress"
 
 module Aidp
   module Watch
@@ -55,6 +58,8 @@ module Aidp
           working_dir = @project_dir
         end
 
+        sync_local_aidp_config(working_dir)
+
         prompt_content = build_prompt(issue: issue, plan_data: plan_data)
         write_prompt(prompt_content, working_dir: working_dir)
 
@@ -65,14 +70,36 @@ module Aidp
           handle_success(issue: issue, slug: slug, branch_name: branch_name, base_branch: base_branch, plan_data: plan_data, working_dir: working_dir)
         elsif result[:status] == "needs_clarification"
           handle_clarification_request(issue: issue, slug: slug, result: result)
+        elsif result[:reason] == :completion_criteria
+          handle_incomplete_criteria(issue: issue, slug: slug, branch_name: branch_name, working_dir: working_dir, metadata: result[:failure_metadata])
         else
           handle_failure(issue: issue, slug: slug, result: result)
         end
       rescue => e
-        display_message("❌ Implementation failed: #{e.message}", type: :error)
-        @state_store.record_build_status(issue[:number], status: "failed", details: {error: e.message})
-        cleanup_workstream(slug) if @use_workstreams && slug
-        raise
+        # Don't re-raise - handle gracefully for fix-forward pattern
+        display_message("❌ Implementation failed with exception: #{e.message}", type: :error)
+        Aidp.log_error(
+          "build_processor",
+          "Implementation failed with exception",
+          issue: issue[:number],
+          error: e.message,
+          error_class: e.class.name,
+          backtrace: e.backtrace&.first(10)
+        )
+
+        # Create error result to pass to handle_failure
+        error_result = {
+          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)
+
+        # Note: We intentionally DON'T re-raise here to allow watch mode to continue
+        # The error has been logged, recorded, and reported to GitHub
       end
 
       private
@@ -147,20 +174,18 @@ module Aidp
           base_branch: base_branch
         )
 
-        if result[:success]
-          display_message("✅ Workstream created at #{result[:path]}", type: :success)
-          result[:path]
-        else
-          raise "Failed to create workstream: #{result[:message]}"
-        end
+        worktree_path = worktree_path_from_result(result)
+        display_message("✅ Workstream created at #{worktree_path}", type: :success)
+        worktree_path
       end
 
       def cleanup_workstream(slug)
         return unless slug
 
         display_message("🧹 Cleaning up workstream: #{slug}", type: :info)
-        result = Aidp::Worktree.remove(slug: slug, project_dir: @project_dir, force: true)
-        if result[:success]
+        result = Aidp::Worktree.remove(slug: slug, project_dir: @project_dir, delete_branch: true)
+        removed = (result == true) || (result.respond_to?(:[]) && result[:success])
+        if removed
           display_message("✅ Workstream removed", type: :success)
         else
           display_message("⚠️  Failed to remove workstream: #{result[:message]}", type: :warn)
@@ -211,7 +236,7 @@ module Aidp
 
       def write_prompt(content, working_dir: @project_dir)
         prompt_manager = Aidp::Execute::PromptManager.new(working_dir)
-        prompt_manager.write(content)
+        prompt_manager.write(content, step_name: IMPLEMENTATION_STEP)
         display_message("📝 Wrote PROMPT.md with implementation contract", type: :info)
 
         if @verbose
@@ -243,10 +268,21 @@ module Aidp
       end
 
       def run_harness(user_input:, working_dir: @project_dir)
+        reset_work_loop_state(working_dir)
+
+        Aidp.log_info(
+          "build_processor",
+          "starting_harness",
+          issue_dir: working_dir,
+          workflow_type: :watch_mode,
+          selected_steps: [IMPLEMENTATION_STEP]
+        )
+
         options = {
           selected_steps: [IMPLEMENTATION_STEP],
           workflow_type: :watch_mode,
-          user_input: user_input
+          user_input: user_input,
+          non_interactive: true
         }
 
         display_message("🚀 Running harness in execute mode...", type: :info) if @verbose
@@ -258,32 +294,133 @@ module Aidp
           display_message("\n--- Harness Result ---", type: :muted)
           display_message("Status: #{result[:status]}", type: :muted)
           display_message("Message: #{result[:message]}", type: :muted) if result[:message]
+          if result[:error]
+            display_message("Error: #{result[:error]}", type: :muted)
+            display_message("Error Details: #{result[:error_details]}", type: :muted) if result[:error_details]
+          end
           display_message("--- End Result ---\n", type: :muted)
         end
 
+        Aidp.log_info(
+          "build_processor",
+          "harness_result",
+          status: result[:status],
+          message: result[:message],
+          error: result[:error],
+          error_class: result[:error_class]
+        )
+
+        # Log errors to aidp.log
+        if result[:status] == "error"
+          error_msg = result[:message] || "Unknown error"
+          error_details = {
+            status: result[:status],
+            message: error_msg,
+            error: result[:error]&.to_s,
+            error_class: result[:error]&.class&.name,
+            backtrace: result[:backtrace]&.first(5)
+          }.compact
+          Aidp.log_error("build_processor", "Harness execution failed", **error_details)
+        end
+
         result
       end
 
+      def reset_work_loop_state(working_dir)
+        state_manager = Aidp::Harness::StateManager.new(working_dir, :execute)
+        state_manager.clear_state
+        Aidp::Execute::Progress.new(working_dir).reset
+      rescue => e
+        display_message("⚠️  Failed to reset work loop state before execution: #{e.message}", type: :warn)
+        Aidp.log_warn("build_processor", "failed_to_reset_work_loop_state", error: e.message, working_dir: working_dir)
+      end
+
+      def enqueue_decider_followup(target_dir)
+        work_loop_dir = File.join(target_dir, ".aidp", "work_loop")
+        FileUtils.mkdir_p(work_loop_dir)
+        request_path = File.join(work_loop_dir, "initial_units.txt")
+        File.open(request_path, "a") { |file| file.puts("decide_whats_next") }
+        Aidp.log_info("build_processor", "scheduled_decider_followup", request_path: request_path)
+      rescue => e
+        Aidp.log_warn("build_processor", "failed_to_schedule_decider", error: e.message)
+      end
+
+      def sync_local_aidp_config(target_dir)
+        return if target_dir.nil? || target_dir == @project_dir
+
+        source_config = File.join(@project_dir, ".aidp", "aidp.yml")
+        return unless File.exist?(source_config)
+
+        target_config = File.join(target_dir, ".aidp", "aidp.yml")
+        FileUtils.mkdir_p(File.dirname(target_config))
+
+        # Only copy when target missing or differs
+        if !File.exist?(target_config) || File.read(source_config, encoding: "UTF-8") != File.read(target_config, encoding: "UTF-8")
+          FileUtils.cp(source_config, target_config)
+        end
+      rescue => e
+        display_message("⚠️  Failed to sync AIDP config to workstream: #{e.message}", type: :warn)
+      end
+
+      def worktree_path_from_result(result)
+        return result if result.is_a?(String)
+
+        path = result[:path] || result["path"]
+        return path if path
+
+        message = result[:message] || "unknown error"
+        raise "Failed to create workstream: #{message}"
+      end
+
       def handle_success(issue:, slug:, branch_name:, base_branch:, plan_data:, working_dir:)
-        stage_and_commit(issue, working_dir: working_dir)
+        changes_committed = stage_and_commit(issue, working_dir: working_dir)
 
-        # Check if PR should be created based on VCS preferences
-        vcs_config = config.dig(:work_loop, :version_control) || {}
-        auto_create_pr = vcs_config.fetch(:auto_create_pr, false)
+        unless changes_committed
+          handle_no_changes(issue: issue, slug: slug, branch_name: branch_name, working_dir: working_dir)
+          return
+        end
 
-        pr_url = if auto_create_pr
+        # 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)
+
+        pr_url = if !changes_committed
+          Aidp.log_info(
+            "build_processor",
+            "skipping_pr_no_commits",
+            issue: issue[:number],
+            branch: branch_name,
+            working_dir: working_dir
+          )
+          display_message("ℹ️  Skipping PR creation because there are no commits on #{branch_name}.", type: :muted)
+          nil
+        elsif auto_create_pr
+          Aidp.log_info(
+            "build_processor",
+            "creating_pull_request",
+            issue: issue[:number],
+            branch: branch_name,
+            base_branch: base_branch,
+            working_dir: working_dir
+          )
           create_pull_request(issue: issue, branch_name: branch_name, base_branch: base_branch, working_dir: working_dir)
         else
           display_message("ℹ️  Skipping PR creation (disabled in VCS preferences)", type: :muted)
           nil
         end
 
+        # Fetch the user who added the most recent label
+        label_actor = @repository_client.most_recent_label_actor(issue[:number])
+
         workstream_note = @use_workstreams ? "\n- Workstream: `#{slug}`" : ""
         pr_line = pr_url ? "\n- Pull Request: #{pr_url}" : ""
+        actor_tag = label_actor ? "cc @#{label_actor}\n\n" : ""
 
         comment = <<~COMMENT
           ✅ Implementation complete for ##{issue[:number]}.
-          - Branch: `#{branch_name}`#{workstream_note}#{pr_line}
+
+          #{actor_tag}- Branch: `#{branch_name}`#{workstream_note}#{pr_line}
 
           Summary:
           #{plan_value(plan_data, "summary")}
@@ -316,10 +453,20 @@ module Aidp
         questions = result[:clarification_questions] || []
         workstream_note = @use_workstreams ? " The workstream `#{slug}` has been preserved." : " The branch has been preserved."
 
+        # Fetch the user who added the most recent label
+        label_actor = @repository_client.most_recent_label_actor(issue[:number])
+
         # Build comment with questions
         comment_parts = []
         comment_parts << "❓ Implementation needs clarification for ##{issue[:number]}."
         comment_parts << ""
+
+        # Tag the label actor if available
+        if label_actor
+          comment_parts << "cc @#{label_actor}"
+          comment_parts << ""
+        end
+
         comment_parts << "The AI agent needs additional information to proceed with implementation:"
         comment_parts << ""
         questions.each_with_index do |question, index|
@@ -355,49 +502,143 @@ module Aidp
 
       def handle_failure(issue:, slug:, result:)
         message = result[:message] || "Unknown failure"
+        error_info = result[:error] || result[:error_details]
         workstream_note = @use_workstreams ? " The workstream `#{slug}` has been left intact for debugging." : " The branch has been left intact for debugging."
+
+        # Build detailed error message for the comment
+        error_details_section = if error_info
+          "\nError: #{error_info}"
+        else
+          ""
+        end
+
         comment = <<~COMMENT
           ❌ Implementation attempt for ##{issue[:number]} failed.
 
           Status: #{result[:status]}
-          Details: #{message}
+          Details: #{message}#{error_details_section}
 
           Please review the repository for partial changes.#{workstream_note}
         COMMENT
         @repository_client.post_comment(issue[:number], comment)
+
+        # Log the failure with full details
+        Aidp.log_error(
+          "build_processor",
+          "Build failed for issue ##{issue[:number]}",
+          status: result[:status],
+          message: message,
+          error: error_info&.to_s,
+          workstream: slug
+        )
+
         @state_store.record_build_status(
           issue[:number],
           status: "failed",
-          details: {message: message, workstream: slug}
+          details: {message: message, error: error_info&.to_s, workstream: slug}
         )
         display_message("⚠️  Build failure recorded for issue ##{issue[:number]}", type: :warn)
       end
 
+      def handle_no_changes(issue:, slug:, branch_name:, working_dir:)
+        location_note = if @use_workstreams
+          "The workstream `#{slug}` has been preserved for review."
+        else
+          "Branch `#{branch_name}` remains checked out for inspection."
+        end
+
+        @state_store.record_build_status(
+          issue[:number],
+          status: "no_changes",
+          details: {branch: branch_name, workstream: slug}
+        )
+
+        Aidp.log_warn(
+          "build_processor",
+          "noop_build_result",
+          issue: issue[:number],
+          branch: branch_name,
+          workstream: slug
+        )
+
+        display_message("⚠️  Implementation produced no changes; labels remain untouched. #{location_note}", type: :warn)
+        enqueue_decider_followup(working_dir)
+      end
+
+      def handle_incomplete_criteria(issue:, slug:, branch_name:, working_dir:, metadata:)
+        display_message("⚠️  Completion criteria unmet; scheduling additional fix-forward iteration.", type: :warn)
+        enqueue_decider_followup(working_dir)
+
+        @state_store.record_build_status(
+          issue[:number],
+          status: "pending_fix_forward",
+          details: {branch: branch_name, workstream: slug, criteria: metadata}
+        )
+
+        Aidp.log_info(
+          "build_processor",
+          "pending_fix_forward",
+          issue: issue[:number],
+          branch: branch_name,
+          workstream: slug,
+          criteria: metadata
+        )
+      end
+
       def stage_and_commit(issue, working_dir: @project_dir)
+        commit_created = false
+
         Dir.chdir(working_dir) do
           status_output = run_git(%w[status --porcelain])
           if status_output.strip.empty?
             display_message("ℹ️  No file changes detected after work loop.", type: :muted)
-            return
+            Aidp.log_info("build_processor", "no_changes_after_work_loop", issue: issue[:number], working_dir: working_dir)
+            return commit_created
           end
 
+          changed_entries = status_output.lines.map(&:strip).reject(&:empty?)
+          Aidp.log_info(
+            "build_processor",
+            "changes_detected_after_work_loop",
+            issue: issue[:number],
+            working_dir: working_dir,
+            changed_file_count: changed_entries.length,
+            changed_files_sample: changed_entries.first(10)
+          )
+
           run_git(%w[add -A])
           commit_message = build_commit_message(issue)
           run_git(["commit", "-m", commit_message])
           display_message("💾 Created commit: #{commit_message.lines.first.strip}", type: :info)
+          Aidp.log_info(
+            "build_processor",
+            "commit_created",
+            working_dir: working_dir,
+            issue: issue[:number],
+            commit_summary: commit_message.lines.first.strip
+          )
+
+          # Push the branch to remote
+          current_branch = run_git(%w[branch --show-current]).strip
+          run_git(["push", "-u", "origin", current_branch])
+          display_message("⬆️  Pushed branch '#{current_branch}' to remote", type: :info)
+          Aidp.log_info("build_processor", "branch_pushed", branch: current_branch, working_dir: working_dir)
+          commit_created = true
         end
+
+        commit_created
       end
 
       def build_commit_message(issue)
-        vcs_config = config.dig(:work_loop, :version_control) || {}
+        vcs_config = config_dig(:work_loop, :version_control) || {}
 
         # Base message components
         issue_ref = "##{issue[:number]}"
         title = issue[:title]
 
         # Determine commit prefix based on configuration
-        prefix = if vcs_config[:conventional_commits]
-          commit_style = vcs_config[:commit_style] || "default"
+        prefix = if config_value(vcs_config, :conventional_commits)
+          commit_style = config_value(vcs_config, :commit_style, "default")
           emoji = (commit_style == "emoji") ? "✨ " : ""
           scope = (commit_style == "angular") ? "(implementation)" : ""
           "#{emoji}feat#{scope}: "
@@ -409,7 +650,7 @@ module Aidp
         main_message = "#{prefix}implement #{issue_ref} #{title}"
 
         # Add co-author attribution if configured
-        if vcs_config.fetch(:co_author_ai, true)
+        if config_value(vcs_config, :co_author_ai, true)
           provider_name = detect_current_provider || "AI Agent"
           co_author = "\n\nCo-authored-by: #{provider_name} <ai@aidp.dev>"
           main_message + co_author
@@ -432,15 +673,40 @@ module Aidp
         @config ||= begin
           config_manager = Aidp::Harness::ConfigManager.new(@project_dir)
           config_manager.config || {}
-        rescue
+        rescue => e
+          Aidp.log_error("build_processor", "config_load_exception", project_dir: @project_dir, error: e.message, backtrace: e.backtrace&.first(5))
           {}
         end
       end
 
+      # Helper to safely dig into config with both string and symbol keys
+      def config_dig(*keys)
+        value = config
+        keys.each do |key|
+          return nil unless value.is_a?(Hash)
+          # Try both symbol and string versions of the key
+          value = value[key] || value[key.to_s] || value[key.to_sym]
+          return nil if value.nil?
+        end
+        value
+      end
+
+      # Helper to get config value with both string and symbol key support
+      def config_value(hash, key, default = nil)
+        return default unless hash.is_a?(Hash)
+        # Check each key variation explicitly to handle false/nil values correctly
+        return hash[key] if hash.key?(key)
+        return hash[key.to_s] if hash.key?(key.to_s)
+        return hash[key.to_sym] if hash.key?(key.to_sym)
+        default
+      end
+
       def create_pull_request(issue:, branch_name:, base_branch:, working_dir: @project_dir)
         title = "aidp: Resolve ##{issue[:number]} - #{issue[:title]}"
         test_summary = gather_test_summary(working_dir: working_dir)
         body = <<~BODY
+          Fixes ##{issue[:number]}
+
           ## Summary
           - Automated resolution for ##{issue[:number]}
 
@@ -449,20 +715,44 @@ module Aidp
         BODY
 
         # Determine if PR should be draft based on VCS preferences
-        vcs_config = config.dig(:work_loop, :version_control) || {}
-        pr_strategy = vcs_config[:pr_strategy] || "draft"
+        vcs_config = config_dig(:work_loop, :version_control) || {}
+        pr_strategy = config_value(vcs_config, :pr_strategy, "draft")
         draft = (pr_strategy == "draft")
 
+        # Fetch the user who added the most recent label to assign the PR
+        label_actor = @repository_client.most_recent_label_actor(issue[:number])
+        assignee = label_actor || issue[:author]
+
+        Aidp.log_info(
+          "build_processor",
+          "assigning_pr",
+          issue: issue[:number],
+          assignee: assignee,
+          label_actor: label_actor,
+          fallback_to_author: label_actor.nil?
+        )
+
         output = @repository_client.create_pull_request(
           title: title,
           body: body,
           head: branch_name,
           base: base_branch,
           issue_number: issue[:number],
-          draft: draft
+          draft: draft,
+          assignee: assignee
         )
 
-        extract_pr_url(output)
+        pr_url = extract_pr_url(output)
+        Aidp.log_info(
+          "build_processor",
+          "pull_request_created",
+          issue: issue[:number],
+          branch: branch_name,
+          base_branch: base_branch,
+          pr_url: pr_url,
+          assignee: assignee
+        )
+        pr_url
       end
 
       def gather_test_summary(working_dir: @project_dir)
@@ -470,7 +760,7 @@ module Aidp
           log_path = File.join(".aidp", "logs", "test_runner.log")
           return "- Fix-forward harness executed; refer to #{log_path}" unless File.exist?(log_path)
 
-          recent = File.readlines(log_path).last(20).map(&:strip).reject(&:empty?)
+          recent = File.readlines(log_path, encoding: "UTF-8").last(20).map(&:strip).reject(&:empty?)
           if recent.empty?
             "- Fix-forward harness executed successfully."
           else