aidp 0.30.0 → 0.32.0

data/lib/aidp/setup/wizard.rb

@@ -50,6 +50,7 @@ module Aidp
         return @saved if skip_wizard?
 
         configure_providers
+        configure_harness_settings
         configure_thinking_tiers
         configure_work_loop
         configure_branching
@@ -285,6 +286,24 @@ module Aidp
         show_provider_summary(provider_choice, cleaned_fallbacks) unless provider_choice == "custom"
       end
 
+      # -------------------------------------------
+      # Harness settings (retries, limits, etc.)
+      # -------------------------------------------
+      def configure_harness_settings
+        prompt.say("\n⚙️  Harness Configuration")
+        prompt.say("  Advanced settings for provider behavior")
+        existing = get([:harness]) || {}
+
+        return unless prompt.yes?("Configure advanced harness settings?", default: false)
+
+        max_retries = ask_with_default(
+          "Maximum retry attempts for failed LLM calls",
+          (existing[:max_retries] || 2).to_s
+        ) { |value| value.to_i }
+
+        set([:harness, :max_retries], max_retries)
+      end
+
       # Removed MCP configuration step (MCP now expected to be provider-specific if used)
 
       # -------------------------------------------
@@ -473,6 +492,7 @@ module Aidp
         prompt.say("\n⚙️  Work loop configuration")
         prompt.say("-" * 40)
 
+        configure_work_loop_limits
         configure_test_commands
         configure_linting
         configure_watch_patterns
@@ -482,6 +502,19 @@ module Aidp
         configure_vcs_behavior
       end
 
+      def configure_work_loop_limits
+        existing = get([:work_loop]) || {}
+
+        return unless prompt.yes?("Configure work loop limits?", default: false)
+
+        max_iterations = ask_with_default(
+          "Maximum work loop iterations",
+          (existing[:max_iterations] || 50).to_s
+        ) { |value| value.to_i }
+
+        set([:work_loop, :max_iterations], max_iterations)
+      end
+
       def configure_test_commands
         existing = get([:work_loop, :test]) || {}
 
@@ -999,6 +1032,7 @@ module Aidp
 
         configure_watch_safety
         configure_watch_labels
+        configure_watch_change_requests
         configure_watch_label_creation
       end
 
@@ -1066,6 +1100,11 @@ module Aidp
           existing[:ci_fix_trigger] || "aidp-fix-ci"
         )
 
+        auto_trigger = ask_with_default(
+          "Label to trigger fully autonomous build+review+CI",
+          existing[:auto_trigger] || "aidp-auto"
+        )
+
         change_request_trigger = ask_with_default(
           "Label to trigger PR change implementation",
           existing[:change_request_trigger] || "aidp-request-changes"
@@ -1078,10 +1117,35 @@ module Aidp
           build_trigger: build_trigger,
           review_trigger: review_trigger,
           ci_fix_trigger: ci_fix_trigger,
+          auto_trigger: auto_trigger,
           change_request_trigger: change_request_trigger
         })
       end
 
+      def configure_watch_change_requests
+        prompt.say("\n📝 PR Change Request Configuration")
+        prompt.say("  Configure how AIDP handles automated PR change requests")
+        existing = get([:watch, :change_requests]) || {}
+
+        max_diff_size = ask_with_default(
+          "Maximum PR diff size (lines) for change requests",
+          (existing[:max_diff_size] || 5000).to_s
+        ) { |value| value.to_i }
+
+        post_comments = prompt.yes?(
+          "Post detection comments when work is detected?",
+          default: existing.fetch(:post_detection_comments, true)
+        )
+
+        set([:watch, :change_requests], {
+          max_diff_size: max_diff_size
+        })
+
+        set([:watch], {
+          post_detection_comments: post_comments
+        }.merge(get([:watch]) || {}))
+      end
+
       def configure_watch_label_creation
         prompt.say("\n🏷️  GitHub Label Auto-Creation")
         prompt.say("  Automatically create GitHub labels for watch mode if they don't exist")
@@ -1222,6 +1286,7 @@ module Aidp
           build_trigger: "5319E7",       # Purple
           review_trigger: "FBCA04",      # Yellow
           ci_fix_trigger: "D93F0B",      # Red
+          auto_trigger: "0C8BD6",        # Blue (distinct from build)
           change_request_trigger: "F9D0C4",  # Light pink
           in_progress: "1D76DB"          # Dark blue (internal coordination)
         }

data/lib/aidp/util.rb

@@ -28,6 +28,17 @@ module Aidp
       File.write(path, content)
     end
 
+    # Walk upward to find the nearest project root (git/package manager markers)
+    def self.find_project_root(start_dir = Dir.pwd)
+      dir = File.expand_path(start_dir)
+      until dir == File.dirname(dir)
+        return dir if project_root?(dir)
+        dir = File.dirname(dir)
+      end
+      # Fall back to the original directory when no markers were found
+      File.expand_path(start_dir)
+    end
+
     def self.project_root?(dir = Dir.pwd)
       File.exist?(File.join(dir, ".git")) ||
         File.exist?(File.join(dir, "package.json")) ||

data/lib/aidp/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Aidp
-  VERSION = "0.30.0"
+  VERSION = "0.32.0"
 end

data/lib/aidp/watch/auto_pr_processor.rb

@@ -0,0 +1,86 @@
+# frozen_string_literal: true
+
+require_relative "../message_display"
+require_relative "github_state_extractor"
+
+module Aidp
+  module Watch
+    # Handles the aidp-auto label on PRs by chaining review and CI-fix flows
+    # until the PR is ready for human review.
+    class AutoPrProcessor
+      include Aidp::MessageDisplay
+
+      DEFAULT_AUTO_LABEL = "aidp-auto"
+
+      def initialize(repository_client:, state_store:, review_processor:, ci_fix_processor:, label_config: {}, verbose: false)
+        @repository_client = repository_client
+        @state_store = state_store
+        @review_processor = review_processor
+        @ci_fix_processor = ci_fix_processor
+        @state_extractor = GitHubStateExtractor.new(repository_client: repository_client)
+        @verbose = verbose
+        @auto_label = label_config[:auto_trigger] || label_config["auto_trigger"] || DEFAULT_AUTO_LABEL
+      end
+
+      def process(pr)
+        number = pr[:number]
+        Aidp.log_debug("auto_pr_processor", "process_started", pr: number, title: pr[:title])
+        display_message("🤖 Running autonomous review/CI loop for PR ##{number}", type: :info)
+
+        # Run review and CI fix flows. Each processor is responsible for its own guards.
+        @review_processor.process(pr)
+        @ci_fix_processor.process(pr)
+
+        finalize_if_ready(pr_number: number)
+      rescue => e
+        Aidp.log_error("auto_pr_processor", "process_failed", pr: pr[:number], error: e.message, error_class: e.class.name)
+        display_message("❌ aidp-auto failed on PR ##{pr[:number]}: #{e.message}", type: :error)
+      end
+
+      attr_reader :auto_label
+
+      private
+
+      def finalize_if_ready(pr_number:)
+        pr_data = @repository_client.fetch_pull_request(pr_number)
+        ci_status = @repository_client.fetch_ci_status(pr_number)
+
+        review_done = @state_extractor.review_completed?(pr_data) || @state_store.review_processed?(pr_number)
+        ci_passing = ci_status[:state] == "success"
+
+        Aidp.log_debug("auto_pr_processor", "completion_check",
+          pr: pr_number,
+          review_done: review_done,
+          ci_state: ci_status[:state])
+
+        return unless review_done && ci_passing
+
+        post_completion_comment(pr_number)
+        remove_auto_label(pr_number)
+      end
+
+      def post_completion_comment(pr_number)
+        comment = <<~COMMENT
+          ## 🤖 aidp-auto
+
+          - Automated review completed
+          - CI is passing
+
+          Marking this PR ready for human review and removing the `#{@auto_label}` label.
+        COMMENT
+
+        @repository_client.post_comment(pr_number, comment)
+        display_message("💬 Posted aidp-auto completion comment on PR ##{pr_number}", type: :success)
+      rescue => e
+        Aidp.log_warn("auto_pr_processor", "comment_failed", pr: pr_number, error: e.message)
+      end
+
+      def remove_auto_label(pr_number)
+        @repository_client.remove_labels(pr_number, @auto_label)
+        display_message("🏷️  Removed '#{@auto_label}' from PR ##{pr_number}", type: :info)
+      rescue => e
+        Aidp.log_warn("auto_pr_processor", "remove_label_failed", pr: pr_number, error: e.message)
+      end
+    end
+  end
+end

data/lib/aidp/watch/auto_processor.rb

@@ -0,0 +1,78 @@
+# frozen_string_literal: true
+
+require_relative "../message_display"
+
+module Aidp
+  module Watch
+    # Handles the aidp-auto label on issues by delegating to the BuildProcessor
+    # and transferring the label to the created PR once work completes.
+    class AutoProcessor
+      include Aidp::MessageDisplay
+
+      DEFAULT_AUTO_LABEL = "aidp-auto"
+
+      attr_reader :auto_label
+
+      def initialize(repository_client:, state_store:, build_processor:, label_config: {}, verbose: false)
+        @repository_client = repository_client
+        @state_store = state_store
+        @build_processor = build_processor
+        @verbose = verbose
+
+        # Allow overrides from watch config
+        @auto_label = label_config[:auto_trigger] || label_config["auto_trigger"] || DEFAULT_AUTO_LABEL
+      end
+
+      def process(issue)
+        number = issue[:number]
+        Aidp.log_debug("auto_processor", "process_started", issue: number, title: issue[:title])
+        display_message("🤖 Starting autonomous build for issue ##{number}", type: :info)
+
+        @build_processor.process(issue)
+
+        status = @state_store.build_status(number)
+        pr_url = status["pr_url"]
+        pr_number = extract_pr_number(pr_url)
+
+        unless status["status"] == "completed" && pr_number
+          Aidp.log_debug("auto_processor", "no_pr_to_transfer", issue: number, status: status["status"], pr_url: pr_url)
+          return
+        end
+
+        transfer_label_to_pr(issue_number: number, pr_number: pr_number)
+      rescue => e
+        Aidp.log_error("auto_processor", "process_failed", issue: issue[:number], error: e.message, error_class: e.class.name)
+        display_message("❌ aidp-auto failed for issue ##{issue[:number]}: #{e.message}", type: :error)
+      end
+
+      private
+
+      def extract_pr_number(pr_url)
+        return nil unless pr_url
+
+        match = pr_url.match(%r{/pull/(\d+)}i)
+        match && match[1].to_i
+      end
+
+      def transfer_label_to_pr(issue_number:, pr_number:)
+        Aidp.log_debug("auto_processor", "transferring_label", issue: issue_number, pr: pr_number, label: @auto_label)
+
+        begin
+          @repository_client.add_labels(pr_number, @auto_label)
+          display_message("🏷️  Added '#{@auto_label}' to PR ##{pr_number}", type: :info)
+        rescue => e
+          Aidp.log_warn("auto_processor", "add_label_failed", pr: pr_number, label: @auto_label, error: e.message)
+          display_message("⚠️  Failed to add '#{@auto_label}' to PR ##{pr_number}: #{e.message}", type: :warn)
+        end
+
+        begin
+          @repository_client.remove_labels(issue_number, @auto_label)
+          display_message("🏷️  Removed '#{@auto_label}' from issue ##{issue_number}", type: :muted)
+        rescue => e
+          Aidp.log_warn("auto_processor", "remove_label_failed", issue: issue_number, label: @auto_label, error: e.message)
+          display_message("⚠️  Failed to remove '#{@auto_label}' from issue ##{issue_number}: #{e.message}", type: :warn)
+        end
+      end
+    end
+  end
+end

data/lib/aidp/watch/change_request_processor.rb

@@ -57,7 +57,8 @@ module Aidp
           run_tests_before_push: true,
           commit_message_prefix: "aidp: pr-change",
           require_comment_reference: true,
-          max_diff_size: 2000
+          max_diff_size: 2000,
+          allow_large_pr_worktree_bypass: true # Default to always using worktree for large PRs
         }.merge(symbolize_keys(change_request_config))
 
         # Load safety configuration
@@ -95,16 +96,23 @@ module Aidp
           return
         end
 
-        # Fetch diff to check size
+        # If max_diff_size is set, attempt to fetch and check diff
+        # But bypass restriction for worktree-based workflows
         diff = @repository_client.fetch_pull_request_diff(number)
         diff_size = diff.lines.count
 
-        if diff_size > @config[:max_diff_size]
+        # Check if we want to use the worktree bypass
+        use_worktree_bypass = @config[:allow_large_pr_worktree_bypass] || @config[:allow_large_pr_worktree_bypass].nil?
+
+        if diff_size > @config[:max_diff_size] && !use_worktree_bypass
           display_message("⚠️  PR ##{number} diff too large (#{diff_size} lines > #{@config[:max_diff_size]}). Skipping.", type: :warn)
           post_diff_too_large_comment(pr, diff_size)
           return
         end
 
+        # Log the diff size for observability
+        Aidp.log_debug("change_request_processor", "PR diff size", number: number, size: diff_size, max_allowed: @config[:max_diff_size], worktree_bypass: use_worktree_bypass)
+
         # Analyze change requests
         analysis_result = analyze_change_requests(pr_data: pr_data, comments: authorized_comments, diff: diff)
 
@@ -308,40 +316,105 @@ module Aidp
         head_ref = pr_data[:head_ref]
         pr_number = pr_data[:number]
 
-        # Check if a worktree already exists for this branch
+        worktree_path = resolve_worktree_for_pr(pr_data)
+
+        Dir.chdir(worktree_path) do
+          run_git(%w[fetch origin], allow_failure: true)
+          run_git(["checkout", head_ref])
+          run_git(%w[pull --ff-only], allow_failure: true)
+        end
+
+        @project_dir = worktree_path
+
+        Aidp.log_debug("change_request_processor", "Checked out PR branch", branch: head_ref, worktree: worktree_path)
+        display_message("🌿 Using worktree for PR ##{pr_number}: #{head_ref}", type: :info)
+      end
+
+      def resolve_worktree_for_pr(pr_data)
+        head_ref = pr_data[:head_ref]
+        pr_number = pr_data[:number]
+
         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])
+          return existing[:path]
+        end
+
+        issue_worktree = find_issue_worktree_for_pr(pr_data)
+        return issue_worktree if issue_worktree
+
+        create_worktree_for_pr(pr_data)
+      end
+
+      def find_issue_worktree_for_pr(pr_data)
+        pr_number = pr_data[:number]
+        linked_issue_numbers = extract_issue_numbers_from_pr(pr_data)
+
+        build_match = @state_store.find_build_by_pr(pr_number)
+        linked_issue_numbers << build_match[:issue_number] if build_match
+        linked_issue_numbers = linked_issue_numbers.compact.uniq
 
-          # Update @project_dir to point to the worktree
-          @project_dir = existing[:path]
+        linked_issue_numbers.each do |issue_number|
+          workstream = @state_store.workstream_for_issue(issue_number)
+          next unless workstream
 
-          # 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)
+          slug = workstream[:workstream]
+          branch = workstream[:branch]
+
+          if slug
+            info = Aidp::Worktree.info(slug: slug, project_dir: @project_dir)
+            if info && info[:active]
+              Aidp.log_debug("change_request_processor", "issue_worktree_reused", pr_number: pr_number, issue_number: issue_number, branch: branch, path: info[:path])
+              display_message("🔄 Reusing worktree #{slug} for issue ##{issue_number} (PR ##{pr_number})", type: :info)
+              return info[:path]
+            end
           end
 
-          return
+          if branch
+            existing = Aidp::Worktree.find_by_branch(branch: branch, project_dir: @project_dir)
+            if existing && existing[:active]
+              Aidp.log_debug("change_request_processor", "issue_branch_worktree_reused", pr_number: pr_number, issue_number: issue_number, branch: branch, path: existing[:path])
+              display_message("🔄 Reusing branch worktree for issue ##{issue_number}: #{branch}", type: :info)
+              return existing[:path]
+            end
+          end
         end
 
-        # Otherwise, use the main worktree
-        Dir.chdir(@project_dir) do
-          # Fetch latest
-          run_git(%w[fetch origin])
+        nil
+      end
 
-          # Checkout the PR branch
-          run_git(["checkout", head_ref])
+      def extract_issue_numbers_from_pr(pr_data)
+        body = pr_data[:body].to_s
+        issue_matches = body.scan(/(?:Fixes|Resolves|Closes)\s+#(\d+)/i).flatten
 
-          # Pull latest changes
-          run_git(%w[pull --ff-only], allow_failure: true)
+        issue_matches.map { |num| num.to_i }.uniq
+      end
+
+      def create_worktree_for_pr(pr_data)
+        head_ref = pr_data[:head_ref]
+        pr_number = pr_data[:number]
+        slug = "pr-#{pr_number}-change-requests"
+
+        display_message("🌿 Creating worktree for PR ##{pr_number}: #{head_ref}", type: :info)
+
+        Dir.chdir(@project_dir) do
+          run_git(%w[fetch origin], allow_failure: true)
         end
 
-        Aidp.log_debug("change_request_processor", "Checked out PR branch", branch: head_ref)
-        display_message("🌿 Checked out branch: #{head_ref}", type: :info)
+        result = Aidp::Worktree.create(
+          slug: slug,
+          project_dir: @project_dir,
+          branch: head_ref,
+          base_branch: pr_data[:base_ref]
+        )
+
+        worktree_path = result[:path]
+        Aidp.log_debug("change_request_processor", "worktree_created", pr_number: pr_number, branch: head_ref, path: worktree_path)
+        display_message("✅ Worktree created at #{worktree_path}", type: :success)
+
+        worktree_path
       end
 
       def apply_changes(changes)
@@ -704,15 +777,20 @@ module Aidp
         comment = <<~COMMENT
           #{COMMENT_HEADER}
 
-          ⚠️  PR diff is too large for automated change requests.
+          ⚠️  PR diff is too large for default change requests.
 
           **Current size:** #{diff_size} lines
           **Maximum allowed:** #{@config[:max_diff_size]} lines
 
-          For large PRs, please consider:
-          1. Breaking the PR into smaller chunks
-          2. Implementing changes manually
-          3. Increasing `max_diff_size` in your `aidp.yml` configuration if appropriate
+          For large PRs, you have several options:
+          1. Enable worktree-based large PR handling:
+             Set `allow_large_pr_worktree_bypass: true` in your `aidp.yml`
+          2. Break the PR into smaller chunks
+          3. Implement changes manually
+          4. Increase `max_diff_size` in your configuration
+
+          The worktree bypass allows processing large PRs by working directly in the branch
+          instead of using diff-based changes.
         COMMENT
 
         begin

data/lib/aidp/watch/runner.rb

@@ -14,6 +14,8 @@ require_relative "../auto_update"
 require_relative "review_processor"
 require_relative "ci_fix_processor"
 require_relative "change_request_processor"
+require_relative "auto_processor"
+require_relative "auto_pr_processor"
 
 module Aidp
   module Watch
@@ -70,6 +72,13 @@ module Aidp
           verbose: verbose,
           label_config: label_config
         )
+        @auto_processor = AutoProcessor.new(
+          repository_client: @repository_client,
+          state_store: @state_store,
+          build_processor: @build_processor,
+          label_config: label_config,
+          verbose: verbose
+        )
 
         # Initialize auto-update coordinator
         @auto_update_coordinator = Aidp::AutoUpdate.coordinator(project_dir: project_dir)
@@ -90,6 +99,14 @@ module Aidp
           label_config: label_config,
           verbose: verbose
         )
+        @auto_pr_processor = AutoPrProcessor.new(
+          repository_client: @repository_client,
+          state_store: @state_store,
+          review_processor: @review_processor,
+          ci_fix_processor: @ci_fix_processor,
+          label_config: label_config,
+          verbose: verbose
+        )
         @change_request_processor = ChangeRequestProcessor.new(
           repository_client: @repository_client,
           state_store: @state_store,
@@ -142,9 +159,11 @@ module Aidp
       def process_cycle
         process_plan_triggers
         process_build_triggers
+        process_auto_issue_triggers
         check_for_updates_if_due
         process_review_triggers
         process_ci_fix_triggers
+        process_auto_pr_triggers
         process_change_request_triggers
       end
 
@@ -264,6 +283,54 @@ module Aidp
         end
       end
 
+      def process_auto_issue_triggers
+        auto_label = @auto_processor.auto_label
+        begin
+          issues = @repository_client.list_issues(labels: [auto_label], state: "open")
+        rescue => e
+          Aidp.log_error("watch_runner", "auto_issue_poll_failed", label: auto_label, error: e.message)
+          return
+        end
+
+        Aidp.log_debug("watch_runner", "auto_issue_poll", label: auto_label, total: issues.size)
+
+        issues.each do |issue|
+          unless issue_has_label?(issue, auto_label)
+            Aidp.log_debug("watch_runner", "auto_issue_skip_label_mismatch", issue: issue[:number], labels: issue[:labels])
+            next
+          end
+
+          begin
+            detailed = @repository_client.fetch_issue(issue[:number])
+          rescue => e
+            Aidp.log_error("watch_runner", "auto_issue_fetch_failed", issue: issue[:number], error: e.message)
+            next
+          end
+
+          # Check if already in progress by another instance
+          if @state_extractor.in_progress?(detailed)
+            Aidp.log_debug("watch_runner", "auto_issue_skip_in_progress", issue: detailed[:number])
+            next
+          end
+
+          # Check author authorization before processing
+          unless @safety_checker.should_process_issue?(detailed, enforce: false)
+            Aidp.log_debug("watch_runner", "auto_issue_skip_unauthorized_author", issue: detailed[:number], author: detailed[:author])
+            next
+          end
+
+          # Check if detection comment already posted (deduplication)
+          unless @state_extractor.detection_comment_posted?(detailed, auto_label)
+            post_detection_comment(item_type: :issue, number: detailed[:number], label: auto_label)
+          end
+
+          Aidp.log_debug("watch_runner", "auto_issue_process", issue: detailed[:number])
+          @auto_processor.process(detailed)
+        rescue RepositorySafetyChecker::UnauthorizedAuthorError => e
+          Aidp.log_warn("watch_runner", "unauthorized_issue_author_auto", issue: issue[:number], error: e.message)
+        end
+      end
+
       def process_review_triggers
         review_label = @review_processor.review_label
         begin
@@ -310,6 +377,43 @@ module Aidp
         end
       end
 
+      def process_auto_pr_triggers
+        auto_label = @auto_pr_processor.auto_label
+        prs = @repository_client.list_pull_requests(labels: [auto_label], state: "open")
+        Aidp.log_debug("watch_runner", "auto_pr_poll", label: auto_label, total: prs.size)
+
+        prs.each do |pr|
+          unless pr_has_label?(pr, auto_label)
+            Aidp.log_debug("watch_runner", "auto_pr_skip_label_mismatch", pr: pr[:number], labels: pr[:labels])
+            next
+          end
+
+          detailed = @repository_client.fetch_pull_request(pr[:number])
+
+          # Check if already in progress by another instance
+          if @state_extractor.in_progress?(detailed)
+            Aidp.log_debug("watch_runner", "auto_pr_skip_in_progress", pr: detailed[:number])
+            next
+          end
+
+          # Check author authorization before processing
+          unless @safety_checker.should_process_issue?(detailed, enforce: false)
+            Aidp.log_debug("watch_runner", "auto_pr_skip_unauthorized_author", pr: detailed[:number], author: detailed[:author])
+            next
+          end
+
+          # Check if detection comment already posted (deduplication)
+          unless @state_extractor.detection_comment_posted?(detailed, auto_label)
+            post_detection_comment(item_type: :pr, number: detailed[:number], label: auto_label)
+          end
+
+          Aidp.log_debug("watch_runner", "auto_pr_process", pr: detailed[:number])
+          @auto_pr_processor.process(detailed)
+        rescue RepositorySafetyChecker::UnauthorizedAuthorError => e
+          Aidp.log_warn("watch_runner", "unauthorized_pr_author_auto", pr: pr[:number], error: e.message)
+        end
+      end
+
       def process_ci_fix_triggers
         ci_fix_label = @ci_fix_processor.ci_fix_label
         prs = @repository_client.list_pull_requests(labels: [ci_fix_label], state: "open")