aidp 0.22.0 → 0.24.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
@@ -15,14 +18,22 @@ module Aidp
     class BuildProcessor
       include Aidp::MessageDisplay
 
-      BUILD_LABEL = "aidp-build"
+      DEFAULT_BUILD_LABEL = "aidp-build"
+      DEFAULT_NEEDS_INPUT_LABEL = "aidp-needs-input"
       IMPLEMENTATION_STEP = "16_IMPLEMENTATION"
 
-      def initialize(repository_client:, state_store:, project_dir: Dir.pwd, use_workstreams: true)
+      attr_reader :build_label, :needs_input_label
+
+      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
         @project_dir = project_dir
         @use_workstreams = use_workstreams
+        @verbose = verbose
+
+        # Load label configuration
+        @build_label = label_config[:build_trigger] || label_config["build_trigger"] || DEFAULT_BUILD_LABEL
+        @needs_input_label = label_config[:needs_input] || label_config["needs_input"] || DEFAULT_NEEDS_INPUT_LABEL
       end
 
       def process(issue)
@@ -47,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)
 
@@ -55,14 +68,38 @@ module Aidp
 
         if result[:status] == "completed"
           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
@@ -137,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)
@@ -201,37 +236,174 @@ 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
+          display_message("\n--- Implementation Prompt ---", type: :muted)
+          display_message(content.strip, type: :muted)
+          display_message("--- End Prompt ---\n", type: :muted)
+        end
       end
 
       def build_user_input(issue:, plan_data:)
         tasks = Array(plan_value(plan_data, "tasks"))
-        {
+        user_input = {
           "Implementation Contract" => plan_value(plan_data, "summary").to_s,
           "Tasks" => tasks.map { |task| "- #{task}" }.join("\n"),
           "Issue URL" => issue[:url]
         }.delete_if { |_k, v| v.nil? || v.empty? }
+
+        if @verbose
+          display_message("\n--- User Input for Harness ---", type: :muted)
+          user_input.each do |key, value|
+            display_message("#{key}:", type: :muted)
+            display_message(value, type: :muted)
+            display_message("", type: :muted)
+          end
+          display_message("--- End User Input ---\n", type: :muted)
+        end
+
+        user_input
       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
+
         runner = Aidp::Harness::Runner.new(working_dir, :execute, options)
-        runner.run
+        result = runner.run
+
+        if @verbose
+          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) != File.read(target_config)
+          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)
+
+        unless changes_committed
+          handle_no_changes(issue: issue, slug: slug, branch_name: branch_name, working_dir: working_dir)
+          return
+        end
 
         # 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 = vcs_config.fetch(:auto_create_pr, false)
-
-        pr_url = if auto_create_pr
+        auto_create_pr = vcs_config.fetch(: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)
@@ -257,45 +429,189 @@ module Aidp
         )
         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)
         end
       end
 
+      def handle_clarification_request(issue:, slug:, result:)
+        questions = result[:clarification_questions] || []
+        workstream_note = @use_workstreams ? " The workstream `#{slug}` has been preserved." : " The branch has been preserved."
+
+        # Build comment with questions
+        comment_parts = []
+        comment_parts << "❓ Implementation needs clarification for ##{issue[:number]}."
+        comment_parts << ""
+        comment_parts << "The AI agent needs additional information to proceed with implementation:"
+        comment_parts << ""
+        questions.each_with_index do |question, index|
+          comment_parts << "#{index + 1}. #{question}"
+        end
+        comment_parts << ""
+        comment_parts << "**Next Steps**: Please reply with answers to the questions above. Once resolved, remove the `#{@needs_input_label}` label and add the `#{@build_label}` label to resume implementation."
+        comment_parts << ""
+        comment_parts << workstream_note.to_s
+
+        comment = comment_parts.join("\n")
+        @repository_client.post_comment(issue[:number], comment)
+
+        # Update labels: remove build trigger, add needs input
+        begin
+          @repository_client.replace_labels(
+            issue[:number],
+            old_labels: [@build_label],
+            new_labels: [@needs_input_label]
+          )
+          display_message("🏷️  Updated labels: removed '#{@build_label}', added '#{@needs_input_label}' (needs clarification)", type: :info)
+        rescue => e
+          display_message("⚠️  Failed to update labels for issue ##{issue[:number]}: #{e.message}", type: :warn)
+        end
+
+        @state_store.record_build_status(
+          issue[:number],
+          status: "needs_clarification",
+          details: {questions: questions, workstream: slug}
+        )
+        display_message("💬 Posted clarification request for issue ##{issue[:number]}", type: :success)
+      end
+
       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)
@@ -353,6 +669,7 @@ module Aidp
         body = <<~BODY
           ## Summary
           - Automated resolution for ##{issue[:number]}
+          - Fixes ##{issue[:number]}
 
           ## Testing
           #{test_summary}
@@ -363,16 +680,29 @@ module Aidp
         pr_strategy = vcs_config[:pr_strategy] || "draft"
         draft = (pr_strategy == "draft")
 
+        # Assign PR to the issue author
+        assignee = issue[:author]
+
         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
+        )
+        pr_url
       end
 
       def gather_test_summary(working_dir: @project_dir)

data/lib/aidp/watch/plan_generator.rb

@@ -26,8 +26,9 @@ module Aidp
         Focus on concrete engineering tasks. Ensure questions are actionable.
       PROMPT
 
-      def initialize(provider_name: nil)
+      def initialize(provider_name: nil, verbose: false)
         @provider_name = provider_name
+        @verbose = verbose
       end
 
       def generate(issue)
@@ -67,7 +68,21 @@ module Aidp
 
       def generate_with_provider(provider, issue)
         payload = build_prompt(issue)
+
+        if @verbose
+          display_message("\n--- Plan Generation Prompt ---", type: :muted)
+          display_message(payload.strip, type: :muted)
+          display_message("--- End Prompt ---\n", type: :muted)
+        end
+
         response = provider.send_message(prompt: payload)
+
+        if @verbose
+          display_message("\n--- Provider Response ---", type: :muted)
+          display_message(response.strip, type: :muted)
+          display_message("--- End Response ---\n", type: :muted)
+        end
+
         parsed = parse_structured_response(response)
 
         return parsed if parsed

data/lib/aidp/watch/plan_processor.rb

@@ -11,13 +11,32 @@ module Aidp
     class PlanProcessor
       include Aidp::MessageDisplay
 
-      PLAN_LABEL = "aidp-plan"
+      # Default label names
+      DEFAULT_PLAN_LABEL = "aidp-plan"
+      DEFAULT_NEEDS_INPUT_LABEL = "aidp-needs-input"
+      DEFAULT_READY_LABEL = "aidp-ready"
+      DEFAULT_BUILD_LABEL = "aidp-build"
+
       COMMENT_HEADER = "## 🤖 AIDP Plan Proposal"
 
-      def initialize(repository_client:, state_store:, plan_generator:)
+      attr_reader :plan_label, :needs_input_label, :ready_label, :build_label
+
+      def initialize(repository_client:, state_store:, plan_generator:, label_config: {})
         @repository_client = repository_client
         @state_store = state_store
         @plan_generator = plan_generator
+
+        # Load label configuration with defaults
+        @plan_label = label_config[:plan_trigger] || label_config["plan_trigger"] || DEFAULT_PLAN_LABEL
+        @needs_input_label = label_config[:needs_input] || label_config["needs_input"] || DEFAULT_NEEDS_INPUT_LABEL
+        @ready_label = label_config[:ready_to_build] || label_config["ready_to_build"] || DEFAULT_READY_LABEL
+        @build_label = label_config[:build_trigger] || label_config["build_trigger"] || DEFAULT_BUILD_LABEL
+      end
+
+      # For backward compatibility
+      def self.plan_label_from_config(config)
+        labels = config[:labels] || config["labels"] || {}
+        labels[:plan_trigger] || labels["plan_trigger"] || DEFAULT_PLAN_LABEL
       end
 
       def process(issue)
@@ -35,14 +54,39 @@ module Aidp
 
         display_message("💬 Posted plan comment for issue ##{number}", type: :success)
         @state_store.record_plan(number, plan_data.merge(comment_body: comment_body, comment_hint: COMMENT_HEADER))
+
+        # Update labels: remove plan trigger, add appropriate status label
+        update_labels_after_plan(number, plan_data)
       end
 
       private
 
+      def update_labels_after_plan(number, plan_data)
+        questions = Array(plan_data[:questions])
+        has_questions = questions.any? && !questions.all? { |q| q.to_s.strip.empty? }
+
+        # Determine which label to add based on whether there are questions
+        new_label = has_questions ? @needs_input_label : @ready_label
+        status_text = has_questions ? "needs input" : "ready to build"
+
+        begin
+          @repository_client.replace_labels(
+            number,
+            old_labels: [@plan_label],
+            new_labels: [new_label]
+          )
+          display_message("🏷️  Updated labels: removed '#{@plan_label}', added '#{new_label}' (#{status_text})", type: :info)
+        rescue => e
+          display_message("⚠️  Failed to update labels for issue ##{number}: #{e.message}", type: :warn)
+          # Don't fail the whole process if label update fails
+        end
+      end
+
       def build_comment(issue:, plan:)
         summary = plan[:summary].to_s.strip
         tasks = Array(plan[:tasks])
         questions = Array(plan[:questions])
+        has_questions = questions.any? && !questions.all? { |q| q.to_s.strip.empty? }
 
         parts = []
         parts << COMMENT_HEADER
@@ -59,7 +103,14 @@ module Aidp
         parts << "### Clarifying Questions"
         parts << format_numbered(questions, placeholder: "_No questions identified_")
         parts << ""
-        parts << "Please reply inline with answers to the questions above. Once the discussion is resolved, apply the `aidp-build` label to begin implementation."
+
+        # Add instructions based on whether there are questions
+        parts << if has_questions
+          "**Next Steps**: Please reply with answers to the questions above. Once resolved, remove the `#{@needs_input_label}` label and add the `#{@build_label}` label to begin implementation."
+        else
+          "**Next Steps**: This plan is ready for implementation. Add the `#{@build_label}` label to begin."
+        end
+
         parts.join("\n")
       end