aidp 0.31.0 → 0.32.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: de5176199a74d1e4992451708e3830fff889cffd526c8bc0887a0aa73a4946a9
-  data.tar.gz: 399593a4d2b8d6991d37d22f383c3cd816b5b276b42e1aa45b0a2df064a470da
+  metadata.gz: c7a02d5fb9cd901a6a74a2b402c5b9d70ea07f47727ddbd388993e9ede64c96b
+  data.tar.gz: fc92260f2b244295b98b5e2e2cdedf4872a18f94f5c3b8bf0031b6a4fc1f6554
 SHA512:
-  metadata.gz: 1d290891c58232da0b32ca1a8560ba211f5a5805c8aa7b24d78f1536cd4e32750ca9ee11dbb8c1b25f018ed50082c5fd52e9412f7b871981f0ff8eacef6f5e15
-  data.tar.gz: c10ee2a196880353991978cdf7a92775e13828b82452ba323c152853740a402a07bad29dad8984da1f9f0e2f650e5075bde9308ac8cc326b89de72af66652b2a
+  metadata.gz: 673505d4036ad47cff7ff1b534e1798e893dcf7fc77f086ee1b6f46ba90b48de4b72333cf63b15db1fd0b16b2b0060c324fe6a1bdf371ae7ec796ce606b454e7
+  data.tar.gz: f99df6bea4120ec723a907e4f4a1cc15dc1c5c52abf3c4753bc5cdd24e6288a5207dca6ae6dc85a6afab442dc2b845de7d7794731f1bd27caeaf22c9e46f656f

data/lib/aidp/execute/work_loop_runner.rb

@@ -7,6 +7,7 @@ require_relative "guard_policy"
 require_relative "work_loop_unit_scheduler"
 require_relative "deterministic_unit"
 require_relative "agent_signal_parser"
+require_relative "steps"
 require_relative "../harness/test_runner"
 require_relative "../errors"
 
@@ -81,6 +82,7 @@ module Aidp
 
         display_message("🔄 Starting hybrid work loop for step: #{step_name}", type: :info)
         display_message("  Flow: Deterministic ↔ Agentic with fix-forward core", type: :info)
+        display_work_context(step_name, context)
 
         display_guard_policy_status
         display_pending_tasks
@@ -1286,6 +1288,74 @@ module Aidp
         display_message("")
       end
 
+      # Show watch-mode context (issue/PR, step position) to improve situational awareness
+      def display_work_context(step_name, context)
+        parts = work_context_parts(step_name, context)
+        return if parts.empty?
+
+        Aidp.log_debug("work_loop", "work_context", step: step_name, parts: parts)
+        display_message("  📡 Context: #{parts.join(" | ")}", type: :info)
+      end
+
+      def work_context_parts(step_name, context)
+        ctx = (@options || {}).merge(context || {})
+        parts = []
+
+        if (step_label = step_position_label(step_name, ctx))
+          parts << step_label
+        end
+
+        if (issue_label = issue_context_label(ctx))
+          parts << issue_label
+        end
+
+        if (pr_label = pr_context_label(ctx))
+          parts << pr_label
+        end
+
+        parts << "Watch mode" if ctx[:workflow_type].to_s == "watch_mode"
+
+        parts.compact
+      end
+
+      def step_position_label(step_name, context)
+        steps = Array(context[:selected_steps]).map(&:to_s)
+        steps = Aidp::Execute::Steps::SPEC.keys if steps.empty?
+        steps = [step_name] if steps.empty?
+        steps << step_name unless steps.include?(step_name)
+
+        index = steps.index(step_name)
+        return nil unless index
+
+        "Step #{index + 1}/#{steps.size} (#{step_name})"
+      end
+
+      def issue_context_label(context)
+        issue_number = context[:issue_number] ||
+          context.dig(:issue, :number) ||
+          extract_number_from_url(context[:issue_url] || context.dig(:issue, :url) || context.dig(:user_input, "Issue URL"), /issues\/(\d+)/)
+
+        return nil unless issue_number
+
+        "Issue ##{issue_number}"
+      end
+
+      def pr_context_label(context)
+        pr_number = context[:pr_number] ||
+          context.dig(:pull_request, :number) ||
+          extract_number_from_url(context[:pr_url] || context.dig(:pull_request, :url) || context.dig(:user_input, "PR URL") || context.dig(:user_input, "Pull Request URL"), /pull\/(\d+)/)
+
+        return nil unless pr_number
+
+        "PR ##{pr_number}"
+      end
+
+      def extract_number_from_url(url, pattern)
+        return nil unless url
+        match = url.to_s.match(pattern)
+        match && match[1]
+      end
+
       # Append task completion requirement to PROMPT.md
       def append_task_requirement_to_prompt(message)
         task_requirement = []

data/lib/aidp/harness/provider_manager.rb

@@ -38,6 +38,7 @@ module Aidp
         @model_fallback_chains = {}
         @model_switching_enabled = true
         @model_weights = {}
+        @model_denylist = Hash.new { |h, k| h[k] = [] }
         @unavailable_cache = {}
         @binary_check_cache = {}
         @binary_check_ttl = 300 # seconds
@@ -387,10 +388,30 @@ module Aidp
         # Check if model is configured for provider
         return false unless model_configured?(provider_name, model_name)
 
+        # Skip models that were explicitly denied (e.g., unsupported by provider)
+        return false if model_denied?(provider_name, model_name)
+
         # Check if model is not rate limited
         !is_model_rate_limited?(provider_name, model_name)
       end
 
+      # Check if a model has been denylisted for a provider
+      def model_denied?(provider_name, model_name)
+        @model_denylist[provider_name]&.include?(model_name)
+      end
+
+      # Add a model to the denylist for a provider (e.g., unsupported model errors)
+      def deny_model(provider_name, model_name, error: nil)
+        return if provider_name.nil? || model_name.nil?
+        return if model_denied?(provider_name, model_name)
+
+        @model_denylist[provider_name] << model_name
+        Aidp.log_debug("provider_manager", "model_denylisted",
+          provider: provider_name,
+          model: model_name,
+          error: error&.message)
+      end
+
       # Check if model is configured for provider
       def model_configured?(provider_name, model_name)
         models = provider_models(provider_name)
@@ -1279,6 +1300,7 @@ module Aidp
         @model_health.clear
         @model_metrics.clear
         @model_fallback_chains.clear
+        @model_denylist.clear
         @model_rate_limit_info&.clear
         @model_history&.clear
         initialize_fallback_chains
@@ -1436,6 +1458,10 @@ module Aidp
       rescue => e
         log_rescue(e, component: "provider_manager", action: "execute_with_provider", fallback: "error_result", provider: provider_type, model: model_name, prompt_length: prompt.length)
 
+        if unsupported_model_error?(e, model_name)
+          deny_model(provider_type, model_name, error: e)
+        end
+
         # Detect rate limit / quota errors and attempt fallback
         error_message = e.message.to_s.downcase
         is_rate_limit = error_message.include?("rate limit") ||
@@ -1583,6 +1609,18 @@ module Aidp
         ((order[a] || 0) >= (order[b] || 0)) ? a : b
       end
 
+      # Detect unsupported/invalid model errors to avoid reusing the model
+      def unsupported_model_error?(error, model_name)
+        return false if model_name.nil?
+
+        message = error&.message.to_s.downcase
+        return false if message.empty?
+
+        (message.include?("unsupported") && message.include?("model")) ||
+          (message.include?("model") && message.include?("not supported")) ||
+          message.include?("invalid model")
+      end
+
       public
 
       # Log provider switch

data/lib/aidp/harness/provider_metrics.rb

@@ -3,6 +3,7 @@
 require "yaml"
 require "fileutils"
 require_relative "../rescue_logging"
+require_relative "../util"
 
 module Aidp
   module Harness
@@ -14,9 +15,10 @@ module Aidp
       attr_reader :project_dir, :metrics_file, :rate_limit_file
 
       def initialize(project_dir)
-        @project_dir = project_dir
-        @metrics_file = File.join(project_dir, ".aidp", "provider_metrics.yml")
-        @rate_limit_file = File.join(project_dir, ".aidp", "provider_rate_limits.yml")
+        # Store metrics at the repository root so different worktrees/modes share state
+        @project_dir = Aidp::Util.find_project_root(project_dir)
+        @metrics_file = File.join(@project_dir, ".aidp", "provider_metrics.yml")
+        @rate_limit_file = File.join(@project_dir, ".aidp", "provider_rate_limits.yml")
         ensure_directory
       end
 

data/lib/aidp/pr_worktree_manager.rb

@@ -0,0 +1,582 @@
+require "json"
+require "fileutils"
+require "shellwords"
+
+module Aidp
+  # Manages worktrees specifically for Pull Request branches
+  class PrWorktreeManager
+    def initialize(base_repo_path: nil, project_dir: nil, worktree_registry_path: nil)
+      @base_repo_path = base_repo_path || project_dir || Dir.pwd
+      @project_dir = project_dir
+      @worktree_registry_path = worktree_registry_path || File.join(
+        project_dir || File.expand_path("~/.aidp"),
+        "pr_worktrees.json"
+      )
+      FileUtils.mkdir_p(File.dirname(@worktree_registry_path))
+      @worktrees = load_registry
+    end
+
+    attr_reader :worktree_registry_path
+
+    # Find an existing worktree for a given PR number or branch
+    def find_worktree(pr_number = nil, branch: nil)
+      Aidp.log_debug(
+        "pr_worktree_manager",
+        "finding_worktree",
+        pr_number: pr_number,
+        branch: branch
+      )
+
+      # Validate input
+      raise ArgumentError, "Must provide either pr_number or branch" if pr_number.nil? && branch.nil?
+
+      # First, check for exact PR match if PR number is provided
+      existing_worktree = pr_number ? @worktrees[pr_number.to_s] : nil
+      return validate_worktree_path(existing_worktree) if existing_worktree
+
+      # If no PR number, search by branch in all worktrees
+      matching_worktrees = @worktrees.values.select do |details|
+        # Check for exact branch match or remote branch match with advanced checks
+        details.values_at("base_branch", "head_branch").any? do |branch_name|
+          branch_name.end_with?("/#{branch}", "remotes/origin/#{branch}") ||
+            branch_name == branch
+        end
+      end
+
+      # If multiple matching worktrees, prefer most recently created
+      # Use min_by to efficiently find the most recently created worktree
+      matching_worktree = matching_worktrees.min_by { |details| [-details["created_at"].to_i, details["path"]] }
+
+      validate_worktree_path(matching_worktree)
+    end
+
+    # Helper method to validate worktree path and provide consistent logging
+    def validate_worktree_path(worktree_details)
+      return nil unless worktree_details
+
+      # Validate the worktree's integrity
+      if File.exist?(worktree_details["path"])
+        # Check if the worktree has the correct git repository
+        if valid_worktree_repository?(worktree_details["path"])
+          Aidp.log_debug("pr_worktree_manager", "found_existing_worktree",
+            path: worktree_details["path"],
+            base_branch: worktree_details["base_branch"],
+            head_branch: worktree_details["head_branch"])
+          return worktree_details["path"]
+        else
+          Aidp.log_warn("pr_worktree_manager", "corrupted_worktree",
+            pr_number: worktree_details["pr_number"] || "unknown",
+            path: worktree_details["path"])
+        end
+      else
+        Aidp.log_warn("pr_worktree_manager", "worktree_path_missing",
+          pr_number: worktree_details["pr_number"] || "unknown",
+          expected_path: worktree_details["path"])
+      end
+
+      nil
+    end
+
+    # Verify the integrity of the git worktree repository
+    def valid_worktree_repository?(worktree_path)
+      return false unless File.directory?(worktree_path)
+
+      # Check for .git directory or .git file (for submodules)
+      git_dir = File.join(worktree_path, ".git")
+      return false unless File.exist?(git_dir) || File.file?(git_dir)
+
+      true
+    rescue
+      false
+    end
+
+    # Create a new worktree for a PR
+    def create_worktree(pr_number, base_branch, head_branch, allow_duplicate: true, max_diff_size: nil)
+      # Log only the required attributes without max_diff_size
+      Aidp.log_debug(
+        "pr_worktree_manager", "creating_worktree",
+        pr_number: pr_number,
+        base_branch: base_branch,
+        head_branch: head_branch
+      )
+
+      # Validate inputs
+      raise ArgumentError, "PR number must be a positive integer" unless pr_number.to_i > 0
+      raise ArgumentError, "Base branch cannot be empty" if base_branch.nil? || base_branch.empty?
+      raise ArgumentError, "Head branch cannot be empty" if head_branch.nil? || head_branch.empty?
+
+      # Advanced max diff size handling
+      if max_diff_size
+        Aidp.log_debug(
+          "pr_worktree_manager", "diff_size_check",
+          method: "worktree_based_workflow"
+        )
+      end
+
+      # Check for existing worktrees if duplicates are not allowed
+      if !allow_duplicate
+        existing_worktrees = @worktrees.values.select do |details|
+          details["base_branch"] == base_branch && details["head_branch"] == head_branch
+        end
+        return existing_worktrees.first["path"] unless existing_worktrees.empty?
+      end
+
+      # Check if a worktree for this PR already exists
+      existing_path = find_worktree(pr_number)
+      return existing_path if existing_path
+
+      # Generate a unique slug for the worktree
+      slug = "pr-#{pr_number}-#{Time.now.to_i}"
+
+      # Determine the base directory for worktrees
+      base_worktree_dir = @project_dir || File.expand_path("~/.aidp/worktrees")
+      worktree_path = File.join(base_worktree_dir, slug)
+
+      # Ensure base repo path is an actual git repository
+      raise "Not a git repository: #{@base_repo_path}" unless File.exist?(File.join(@base_repo_path, ".git"))
+
+      # Create the worktree directory if it doesn't exist
+      FileUtils.mkdir_p(base_worktree_dir)
+
+      # Verify base branch exists
+      Dir.chdir(@base_repo_path) do
+        # List all remote and local branches
+        branch_list_output = `git branch -a`.split("\n").map(&:strip)
+
+        # More robust branch existence check with expanded match criteria
+        base_branch_exists = branch_list_output.any? do |branch|
+          branch.end_with?("/#{base_branch}", "remotes/origin/#{base_branch}") ||
+            branch == base_branch ||
+            branch == "* #{base_branch}"
+        end
+
+        # Enhance branch tracking and fetching
+        unless base_branch_exists
+          # Try multiple fetch strategies
+          fetch_commands = [
+            "git fetch origin #{base_branch}:#{base_branch} 2>/dev/null",
+            "git fetch origin 2>/dev/null",
+            "git fetch --all 2>/dev/null"
+          ]
+
+          fetch_commands.each do |fetch_cmd|
+            system(fetch_cmd)
+            branch_list_output = `git branch -a`.split("\n").map(&:strip)
+            base_branch_exists = branch_list_output.any? do |branch|
+              branch.end_with?("/#{base_branch}", "remotes/origin/#{base_branch}") ||
+                branch == base_branch ||
+                branch == "* #{base_branch}"
+            end
+            break if base_branch_exists
+          end
+        end
+
+        raise ArgumentError, "Base branch '#{base_branch}' does not exist in the repository" unless base_branch_exists
+
+        # Robust worktree creation with enhanced error handling and logging
+        worktree_create_command = "git worktree add #{Shellwords.escape(worktree_path)} -b #{Shellwords.escape(head_branch)} #{Shellwords.escape(base_branch)}"
+        unless system(worktree_create_command)
+          error_details = {
+            pr_number: pr_number,
+            base_branch: base_branch,
+            head_branch: head_branch,
+            command: worktree_create_command
+          }
+          Aidp.log_error(
+            "pr_worktree_manager", "worktree_creation_failed",
+            error_details
+          )
+
+          # Attempt to diagnose the failure
+          git_status = `git status`
+          Aidp.log_debug(
+            "pr_worktree_manager", "git_status_on_failure",
+            status: git_status
+          )
+
+          raise "Failed to create worktree for PR #{pr_number}"
+        end
+      end
+
+      # Extended validation of worktree creation
+      unless File.exist?(worktree_path) && File.directory?(worktree_path)
+        error_details = {
+          pr_number: pr_number,
+          base_branch: base_branch,
+          head_branch: head_branch,
+          expected_path: worktree_path
+        }
+        Aidp.log_error(
+          "pr_worktree_manager", "worktree_path_validation_failed",
+          error_details
+        )
+        raise "Failed to validate worktree path for PR #{pr_number}"
+      end
+
+      # Prepare registry entry with additional metadata
+      registry_entry = {
+        "path" => worktree_path,
+        "base_branch" => base_branch,
+        "head_branch" => head_branch,
+        "created_at" => Time.now.to_i,
+        "slug" => slug,
+        "source" => "label_workflow"  # Add custom source tracking
+      }
+
+      # Conditionally add max_diff_size only if it's provided
+      registry_entry["max_diff_size"] = max_diff_size if max_diff_size
+
+      # Store in registry
+      @worktrees[pr_number.to_s] = registry_entry
+      save_registry
+
+      Aidp.log_debug(
+        "pr_worktree_manager", "worktree_created",
+        path: worktree_path,
+        pr_number: pr_number
+      )
+
+      worktree_path
+    end
+
+    # Enhanced method to extract changes from PR comments/reviews
+    def extract_pr_changes(changes_description)
+      Aidp.log_debug(
+        "pr_worktree_manager", "extracting_pr_changes",
+        description_length: changes_description&.length
+      )
+
+      return nil if changes_description.nil? || changes_description.empty?
+
+      # Sophisticated change extraction with multiple parsing strategies
+      parsed_changes = {
+        files: [],
+        operations: [],
+        comments: [],
+        metadata: {}
+      }
+
+      # Advanced change detection patterns
+      file_patterns = [
+        /(?:modify|update|add|delete)\s+file:\s*([^\n]+)/i,
+        /\[(\w+)\]\s*([^\n]+)/,           # GitHub-style change indicators
+        /(?:Action:\s*(\w+))\s*File:\s*([^\n]+)/i
+      ]
+
+      # Operation mapping
+      operation_map = {
+        "add" => :create,
+        "create" => :create,
+        "update" => :modify,
+        "modify" => :modify,
+        "delete" => :delete,
+        "remove" => :delete
+      }
+
+      # Parse changes using multiple strategies
+      file_patterns.each do |pattern|
+        changes_description.scan(pattern) do |match|
+          operation = (match.size == 2) ? (match[0].downcase) : nil
+          file = (match.size == 2) ? (match[1].strip) : match[0].strip
+
+          parsed_changes[:files] << file
+          if operation && operation_map.key?(operation)
+            parsed_changes[:operations] << operation_map[operation]
+          end
+        end
+      end
+
+      # Extract potential comments or annotations
+      comment_pattern = /(?:comment|note):\s*(.+)/i
+      changes_description.scan(comment_pattern) do |match|
+        parsed_changes[:comments] << match[0].strip
+      end
+
+      # Additional metadata extraction
+      parsed_changes[:metadata] = {
+        source: "pr_comments",
+        timestamp: Time.now.to_i
+      }
+
+      Aidp.log_debug(
+        "pr_worktree_manager", "pr_changes_extracted",
+        files_count: parsed_changes[:files].size,
+        operations_count: parsed_changes[:operations].size,
+        comments_count: parsed_changes[:comments].size
+      )
+
+      parsed_changes
+    end
+
+    # Enhanced method to apply changes to the worktree with robust handling
+    def apply_worktree_changes(pr_number, changes)
+      Aidp.log_debug(
+        "pr_worktree_manager", "applying_worktree_changes",
+        pr_number: pr_number,
+        changes: changes
+      )
+
+      # Find the worktree for the PR
+      worktree_path = find_worktree(pr_number)
+      raise "No worktree found for PR #{pr_number}" unless worktree_path
+
+      # Track successful and failed file modifications
+      successful_files = []
+      failed_files = []
+
+      Dir.chdir(worktree_path) do
+        changes.fetch(:files, []).each_with_index do |file, index|
+          operation = changes.fetch(:operations, [])[index] || :modify
+          file_path = File.join(worktree_path, file)
+
+          # Enhanced file manipulation with operation-specific handling
+          begin
+            # Ensure safe file path (prevent directory traversal)
+            canonical_path = File.expand_path(file_path)
+            raise SecurityError, "Unsafe file path" unless canonical_path.start_with?(worktree_path)
+
+            # Ensure directory exists for file creation
+            FileUtils.mkdir_p(File.dirname(file_path)) unless File.exist?(File.dirname(file_path))
+
+            case operation
+            when :create, :modify
+              File.write(file_path, "# File #{(operation == :create) ? "added" : "modified"} by AIDP request-changes workflow\n")
+            when :delete
+              FileUtils.rm_f(file_path)
+            else
+              Aidp.log_warn(
+                "pr_worktree_manager", "unknown_file_operation",
+                file: file,
+                operation: operation
+              )
+              next
+            end
+
+            successful_files << file
+            Aidp.log_debug(
+              "pr_worktree_manager", "file_changed",
+              file: file,
+              action: operation
+            )
+          rescue SecurityError => e
+            Aidp.log_error(
+              "pr_worktree_manager", "file_path_security_error",
+              file: file,
+              error: e.message
+            )
+            failed_files << file
+          rescue => e
+            Aidp.log_error(
+              "pr_worktree_manager", "file_change_error",
+              file: file,
+              operation: operation,
+              error: e.message
+            )
+            failed_files << file
+          end
+        end
+
+        # Stage only successfully modified files
+        unless successful_files.empty?
+          system("git add #{successful_files.map { |f| Shellwords.escape(f) }.join(" ")}")
+        end
+      end
+
+      Aidp.log_debug(
+        "pr_worktree_manager", "worktree_changes_summary",
+        pr_number: pr_number,
+        successful_files_count: successful_files.size,
+        failed_files_count: failed_files.size,
+        total_files: changes.fetch(:files, []).size
+      )
+
+      {
+        success: successful_files.size == changes.fetch(:files, []).size,
+        successful_files: successful_files,
+        failed_files: failed_files
+      }
+    end
+
+    # Push changes back to the PR branch with enhanced error handling
+    def push_worktree_changes(pr_number, branch: nil)
+      Aidp.log_debug(
+        "pr_worktree_manager", "pushing_worktree_changes",
+        pr_number: pr_number,
+        branch: branch
+      )
+
+      # Find the worktree and its head branch
+      worktree_path = find_worktree(pr_number)
+      raise "No worktree found for PR #{pr_number}" unless worktree_path
+
+      # Retrieve the head branch from registry if not provided
+      head_branch = branch || @worktrees[pr_number.to_s]["head_branch"]
+      raise "No head branch found for PR #{pr_number}" unless head_branch
+
+      # Comprehensive error tracking
+      push_result = {
+        success: false,
+        git_actions: {
+          staged_changes: false,
+          committed: false,
+          pushed: false
+        },
+        errors: [],
+        changed_files: []
+      }
+
+      Dir.chdir(worktree_path) do
+        # Check staged changes with more robust capture
+        staged_changes_output = `git diff --staged --name-only`.strip
+
+        if !staged_changes_output.empty?
+          push_result[:git_actions][:staged_changes] = true
+          push_result[:changed_files] = staged_changes_output.split("\n")
+
+          # More robust commit command with additional logging
+          commit_message = "Changes applied via AIDP request-changes workflow for PR ##{pr_number}"
+          commit_command = "git commit -m '#{commit_message}' 2>&1"
+          commit_output = `#{commit_command}`.strip
+
+          if $?.success?
+            push_result[:git_actions][:committed] = true
+
+            # Enhanced push with verbose tracking
+            push_command = "git push origin #{head_branch} 2>&1"
+            push_output = `#{push_command}`.strip
+
+            if $?.success?
+              push_result[:git_actions][:pushed] = true
+              push_result[:success] = true
+
+              Aidp.log_debug(
+                "pr_worktree_manager", "changes_pushed_successfully",
+                pr_number: pr_number,
+                branch: head_branch,
+                changed_files_count: push_result[:changed_files].size
+              )
+            else
+              # Detailed push error logging
+              push_result[:errors] << "Push failed: #{push_output}"
+              Aidp.log_error(
+                "pr_worktree_manager", "push_changes_failed",
+                pr_number: pr_number,
+                branch: head_branch,
+                error_details: push_output
+              )
+            end
+          else
+            # Detailed commit error logging
+            push_result[:errors] << "Commit failed: #{commit_output}"
+            Aidp.log_error(
+              "pr_worktree_manager", "commit_changes_failed",
+              pr_number: pr_number,
+              branch: head_branch,
+              error_details: commit_output
+            )
+          end
+        else
+          # No changes to commit
+          push_result[:success] = true
+          Aidp.log_debug(
+            "pr_worktree_manager", "no_changes_to_push",
+            pr_number: pr_number
+          )
+        end
+      end
+
+      push_result
+    end
+
+    # Remove a specific worktree
+    def remove_worktree(pr_number)
+      Aidp.log_debug("pr_worktree_manager", "removing_worktree", pr_number: pr_number)
+
+      existing_worktree = @worktrees[pr_number.to_s]
+      return false unless existing_worktree
+
+      # Remove git worktree
+      system("git worktree remove #{existing_worktree["path"]}") if File.exist?(existing_worktree["path"])
+
+      # Remove from registry and save
+      @worktrees.delete(pr_number.to_s)
+      save_registry
+
+      true
+    end
+
+    # List all active worktrees
+    def list_worktrees
+      # Include all known metadata keys from stored details
+      metadata_keys = ["path", "base_branch", "head_branch", "created_at", "max_diff_size"]
+      @worktrees.transform_values { |details| details.slice(*metadata_keys) }
+    end
+
+    # Cleanup old/stale worktrees (more than 30 days old)
+    def cleanup_stale_worktrees(days_threshold = 30)
+      Aidp.log_debug("pr_worktree_manager", "cleaning_stale_worktrees", threshold_days: days_threshold)
+
+      stale_worktrees = @worktrees.select do |_, details|
+        created_at = Time.at(details["created_at"])
+        (Time.now - created_at) > (days_threshold * 24 * 60 * 60)
+      end
+
+      stale_worktrees.each_key { |pr_number| remove_worktree(pr_number) }
+
+      Aidp.log_debug(
+        "pr_worktree_manager", "stale_worktrees_cleaned",
+        count: stale_worktrees.size
+      )
+    end
+
+    private
+
+    # Load the worktree registry from file
+    def load_registry
+      return {} unless File.exist?(worktree_registry_path)
+
+      begin
+        # Validate file content before parsing
+        registry_content = File.read(worktree_registry_path)
+        return {} if registry_content.strip.empty?
+
+        # Attempt to parse JSON
+        parsed_registry = JSON.parse(registry_content)
+
+        # Additional validation of registry structure
+        if parsed_registry.is_a?(Hash) && parsed_registry.all? { |k, v| k.is_a?(String) && v.is_a?(Hash) }
+          parsed_registry
+        else
+          Aidp.log_warn(
+            "pr_worktree_manager",
+            "invalid_registry_structure",
+            path: worktree_registry_path
+          )
+          {}
+        end
+      rescue JSON::ParserError
+        Aidp.log_warn(
+          "pr_worktree_manager",
+          "invalid_registry",
+          path: worktree_registry_path
+        )
+        {}
+      rescue SystemCallError
+        Aidp.log_warn(
+          "pr_worktree_manager",
+          "registry_read_error",
+          path: worktree_registry_path
+        )
+        {}
+      end
+    end
+
+    # Save the worktree registry to file
+    def save_registry
+      FileUtils.mkdir_p(File.dirname(worktree_registry_path))
+      File.write(worktree_registry_path, JSON.pretty_generate(@worktrees))
+    rescue => e
+      Aidp.log_error("pr_worktree_manager", "registry_save_failed", error: e.message)
+    end
+  end
+end

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.31.0"
+  VERSION = "0.32.0"
 end

data/lib/aidp/worktree_branch_manager.rb

@@ -12,6 +12,7 @@ module Aidp
       @project_dir = project_dir
       @logger = logger
       @worktree_registry_path = File.join(project_dir, ".aidp", "worktrees.json")
+      @pr_worktree_registry_path = File.join(project_dir, ".aidp", "pr_worktrees.json")
     end
 
     # Find an existing worktree for a given branch or PR
@@ -20,7 +21,7 @@ module Aidp
 
       raise WorktreeLookupError, "Invalid git repository: #{@project_dir}" unless git_repository?
 
-      # Check registry first
+      # First, check registry first for exact branch match
       worktree_info = read_registry.find { |w| w["branch"] == branch }
 
       if worktree_info
@@ -42,6 +43,38 @@ module Aidp
       raise
     end
 
+    # Find or create a worktree for a PR, with advanced lookup strategies
+    def find_or_create_pr_worktree(pr_number:, head_branch:, base_branch: "main")
+      Aidp.log_debug("worktree_branch_manager", "finding_or_creating_pr_worktree",
+        pr_number: pr_number, head_branch: head_branch, base_branch: base_branch)
+
+      # First, check the PR-specific registry
+      pr_registry = read_pr_registry
+      pr_worktree = pr_registry.find { |w| w["pr_number"] == pr_number }
+
+      # If a valid worktree exists in the registry, return it
+      if pr_worktree
+        worktree_path = pr_worktree["path"]
+        return worktree_path if File.directory?(worktree_path)
+      end
+
+      # Attempt to find worktree by branch name
+      existing_worktree = find_worktree(branch: head_branch)
+      return existing_worktree if existing_worktree
+
+      # If no existing worktree, create a new one
+      worktree_path = create_worktree(branch: head_branch, base_branch: base_branch)
+
+      # Update PR-specific registry
+      update_pr_registry(pr_number, head_branch, worktree_path, base_branch)
+
+      worktree_path
+    rescue => e
+      Aidp.log_error("worktree_branch_manager", "pr_worktree_creation_failed",
+        error: e.message, pr_number: pr_number, head_branch: head_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",
@@ -123,6 +156,19 @@ module Aidp
       end
     end
 
+    # Read the PR-specific worktree registry
+    def read_pr_registry
+      return [] unless File.exist?(@pr_worktree_registry_path)
+
+      begin
+        JSON.parse(File.read(@pr_worktree_registry_path))
+      rescue JSON::ParserError
+        Aidp.log_warn("worktree_branch_manager", "invalid_pr_registry",
+          path: @pr_worktree_registry_path)
+        []
+      end
+    end
+
     # Update the worktree registry
     def update_registry(branch, path)
       # Ensure .aidp directory exists
@@ -143,5 +189,28 @@ module Aidp
       # Write updated registry
       File.write(@worktree_registry_path, JSON.pretty_generate(registry))
     end
+
+    # Update the PR-specific worktree registry
+    def update_pr_registry(pr_number, head_branch, worktree_path, base_branch)
+      # Ensure .aidp directory exists
+      FileUtils.mkdir_p(File.dirname(@pr_worktree_registry_path))
+
+      registry = read_pr_registry
+
+      # Remove existing entries for the same PR
+      registry.reject! { |w| w["pr_number"] == pr_number }
+
+      # Add new entry
+      registry << {
+        "pr_number" => pr_number,
+        "head_branch" => head_branch,
+        "base_branch" => base_branch,
+        "path" => worktree_path,
+        "created_at" => Time.now.to_i
+      }
+
+      # Write updated registry
+      File.write(@pr_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.31.0
+  version: 0.32.0
 platform: ruby
 authors:
 - Bart Agapinan
@@ -401,6 +401,7 @@ files:
 - lib/aidp/planning/mappers/persona_mapper.rb
 - lib/aidp/planning/parsers/document_parser.rb
 - lib/aidp/planning/parsers/feedback_data_parser.rb
+- lib/aidp/pr_worktree_manager.rb
 - lib/aidp/prompt_optimization/context_composer.rb
 - lib/aidp/prompt_optimization/optimizer.rb
 - lib/aidp/prompt_optimization/prompt_builder.rb