aidp 0.23.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
@@ -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,20 +294,116 @@ 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) != 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)
@@ -355,37 +487,131 @@ 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)
@@ -443,6 +669,7 @@ module Aidp
         body = <<~BODY
           ## Summary
           - Automated resolution for ##{issue[:number]}
+          - Fixes ##{issue[:number]}
 
           ## Testing
           #{test_summary}
@@ -453,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/repository_client.rb

@@ -61,8 +61,8 @@ module Aidp
         gh_available? ? post_comment_via_gh(number, body) : post_comment_via_api(number, body)
       end
 
-      def create_pull_request(title:, body:, head:, base:, issue_number:)
-        gh_available? ? create_pull_request_via_gh(title: title, body: body, head: head, base: base, issue_number: issue_number) : raise("GitHub CLI not available - cannot create PR")
+      def create_pull_request(title:, body:, head:, base:, issue_number:, draft: false, assignee: nil)
+        gh_available? ? create_pull_request_via_gh(title: title, body: body, head: head, base: base, issue_number: issue_number, draft: draft, assignee: assignee) : raise("GitHub CLI not available - cannot create PR")
       end
 
       def add_labels(number, *labels)
@@ -176,7 +176,7 @@ module Aidp
         response.body
       end
 
-      def create_pull_request_via_gh(title:, body:, head:, base:, issue_number:, draft: false)
+      def create_pull_request_via_gh(title:, body:, head:, base:, issue_number:, draft: false, assignee: nil)
         cmd = [
           "gh", "pr", "create",
           "--repo", full_repo,
@@ -185,8 +185,8 @@ module Aidp
           "--head", head,
           "--base", base
         ]
-        cmd += ["--issue", issue_number.to_s] if issue_number
         cmd += ["--draft"] if draft
+        cmd += ["--assignee", assignee] if assignee
 
         stdout, stderr, status = Open3.capture3(*cmd)
         raise "Failed to create PR via gh: #{stderr.strip}" unless status.success?

data/lib/aidp/watch/runner.rb

@@ -58,12 +58,25 @@ module Aidp
         # Validate safety requirements before starting
         @safety_checker.validate_watch_mode_safety!(force: @force)
 
+        Aidp.log_info(
+          "watch_runner",
+          "watch_mode_started",
+          repo: @repository_client.full_repo,
+          interval: @interval,
+          once: @once,
+          use_workstreams: @use_workstreams,
+          verbose: @verbose
+        )
+
         display_message("👀 Watch mode enabled for #{@repository_client.full_repo}", type: :highlight)
         display_message("Polling every #{@interval} seconds. Press Ctrl+C to stop.", type: :muted)
 
         loop do
+          Aidp.log_debug("watch_runner", "poll_cycle.begin", repo: @repository_client.full_repo, interval: @interval)
           process_cycle
+          Aidp.log_debug("watch_runner", "poll_cycle.complete", once: @once, next_poll_in: @once ? nil : @interval)
           break if @once
+          Aidp.log_debug("watch_runner", "poll_cycle.sleep", seconds: @interval)
           sleep @interval
         end
       rescue Interrupt
@@ -83,14 +96,22 @@ module Aidp
       def process_plan_triggers
         plan_label = @plan_processor.plan_label
         issues = @repository_client.list_issues(labels: [plan_label], state: "open")
+        Aidp.log_debug("watch_runner", "plan_poll", label: plan_label, total: issues.size)
         issues.each do |issue|
-          next unless issue_has_label?(issue, plan_label)
+          unless issue_has_label?(issue, plan_label)
+            Aidp.log_debug("watch_runner", "plan_skip_label_mismatch", issue: issue[:number], labels: issue[:labels])
+            next
+          end
 
           detailed = @repository_client.fetch_issue(issue[:number])
 
           # Check author authorization before processing
-          next unless @safety_checker.should_process_issue?(detailed, enforce: false)
+          unless @safety_checker.should_process_issue?(detailed, enforce: false)
+            Aidp.log_debug("watch_runner", "plan_skip_unauthorized_author", issue: detailed[:number], author: detailed[:author])
+            next
+          end
 
+          Aidp.log_debug("watch_runner", "plan_process", issue: detailed[:number])
           @plan_processor.process(detailed)
         rescue RepositorySafetyChecker::UnauthorizedAuthorError => e
           Aidp.log_warn("watch_runner", "unauthorized issue author", issue: issue[:number], error: e.message)
@@ -100,17 +121,28 @@ module Aidp
       def process_build_triggers
         build_label = @build_processor.build_label
         issues = @repository_client.list_issues(labels: [build_label], state: "open")
+        Aidp.log_debug("watch_runner", "build_poll", label: build_label, total: issues.size)
         issues.each do |issue|
-          next unless issue_has_label?(issue, build_label)
+          unless issue_has_label?(issue, build_label)
+            Aidp.log_debug("watch_runner", "build_skip_label_mismatch", issue: issue[:number], labels: issue[:labels])
+            next
+          end
 
           status = @state_store.build_status(issue[:number])
-          next if status["status"] == "completed"
+          if status["status"] == "completed"
+            Aidp.log_debug("watch_runner", "build_skip_completed", issue: issue[:number])
+            next
+          end
 
           detailed = @repository_client.fetch_issue(issue[:number])
 
           # Check author authorization before processing
-          next unless @safety_checker.should_process_issue?(detailed, enforce: false)
+          unless @safety_checker.should_process_issue?(detailed, enforce: false)
+            Aidp.log_debug("watch_runner", "build_skip_unauthorized_author", issue: detailed[:number], author: detailed[:author])
+            next
+          end
 
+          Aidp.log_debug("watch_runner", "build_process", issue: detailed[:number])
           @build_processor.process(detailed)
         rescue RepositorySafetyChecker::UnauthorizedAuthorError => e
           Aidp.log_warn("watch_runner", "unauthorized issue author", issue: issue[:number], error: e.message)

data/lib/aidp/workflows/guided_agent.rb

@@ -229,16 +229,34 @@ module Aidp
           end
 
           combined_prompt = "#{system_prompt}\n\n#{user_prompt}"
+
+          # Record timing for metrics
+          start_time = Time.now
           result = provider.send_message(prompt: combined_prompt)
+          duration = Time.now - start_time
 
           if result.nil? || result.empty?
+            # Record failed metric
+            @provider_manager.record_metrics(provider_name, success: false, duration: duration, error: StandardError.new("Empty response")) if @provider_manager.respond_to?(:record_metrics)
             raise ConversationError, "Provider request failed: empty response"
           end
 
+          # Record successful metric
+          @provider_manager.record_metrics(provider_name, success: true, duration: duration) if @provider_manager.respond_to?(:record_metrics)
+
           result
         rescue => e
           message = e.message.to_s
 
+          # Record failed metric (if we haven't already from empty response check)
+          if defined?(start_time) && defined?(provider_name) && defined?(duration).nil?
+            duration = Time.now - start_time
+            @provider_manager.record_metrics(provider_name, success: false, duration: duration, error: e) if @provider_manager.respond_to?(:record_metrics)
+          end
+
+          # Extract rate limit reset time from error message (especially Claude)
+          extract_and_save_rate_limit_info(provider_name, message) if defined?(provider_name)
+
           # Classify error type for better handling
           classified = if message =~ /resource[_ ]exhausted/i || message =~ /\[resource_exhausted\]/i
             "resource_exhausted"
@@ -319,6 +337,41 @@ module Aidp
         Aidp.logger.warn("guided_agent", "Failed verbose iteration emit", error: e.message)
       end
 
+      # Extract rate limit reset time from error message and save to provider manager
+      def extract_and_save_rate_limit_info(provider_name, error_message)
+        return unless @provider_manager.respond_to?(:mark_rate_limited)
+        return unless error_message
+
+        # Claude error format: "please try again in 1m23s" or "retry after X seconds/minutes"
+        reset_time = nil
+
+        if error_message =~ /try again in (\d+)m(\d+)s/i
+          minutes = $1.to_i
+          seconds = $2.to_i
+          reset_time = Time.now + (minutes * 60) + seconds
+        elsif error_message =~ /try again in (\d+)s/i
+          seconds = $1.to_i
+          reset_time = Time.now + seconds
+        elsif error_message =~ /try again in (\d+)m/i
+          minutes = $1.to_i
+          reset_time = Time.now + (minutes * 60)
+        elsif error_message =~ /retry after (\d+) seconds?/i
+          seconds = $1.to_i
+          reset_time = Time.now + seconds
+        elsif error_message =~ /retry after (\d+) minutes?/i
+          minutes = $1.to_i
+          reset_time = Time.now + (minutes * 60)
+        end
+
+        # Mark provider as rate limited with extracted reset time
+        if reset_time
+          @provider_manager.mark_rate_limited(provider_name, reset_time)
+          Aidp.logger.info("guided_agent", "Extracted rate limit reset time", provider: provider_name, reset_at: reset_time.iso8601)
+        end
+      rescue => e
+        Aidp.logger.warn("guided_agent", "Failed to extract rate limit info", error: e.message)
+      end
+
       def validate_provider_configuration!
         configured = @provider_manager.configured_providers
         if configured.nil? || configured.empty?