aidp 0.29.0 → 0.31.0

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")

data/lib/aidp/watch/state_store.rb

@@ -65,6 +65,43 @@ module Aidp
         save!
       end
 
+      # Retrieve workstream metadata for a given issue
+      # @return [Hash, nil] {issue_number:, branch:, workstream:, pr_url:, status:}
+      def workstream_for_issue(issue_number)
+        data = build_status(issue_number)
+        return nil if data.nil? || data.empty?
+
+        {
+          issue_number: issue_number.to_i,
+          branch: data["branch"],
+          workstream: data["workstream"],
+          pr_url: data["pr_url"],
+          status: data["status"]
+        }
+      end
+
+      # Find the build/workstream metadata associated with a PR URL
+      # This is used to map change-request PRs back to their originating issues/worktrees.
+      # @return [Hash, nil] {issue_number:, branch:, workstream:, pr_url:, status:}
+      def find_build_by_pr(pr_number)
+        builds.each do |issue_number, data|
+          pr_url = data["pr_url"]
+          next unless pr_url
+
+          if pr_url.match?(%r{/pull/#{pr_number}\b})
+            return {
+              issue_number: issue_number.to_i,
+              branch: data["branch"],
+              workstream: data["workstream"],
+              pr_url: pr_url,
+              status: data["status"]
+            }
+          end
+        end
+
+        nil
+      end
+
       # Review tracking methods
       def review_processed?(pr_number)
         reviews.key?(pr_number.to_s)

data/lib/aidp/worktree_branch_manager.rb

@@ -0,0 +1,147 @@
+require "json"
+require "fileutils"
+
+module Aidp
+  # Manages git worktrees for pull request branches
+  class WorktreeBranchManager
+    class WorktreeCreationError < StandardError; end
+    class WorktreeLookupError < StandardError; end
+
+    # Initialize with a project directory and optional logger
+    def initialize(project_dir:, logger: Aidp.logger)
+      @project_dir = project_dir
+      @logger = logger
+      @worktree_registry_path = File.join(project_dir, ".aidp", "worktrees.json")
+    end
+
+    # Find an existing worktree for a given branch or PR
+    def find_worktree(branch:)
+      Aidp.log_debug("worktree_branch_manager", "finding_worktree", branch: branch)
+
+      raise WorktreeLookupError, "Invalid git repository: #{@project_dir}" unless git_repository?
+
+      # Check registry first
+      worktree_info = read_registry.find { |w| w["branch"] == branch }
+
+      if worktree_info
+        worktree_path = worktree_info["path"]
+        return worktree_path if File.directory?(worktree_path)
+      end
+
+      # Fallback: Use git worktree list to find the worktree
+      worktree_list_output = run_git_command("git worktree list")
+      worktree_list_output.split("\n").each do |line|
+        path, branch_info = line.split(" ", 2)
+        return path if branch_info&.include?(branch)
+      end
+
+      nil
+    rescue => e
+      Aidp.log_error("worktree_branch_manager", "worktree_lookup_failed",
+        error: e.message, branch: branch)
+      raise
+    end
+
+    # Create a new worktree for a branch
+    def create_worktree(branch:, base_branch: "main")
+      Aidp.log_debug("worktree_branch_manager", "creating_worktree",
+        branch: branch, base_branch: base_branch)
+
+      # Validate branch name to prevent path traversal
+      validate_branch_name!(branch)
+
+      # Check if worktree already exists
+      existing_worktree = find_worktree(branch: branch)
+      return existing_worktree if existing_worktree
+
+      # Ensure base branch exists
+      base_ref = (branch == "main") ? "main" : "refs/heads/#{base_branch}"
+      base_exists_cmd = "git show-ref --verify --quiet #{base_ref}"
+
+      system({"GIT_DIR" => File.join(@project_dir, ".git")}, "cd #{@project_dir} && #{base_exists_cmd}")
+
+      # If base branch doesn't exist locally, create it
+      unless $?.success?
+        system({"GIT_DIR" => File.join(@project_dir, ".git")}, "cd #{@project_dir} && git checkout -b #{base_branch}")
+      end
+
+      # Create worktree directory
+      worktree_name = branch.tr("/", "_")
+      worktree_path = File.join(@project_dir, ".worktrees", worktree_name)
+
+      # Ensure .worktrees directory exists
+      FileUtils.mkdir_p(File.join(@project_dir, ".worktrees"))
+
+      # Create the worktree
+      cmd = "git worktree add -b #{branch} #{worktree_path} #{base_branch}"
+      result = system({"GIT_DIR" => File.join(@project_dir, ".git")}, "cd #{@project_dir} && #{cmd}")
+
+      unless result
+        Aidp.log_error("worktree_branch_manager", "worktree_creation_failed",
+          branch: branch, base_branch: base_branch)
+        raise WorktreeCreationError, "Failed to create worktree for branch #{branch}"
+      end
+
+      # Update registry
+      update_registry(branch, worktree_path)
+
+      worktree_path
+    end
+
+    private
+
+    def git_repository?
+      File.directory?(File.join(@project_dir, ".git"))
+    rescue
+      false
+    end
+
+    def validate_branch_name!(branch)
+      if branch.include?("..") || branch.start_with?("/")
+        raise WorktreeCreationError, "Invalid branch name: #{branch}"
+      end
+    end
+
+    def run_git_command(cmd)
+      Dir.chdir(@project_dir) do
+        output = `#{cmd} 2>&1`
+        raise StandardError, output unless $?.success?
+        output
+      end
+    end
+
+    # Read the worktree registry
+    def read_registry
+      return [] unless File.exist?(@worktree_registry_path)
+
+      begin
+        JSON.parse(File.read(@worktree_registry_path))
+      rescue JSON::ParserError
+        Aidp.log_warn("worktree_branch_manager", "invalid_registry",
+          path: @worktree_registry_path)
+        []
+      end
+    end
+
+    # Update the worktree registry
+    def update_registry(branch, path)
+      # Ensure .aidp directory exists
+      FileUtils.mkdir_p(File.dirname(@worktree_registry_path))
+
+      registry = read_registry
+
+      # Remove existing entries for the same branch
+      registry.reject! { |w| w["branch"] == branch }
+
+      # Add new entry
+      registry << {
+        "branch" => branch,
+        "path" => path,
+        "created_at" => Time.now.to_i
+      }
+
+      # Write updated registry
+      File.write(@worktree_registry_path, JSON.pretty_generate(registry))
+    end
+  end
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: aidp
 version: !ruby/object:Gem::Version
-  version: 0.29.0
+  version: 0.31.0
 platform: ruby
 authors:
 - Bart Agapinan
@@ -324,6 +324,7 @@ files:
 - lib/aidp/harness/config_schema.rb
 - lib/aidp/harness/config_validator.rb
 - lib/aidp/harness/configuration.rb
+- lib/aidp/harness/deprecation_cache.rb
 - lib/aidp/harness/enhanced_runner.rb
 - lib/aidp/harness/error_handler.rb
 - lib/aidp/harness/filter_strategy.rb
@@ -448,6 +449,8 @@ files:
 - lib/aidp/utils/devcontainer_detector.rb
 - lib/aidp/version.rb
 - lib/aidp/watch.rb
+- lib/aidp/watch/auto_pr_processor.rb
+- lib/aidp/watch/auto_processor.rb
 - lib/aidp/watch/build_processor.rb
 - lib/aidp/watch/change_request_processor.rb
 - lib/aidp/watch/ci_fix_processor.rb
@@ -472,6 +475,7 @@ files:
 - lib/aidp/workstream_executor.rb
 - lib/aidp/workstream_state.rb
 - lib/aidp/worktree.rb
+- lib/aidp/worktree_branch_manager.rb
 - templates/COMMON/AGENT_BASE.md
 - templates/COMMON/CONVENTIONS.md
 - templates/COMMON/TEMPLATES/ADR_TEMPLATE.md