aidp 0.22.0 → 0.24.0

data/lib/aidp/watch/repository_client.rb

@@ -61,8 +61,22 @@ 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)
+        gh_available? ? add_labels_via_gh(number, labels.flatten) : add_labels_via_api(number, labels.flatten)
+      end
+
+      def remove_labels(number, *labels)
+        gh_available? ? remove_labels_via_gh(number, labels.flatten) : remove_labels_via_api(number, labels.flatten)
+      end
+
+      def replace_labels(number, old_labels:, new_labels:)
+        # Remove old labels and add new ones atomically where possible
+        remove_labels(number, *old_labels) unless old_labels.empty?
+        add_labels(number, *new_labels) unless new_labels.empty?
       end
 
       private
@@ -162,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,
@@ -171,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?
@@ -180,6 +194,66 @@ module Aidp
         stdout.strip
       end
 
+      def add_labels_via_gh(number, labels)
+        return if labels.empty?
+
+        cmd = ["gh", "issue", "edit", number.to_s, "--repo", full_repo]
+        labels.each { |label| cmd += ["--add-label", label] }
+
+        stdout, stderr, status = Open3.capture3(*cmd)
+        raise "Failed to add labels via gh: #{stderr.strip}" unless status.success?
+
+        stdout.strip
+      end
+
+      def add_labels_via_api(number, labels)
+        return if labels.empty?
+
+        uri = URI("https://api.github.com/repos/#{full_repo}/issues/#{number}/labels")
+        request = Net::HTTP::Post.new(uri)
+        request["Content-Type"] = "application/json"
+        request.body = JSON.dump({labels: labels})
+
+        response = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) do |http|
+          http.request(request)
+        end
+
+        raise "Failed to add labels via API (#{response.code})" unless response.code.start_with?("2")
+        response.body
+      end
+
+      def remove_labels_via_gh(number, labels)
+        return if labels.empty?
+
+        cmd = ["gh", "issue", "edit", number.to_s, "--repo", full_repo]
+        labels.each { |label| cmd += ["--remove-label", label] }
+
+        stdout, stderr, status = Open3.capture3(*cmd)
+        raise "Failed to remove labels via gh: #{stderr.strip}" unless status.success?
+
+        stdout.strip
+      end
+
+      def remove_labels_via_api(number, labels)
+        return if labels.empty?
+
+        labels.each do |label|
+          # URL encode the label name
+          encoded_label = URI.encode_www_form_component(label)
+          uri = URI("https://api.github.com/repos/#{full_repo}/issues/#{number}/labels/#{encoded_label}")
+          request = Net::HTTP::Delete.new(uri)
+
+          response = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) do |http|
+            http.request(request)
+          end
+
+          # 404 is OK - label didn't exist
+          unless response.code.start_with?("2") || response.code == "404"
+            raise "Failed to remove label '#{label}' via API (#{response.code})"
+          end
+        end
+      end
+
       def normalize_issue(raw)
         {
           number: raw["number"],

data/lib/aidp/watch/repository_safety_checker.rb

@@ -163,16 +163,25 @@ module Aidp
       end
 
       def public_repos_allowed?
-        @config.dig(:safety, :allow_public_repos) == true
+        # Support both string and symbol keys
+        safety_config = @config[:safety] || @config["safety"] || {}
+        (safety_config[:allow_public_repos] || safety_config["allow_public_repos"]) == true
       end
 
       def author_allowlist
-        @author_allowlist ||= Array(@config.dig(:safety, :author_allowlist)).compact.map(&:to_s)
+        # Support both string and symbol keys
+        safety_config = @config[:safety] || @config["safety"] || {}
+        @author_allowlist ||= Array(
+          safety_config[:author_allowlist] || safety_config["author_allowlist"]
+        ).compact.map(&:to_s)
       end
 
       def safe_environment?
         # Check if running in a container
-        in_container? || @config.dig(:safety, :require_container) == false
+        # Support both string and symbol keys
+        safety_config = @config[:safety] || @config["safety"] || {}
+        require_container = safety_config[:require_container] || safety_config["require_container"]
+        in_container? || require_container == false
       end
 
       def in_container?

data/lib/aidp/watch/runner.rb

@@ -19,12 +19,13 @@ module Aidp
 
       DEFAULT_INTERVAL = 30
 
-      def initialize(issues_url:, interval: DEFAULT_INTERVAL, provider_name: nil, gh_available: nil, project_dir: Dir.pwd, once: false, use_workstreams: true, prompt: TTY::Prompt.new, safety_config: {}, force: false)
+      def initialize(issues_url:, interval: DEFAULT_INTERVAL, provider_name: nil, gh_available: nil, project_dir: Dir.pwd, once: false, use_workstreams: true, prompt: TTY::Prompt.new, safety_config: {}, force: false, verbose: false)
         @prompt = prompt
         @interval = interval
         @once = once
         @project_dir = project_dir
         @force = force
+        @verbose = verbose
 
         owner, repo = RepositoryClient.parse_issues_url(issues_url)
         @repository_client = RepositoryClient.new(owner: owner, repo: repo, gh_available: gh_available)
@@ -33,16 +34,23 @@ module Aidp
           config: safety_config
         )
         @state_store = StateStore.new(project_dir: project_dir, repository: "#{owner}/#{repo}")
+
+        # Extract label configuration from safety_config (it's actually the full watch config)
+        label_config = safety_config[:labels] || safety_config["labels"] || {}
+
         @plan_processor = PlanProcessor.new(
           repository_client: @repository_client,
           state_store: @state_store,
-          plan_generator: PlanGenerator.new(provider_name: provider_name)
+          plan_generator: PlanGenerator.new(provider_name: provider_name, verbose: verbose),
+          label_config: label_config
         )
         @build_processor = BuildProcessor.new(
           repository_client: @repository_client,
           state_store: @state_store,
           project_dir: project_dir,
-          use_workstreams: use_workstreams
+          use_workstreams: use_workstreams,
+          verbose: verbose,
+          label_config: label_config
         )
       end
 
@@ -50,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
@@ -73,15 +94,24 @@ module Aidp
       end
 
       def process_plan_triggers
-        issues = @repository_client.list_issues(labels: [PlanProcessor::PLAN_LABEL], state: "open")
+        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, PlanProcessor::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)
@@ -89,18 +119,30 @@ module Aidp
       end
 
       def process_build_triggers
-        issues = @repository_client.list_issues(labels: [BuildProcessor::BUILD_LABEL], state: "open")
+        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, BuildProcessor::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?

data/lib/aidp/worktree.rb

@@ -2,6 +2,7 @@
 
 require "fileutils"
 require "json"
+require "open3"
 require_relative "workstream_state"
 
 module Aidp
@@ -32,16 +33,14 @@ module Aidp
           raise WorktreeExists, "Worktree already exists at #{worktree_path}"
         end
 
-        # Create the worktree
-        cmd = ["git", "worktree", "add", "-b", branch, worktree_path]
-        cmd << base_branch if base_branch
-
-        Dir.chdir(project_dir) do
-          success = system(*cmd, out: File::NULL, err: File::NULL)
-          unless success
-            raise Error, "Failed to create worktree: #{$?.exitstatus}"
-          end
-        end
+        branch_exists = branch_exists?(project_dir, branch)
+        run_worktree_add!(
+          project_dir: project_dir,
+          branch: branch,
+          branch_exists: branch_exists,
+          worktree_path: worktree_path,
+          base_branch: base_branch
+        )
 
         # Initialize .aidp directory in the worktree
         ensure_aidp_dir(worktree_path)
@@ -203,6 +202,64 @@ module Aidp
       def registry_file_path(project_dir)
         File.join(project_dir, ".aidp", "worktrees.json")
       end
+
+      def branch_exists?(project_dir, branch)
+        Dir.chdir(project_dir) do
+          system("git", "show-ref", "--verify", "--quiet", "refs/heads/#{branch}")
+        end
+      end
+
+      def run_worktree_add!(project_dir:, branch:, branch_exists:, worktree_path:, base_branch:)
+        prune_attempted = false
+
+        loop do
+          cmd = build_worktree_command(branch_exists: branch_exists, branch: branch, worktree_path: worktree_path, base_branch: base_branch)
+          stdout, stderr, status = Dir.chdir(project_dir) { Open3.capture3(*cmd) }
+
+          return if status.success?
+
+          error_output = stderr.strip.empty? ? stdout.strip : stderr.strip
+
+          if !branch_exists && branch_already_exists?(error_output, branch)
+            Aidp.log_debug("worktree", "branch_exists_retry", branch: branch)
+            branch_exists = true
+            next
+          end
+
+          if !prune_attempted && missing_registered_worktree?(error_output)
+            Aidp.log_debug("worktree", "prune_missing_worktree", branch: branch, path: worktree_path)
+            Dir.chdir(project_dir) { Open3.capture3("git", "worktree", "prune") }
+            prune_attempted = true
+            next
+          end
+
+          raise Error, "Failed to create worktree (status=#{status.exitstatus}): #{error_output}"
+        end
+      end
+
+      def build_worktree_command(branch_exists:, branch:, worktree_path:, base_branch:)
+        if branch_exists
+          ["git", "worktree", "add", worktree_path, branch]
+        else
+          cmd = ["git", "worktree", "add", "-b", branch, worktree_path]
+          cmd << base_branch if base_branch
+          cmd
+        end
+      end
+
+      def branch_already_exists?(error_output, branch)
+        return false if error_output.nil? || error_output.empty?
+
+        normalized = error_output.downcase
+        normalized.include?("branch '#{branch.downcase}' already exists") ||
+          normalized.include?("a branch named '#{branch.downcase}' already exists")
+      end
+
+      def missing_registered_worktree?(error_output)
+        return false if error_output.nil? || error_output.empty?
+
+        error_output.downcase.include?("missing but already registered worktree")
+      end
     end
   end
 end

data/templates/work_loop/decide_whats_next.md

@@ -0,0 +1,21 @@
+# Decide the Next Work Loop Unit
+
+You are operating inside the Aidp hybrid work loop. Review the recent deterministic outputs, consider the latest agent summary, and choose the next unit by emitting `NEXT_UNIT: <unit_name>` on its own line.
+
+## Deterministic Outputs
+
+{{DETERMINISTIC_OUTPUTS}}
+
+## Previous Agent Summary
+
+{{PREVIOUS_AGENT_SUMMARY}}
+
+## Guidance
+
+- Pick whichever unit will unblock progress the fastest. Options include deterministic unit names (`run_full_tests`, `run_lint`, etc.), `agentic` to resume coding, or `wait_for_github` if the system must await an external event.
+- Cite concrete evidence from the outputs above when selecting a unit so future readers understand the decision.
+- Keep the rationale tight—two or three sentences max.
+
+## Rationale
+
+Provide the reasoning for your `NEXT_UNIT` decision here.

data/templates/work_loop/diagnose_failures.md

@@ -0,0 +1,21 @@
+# Diagnose Recent Failures
+
+You are operating inside the Aidp work loop. Analyze the most recent deterministic failures and decide how to unblock progress. Finish by emitting `NEXT_UNIT: <unit_name>` on its own line.
+
+## Recent Deterministic Outputs
+
+{{DETERMINISTIC_OUTPUTS}}
+
+## Previous Agent Summary
+
+{{PREVIOUS_AGENT_SUMMARY}}
+
+## Instructions
+
+- Identify the concrete failures and hypothesize root causes.
+- Propose the next best action (run another deterministic unit, resume agentic editing, or wait for GitHub updates).
+- Keep the analysis crisp—focus on evidence and required follow-up work.
+
+## Analysis
+
+Summarize key findings here, then state your `NEXT_UNIT` decision.

metadata

@@ -1,11 +1,11 @@
 --- !ruby/object:Gem::Specification
 name: aidp
 version: !ruby/object:Gem::Version
-  version: 0.22.0
+  version: 0.24.0
 platform: ruby
 authors:
 - Bart Agapinan
-bindir: bin
+bindir: exe
 cert_chain: []
 date: 1980-01-02 00:00:00.000000000 Z
 dependencies:
@@ -231,7 +231,7 @@ extra_rdoc_files: []
 files:
 - LICENSE
 - README.md
-- bin/aidp
+- exe/aidp
 - lib/aidp.rb
 - lib/aidp/analyze/error_handler.rb
 - lib/aidp/analyze/feature_analyzer.rb
@@ -297,6 +297,7 @@ files:
 - lib/aidp/harness/provider_factory.rb
 - lib/aidp/harness/provider_info.rb
 - lib/aidp/harness/provider_manager.rb
+- lib/aidp/harness/provider_metrics.rb
 - lib/aidp/harness/provider_type_checker.rb
 - lib/aidp/harness/runner.rb
 - lib/aidp/harness/simple_user_interface.rb
@@ -347,10 +348,13 @@ files:
 - lib/aidp/prompt_optimization/style_guide_indexer.rb
 - lib/aidp/prompt_optimization/template_indexer.rb
 - lib/aidp/provider_manager.rb
+- lib/aidp/providers/adapter.rb
 - lib/aidp/providers/anthropic.rb
 - lib/aidp/providers/base.rb
+- lib/aidp/providers/capability_registry.rb
 - lib/aidp/providers/codex.rb
 - lib/aidp/providers/cursor.rb
+- lib/aidp/providers/error_taxonomy.rb
 - lib/aidp/providers/gemini.rb
 - lib/aidp/providers/github_copilot.rb
 - lib/aidp/providers/opencode.rb
@@ -360,6 +364,7 @@ files:
 - lib/aidp/setup/devcontainer/generator.rb
 - lib/aidp/setup/devcontainer/parser.rb
 - lib/aidp/setup/devcontainer/port_manager.rb
+- lib/aidp/setup/provider_registry.rb
 - lib/aidp/setup/wizard.rb
 - lib/aidp/skills.rb
 - lib/aidp/skills/composer.rb
@@ -438,6 +443,8 @@ files:
 - templates/skills/product_strategist/SKILL.md
 - templates/skills/repository_analyst/SKILL.md
 - templates/skills/test_analyzer/SKILL.md
+- templates/work_loop/decide_whats_next.md
+- templates/work_loop/diagnose_failures.md
 homepage: https://github.com/viamin/aidp
 licenses:
 - MIT