aidp 0.25.0 → 0.26.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 348238e998f8d75ef9f23fcb5a8f4517b6fde0dd9612a4520583b03ab692cc23
-  data.tar.gz: ed8db8dbd0459211e65b76784b6074b65f2689cdb76f7b7c74bcb029d4c9f74d
+  metadata.gz: 0b4770edc850e936b3201ec532cdd369f7fd881ff79dd10e24407c6453b8cb22
+  data.tar.gz: d7d2640aa63d2c25afbf795bbf77d48741bdd99d6a074765fa5595f3982b96e6
 SHA512:
-  metadata.gz: ac5628709db6248036d75e5873252089e497b96bac785a610bcc9b153b350714d4a5e441610501b3897cf6994d9081fa36e990da67678b86c167d5e58b048f64
-  data.tar.gz: dd660df245ffd1bb28048e4b76b231efce515e880fc8cfa088af6a25b1fcb42b98562d592880d256ade4474a3db6879567f3fb2670e750da0ee94ea5347b2df7
+  metadata.gz: 1841e0b35478d65d382d13dd138955c30655002b91c2a83d96ec2c83925eec4f954892aa710ded867b50554dbc9653bddfad5c5aa915890e674bb49afed347bc
+  data.tar.gz: 1fc1443566c4e01e0c6ff25f1ae62c890ddcd5373257265ee7119ea8db359c20282cf646d61b955204e4dc538ceb9c6313725cb4fed21cda231b97321cc2c030

data/README.md

@@ -218,7 +218,9 @@ aidp watch owner/repo --once
 
 **Label Workflow:**
 
-AIDP uses a smart label-based workflow to manage the lifecycle of automated issue resolution:
+AIDP uses a smart label-based workflow to manage both issues and pull requests:
+
+#### Issue Workflow (Plan & Build)
 
 1. **Planning Phase** (`aidp-plan` label):
    - Add this label to an issue to trigger plan generation
@@ -247,6 +249,32 @@ AIDP uses a smart label-based workflow to manage the lifecycle of automated issu
      - Posts completion comment with summary
      - Automatically removes the `aidp-build` label
 
+#### Pull Request Workflow (Review, CI Fix, Change Requests)
+
+<!-- markdownlint-disable-next-line MD029 -->
+1. **Code Review** (`aidp-review` label):
+   - Add this label to any PR to trigger automated code review
+   - AIDP analyzes code from three expert perspectives (Senior Developer, Security Specialist, Performance Analyst)
+   - Posts a comprehensive review comment with severity-categorized findings (High Priority, Major, Minor, Nit)
+   - Automatically removes the label after posting review
+   - No commits are made - review only
+
+2. **CI Fix** (`aidp-fix-ci` label):
+   - Add this label to a PR with failing CI checks
+   - AIDP analyzes CI failure logs and identifies root causes
+   - Automatically fixes issues like linting errors, simple test failures, and dependency problems
+   - Commits and pushes fixes to the PR branch
+   - Posts a summary of what was fixed
+   - Automatically removes the label after completion
+
+3. **Change Requests** (`aidp-request-changes` label):
+   - Comment on your own PR describing desired changes, then add this label
+   - AIDP implements the requested changes on the PR branch
+   - Runs tests/linters and commits changes
+   - **If clarification needed**: Replaces label with `aidp-needs-input` and posts questions
+   - User responds to questions and re-applies the label to continue
+   - Automatically removes the label after completion
+
 **Customizable Labels:**
 
 All label names are configurable to match your repository's existing label scheme. Configure via the interactive wizard or manually in `aidp.yml`:
@@ -255,10 +283,16 @@ All label names are configurable to match your repository's existing label schem
 # .aidp/aidp.yml
 watch:
   labels:
-    plan_trigger: aidp-plan        # Label to trigger plan generation
-    needs_input: aidp-needs-input  # Label when plan needs user input
-    ready_to_build: aidp-ready     # Label when plan is ready to build
-    build_trigger: aidp-build      # Label to trigger implementation
+    # Issue-based automation
+    plan_trigger: aidp-plan                    # Trigger plan generation
+    needs_input: aidp-needs-input              # Needs user input/clarification
+    ready_to_build: aidp-ready                 # Plan ready for implementation
+    build_trigger: aidp-build                  # Trigger implementation
+
+    # PR-based automation
+    review_trigger: aidp-review                # Trigger code review
+    ci_fix_trigger: aidp-fix-ci                # Trigger CI auto-fix
+    change_request_trigger: aidp-request-changes  # Trigger PR change implementation
 ```
 
 Run `aidp config --interactive` and enable watch mode to configure labels interactively.
@@ -294,7 +328,12 @@ AIDP can automatically request clarification when it needs more information duri
 
 This ensures AIDP never gets stuck - if it needs more information, it will ask for it rather than making incorrect assumptions or failing silently.
 
-See [Watch Mode Guide](docs/FULLY_AUTOMATIC_MODE.md) and [Watch Mode Safety](docs/WATCH_MODE_SAFETY.md) for complete documentation.
+**Additional Documentation:**
+
+- [Watch Mode Guide](docs/FULLY_AUTOMATIC_MODE.md) - Complete guide to watch mode setup and operation
+- [Watch Mode Safety](docs/WATCH_MODE_SAFETY.md) - Security features and best practices
+- [PR Automation Guide](docs/PR_AUTOMATION.md) - Detailed guide for code review, CI fixes, and PR changes
+- [PR Change Requests](docs/PR_CHANGE_REQUESTS.md) - Comprehensive documentation for automated PR modifications
 
 ## Command Reference
 

data/lib/aidp/analyze/error_handler.rb

@@ -99,6 +99,13 @@ module Aidp
       private
 
       def setup_logger(log_file, verbose)
+        # Suppress logger output in test/CI environments
+        if suppress_error_logs?
+          logger = ::Logger.new(IO::NULL)
+          logger.level = ::Logger::FATAL
+          return logger
+        end
+
         output_stream = log_file || @output || $stdout
         logger = ::Logger.new(output_stream)
         logger.level = verbose ? ::Logger::DEBUG : ::Logger::INFO
@@ -108,6 +115,10 @@ module Aidp
         logger
       end
 
+      def suppress_error_logs?
+        ENV["RSPEC_RUNNING"] || ENV["CI"] || ENV["RAILS_ENV"] == "test" || ENV["RACK_ENV"] == "test"
+      end
+
       def setup_recovery_strategies
         strategies = {
           Errno::ENOENT => :skip_step_with_warning,

data/lib/aidp/execute/work_loop_runner.rb

@@ -59,6 +59,12 @@ module Aidp
         @state_history = []
         @deterministic_runner = DeterministicUnits::Runner.new(project_dir)
         @unit_scheduler = nil
+
+        # Initialize thinking depth manager for intelligent model selection
+        require_relative "../harness/thinking_depth_manager"
+        @thinking_depth_manager = Aidp::Harness::ThinkingDepthManager.new(config)
+        @consecutive_failures = 0
+        @last_tier = nil
       end
 
       # Execute a step using fix-forward work loop pattern
@@ -176,19 +182,45 @@ module Aidp
           process_task_filing(agent_result)
 
           transition_to(:test)
+          # Run all configured checks
           test_results = @test_runner.run_tests
           lint_results = @test_runner.run_linters
+          build_results = @test_runner.run_builds
+          doc_results = @test_runner.run_documentation
+
+          # Run formatters only if agent marked work complete (per issue #234)
+          formatter_results = if agent_marked_complete?(agent_result)
+            @test_runner.run_formatters
+          else
+            {success: true, output: "Formatters: Skipped (work not complete)", failures: [], required_failures: []}
+          end
+
+          all_results = {
+            tests: test_results,
+            lints: lint_results,
+            formatters: formatter_results,
+            builds: build_results,
+            docs: doc_results
+          }
+
+          record_periodic_checkpoint(all_results)
 
-          record_periodic_checkpoint(test_results, lint_results)
+          # Track failures and escalate thinking tier if needed
+          track_failures_and_escalate(all_results)
 
-          tests_pass = test_results[:success] && lint_results[:success]
+          # All required checks must pass for completion
+          all_checks_pass = test_results[:success] &&
+            lint_results[:success] &&
+            formatter_results[:success] &&
+            build_results[:success] &&
+            doc_results[:success]
 
-          if tests_pass
+          if all_checks_pass
             transition_to(:pass)
 
             if agent_marked_complete?(agent_result)
               transition_to(:done)
-              record_final_checkpoint(test_results, lint_results)
+              record_final_checkpoint(all_results)
               display_message("✅ Step #{@step_name} completed after #{@iteration_count} iterations", type: :success)
               display_state_summary
               archive_and_cleanup
@@ -201,18 +233,18 @@ module Aidp
                 terminate: true
               )
             else
-              display_message("  Tests passed but work not marked complete", type: :info)
+              display_message("  All checks passed but work not marked complete", type: :info)
               transition_to(:next_patch)
             end
           else
             transition_to(:fail)
-            display_message("  Tests or linters failed", type: :warning)
+            display_message("  Required checks failed", type: :warning)
 
             transition_to(:diagnose)
-            diagnostic = diagnose_failures(test_results, lint_results)
+            diagnostic = diagnose_failures(all_results)
 
             transition_to(:next_patch)
-            prepare_next_iteration(test_results, lint_results, diagnostic)
+            prepare_next_iteration(all_results, diagnostic)
           end
         end
       end
@@ -222,14 +254,18 @@ module Aidp
 
         prompt = build_decider_prompt(context)
 
+        # Select model based on thinking depth tier
+        provider_name, model_name, _model_data = select_model_for_current_tier
+
         agent_result = @provider_manager.execute_with_provider(
-          @provider_manager.current_provider,
+          provider_name,
           prompt,
           {
             step_name: @step_name,
             iteration: @iteration_count,
             project_dir: @project_dir,
-            mode: :decide_whats_next
+            mode: :decide_whats_next,
+            model: model_name
           }
         )
 
@@ -250,14 +286,18 @@ module Aidp
 
         prompt = build_diagnose_prompt(context)
 
+        # Select model based on thinking depth tier
+        provider_name, model_name, _model_data = select_model_for_current_tier
+
         agent_result = @provider_manager.execute_with_provider(
-          @provider_manager.current_provider,
+          provider_name,
           prompt,
           {
             step_name: @step_name,
             iteration: @iteration_count,
             project_dir: @project_dir,
-            mode: :diagnose_failures
+            mode: :diagnose_failures,
+            model: model_name
           }
         )
 
@@ -421,27 +461,26 @@ module Aidp
         result[:status] == "completed" || prompt_marked_complete?
       end
 
-      # Diagnose test/lint failures
+      # Diagnose all failures (tests, lints, formatters, builds, docs)
       # Returns diagnostic information to help agent understand what went wrong
-      def diagnose_failures(test_results, lint_results)
+      def diagnose_failures(all_results)
         diagnostic = {
           iteration: @iteration_count,
           failures: []
         }
 
-        unless test_results[:success]
-          diagnostic[:failures] << {
-            type: "tests",
-            count: test_results[:failures]&.size || 0,
-            commands: test_results[:failures]&.map { |f| f[:command] } || []
-          }
-        end
+        # Check each result type for failures
+        all_results.each do |category, results|
+          next if results[:success]
+
+          # Only include required failures in diagnostic
+          required_failures = results[:required_failures] || results[:failures] || []
+          next if required_failures.empty?
 
-        unless lint_results[:success]
           diagnostic[:failures] << {
-            type: "linters",
-            count: lint_results[:failures]&.size || 0,
-            commands: lint_results[:failures]&.map { |f| f[:command] } || []
+            type: category.to_s,
+            count: required_failures.size,
+            commands: required_failures.map { |f| f[:command] }
           }
         end
 
@@ -650,17 +689,36 @@ module Aidp
         # Prepend work loop instructions to every iteration
         full_prompt = build_work_loop_header(@step_name, @iteration_count) + "\n\n" + prompt_content
 
+        # Select model based on thinking depth tier
+        provider_name, model_name, _model_data = select_model_for_current_tier
+
+        if provider_name.nil? || model_name.nil?
+          Aidp.logger.error("work_loop", "Failed to select model for tier",
+            tier: @thinking_depth_manager.current_tier,
+            step: @step_name,
+            iteration: @iteration_count)
+          return {status: "error", message: "No model available for tier #{@thinking_depth_manager.current_tier}"}
+        end
+
+        # Log model selection
+        tier = @thinking_depth_manager.current_tier
+        if @last_tier != tier
+          display_message("  💡 Using tier: #{tier} (#{provider_name}/#{model_name})", type: :info)
+          @last_tier = tier
+        end
+
         # CRITICAL: Change to project directory before calling provider
         # This ensures Claude CLI runs in the correct directory and can create files
         Dir.chdir(@project_dir) do
-          # Send to provider via provider_manager
+          # Send to provider via provider_manager with selected model
           @provider_manager.execute_with_provider(
-            @provider_manager.current_provider,
+            provider_name,
             full_prompt,
             {
               step_name: @step_name,
               iteration: @iteration_count,
-              project_dir: @project_dir
+              project_dir: @project_dir,
+              model: model_name
             }
           )
         end
@@ -701,7 +759,7 @@ module Aidp
         prompt_content.match?(/^STATUS:\s*COMPLETE/i)
       end
 
-      def prepare_next_iteration(test_results, lint_results, diagnostic = nil)
+      def prepare_next_iteration(all_results, diagnostic = nil)
         # Only append failures to PROMPT.md for agent to see
         # This follows fix-forward: never rollback, only add information for next patch
         failures = []
@@ -723,25 +781,30 @@ module Aidp
           failures << ""
         end
 
-        unless test_results[:success]
-          failures << "### Test Failures"
-          failures << test_results[:output]
-          failures << ""
-        end
+        # Add failure output for each category that has failures
+        category_labels = {
+          tests: "Test",
+          lints: "Linter",
+          formatters: "Formatter",
+          builds: "Build",
+          docs: "Documentation"
+        }
 
-        unless lint_results[:success]
-          failures << "### Linter Failures"
-          failures << lint_results[:output]
+        all_results.each do |category, results|
+          next if results[:success]
+
+          failures << "### #{category_labels[category]} Failures"
+          failures << results[:output]
           failures << ""
         end
 
-        strategy = build_failure_strategy(test_results, lint_results)
+        strategy = build_failure_strategy(all_results)
         failures.concat(strategy) unless strategy.empty?
 
         failures << "**Fix-forward instructions**: Do not rollback changes. Build on what exists and fix the failures above."
         failures << ""
 
-        return if test_results[:success] && lint_results[:success]
+        return if all_results.values.all? { |result| result[:success] }
 
         # Append failures to PROMPT.md and archive immediately (issue #224)
         current_prompt = @prompt_manager.read
@@ -832,20 +895,27 @@ module Aidp
         reminder.join("\n")
       end
 
-      def build_failure_strategy(test_results, lint_results)
-        return [] if test_results[:success] && lint_results[:success]
+      def build_failure_strategy(all_results)
+        return [] if all_results.values.all? { |result| result[:success] }
 
         lines = ["### Recovery Strategy", ""]
 
-        unless test_results[:success]
-          commands = format_command_list(test_results[:failures])
-          lines << "- Re-run #{commands} locally to reproduce the failing specs listed above."
-          lines << "- Triage the exact failures before moving on to new work."
-        end
+        category_strategies = {
+          tests: "Re-run %s locally to reproduce the failing specs listed above. Triage the exact failures before moving on to new work.",
+          lints: "Execute %s and fix each reported offense.",
+          formatters: "Run %s to fix formatting issues.",
+          builds: "Run %s to diagnose and fix build errors.",
+          docs: "Review and update documentation using %s to meet requirements."
+        }
 
-        unless lint_results[:success]
-          commands = format_command_list(lint_results[:failures])
-          lines << "- Execute #{commands} and fix each reported offense."
+        all_results.each do |category, results|
+          next if results[:success]
+
+          strategy_template = category_strategies[category]
+          next unless strategy_template
+
+          commands = format_command_list(results[:failures])
+          lines << "- #{strategy_template % commands}"
         end
 
         lines << ""
@@ -926,13 +996,16 @@ module Aidp
       end
 
       # Record checkpoint at regular intervals
-      def record_periodic_checkpoint(test_results, lint_results)
+      def record_periodic_checkpoint(all_results)
         # Record every CHECKPOINT_INTERVAL iterations or on iteration 1
         return unless @iteration_count == 1 || (@iteration_count % CHECKPOINT_INTERVAL == 0)
 
         metrics = {
-          tests_passing: test_results[:success],
-          linters_passing: lint_results[:success]
+          tests_passing: all_results[:tests][:success],
+          linters_passing: all_results[:lints][:success],
+          formatters_passing: all_results[:formatters][:success],
+          builds_passing: all_results[:builds][:success],
+          docs_passing: all_results[:docs][:success]
         }
 
         checkpoint_data = @checkpoint.record_checkpoint(@step_name, @iteration_count, metrics)
@@ -947,10 +1020,13 @@ module Aidp
       end
 
       # Record final checkpoint when step completes
-      def record_final_checkpoint(test_results, lint_results)
+      def record_final_checkpoint(all_results)
         metrics = {
-          tests_passing: test_results[:success],
-          linters_passing: lint_results[:success],
+          tests_passing: all_results[:tests][:success],
+          linters_passing: all_results[:lints][:success],
+          formatters_passing: all_results[:formatters][:success],
+          builds_passing: all_results[:builds][:success],
+          docs_passing: all_results[:docs][:success],
           completed: true
         }
 
@@ -1114,6 +1190,100 @@ module Aidp
           display_message("   ✓ Confirmed", type: :success)
         end
       end
+
+      # Select model based on current thinking depth tier
+      # Returns [provider_name, model_name, model_data]
+      def select_model_for_current_tier
+        current_tier = @thinking_depth_manager.current_tier
+        provider_name, model_name, model_data = @thinking_depth_manager.select_model_for_tier(
+          current_tier,
+          provider: @provider_manager.current_provider
+        )
+
+        Aidp.logger.debug("work_loop", "Selected model for tier",
+          tier: current_tier,
+          provider: provider_name,
+          model: model_name,
+          step: @step_name,
+          iteration: @iteration_count)
+
+        [provider_name, model_name, model_data]
+      end
+
+      # Track test/lint/formatter/build/doc failures and escalate tier if needed
+      def track_failures_and_escalate(all_results)
+        all_pass = all_results.values.all? { |result| result[:success] }
+
+        if all_pass
+          # Reset failure count on success
+          @consecutive_failures = 0
+        else
+          # Increment failure count
+          @consecutive_failures += 1
+
+          # Check if we should escalate based on consecutive failures
+          if @thinking_depth_manager.should_escalate_on_failures?(@consecutive_failures)
+            escalate_thinking_tier("consecutive_failures")
+          end
+        end
+
+        # Check complexity-based escalation
+        changed_files = get_changed_files
+        if @thinking_depth_manager.should_escalate_on_complexity?(
+          files_changed: changed_files.size,
+          modules_touched: estimate_modules_touched(changed_files)
+        )
+          escalate_thinking_tier("complexity_threshold")
+        end
+      end
+
+      # Escalate to next thinking tier
+      def escalate_thinking_tier(reason)
+        old_tier = @thinking_depth_manager.current_tier
+        new_tier = @thinking_depth_manager.escalate_tier(reason: reason)
+
+        if new_tier
+          display_message("  ⬆️  Escalated thinking tier: #{old_tier} → #{new_tier} (#{reason})", type: :warning)
+          Aidp.logger.info("work_loop", "Escalated thinking tier",
+            from: old_tier,
+            to: new_tier,
+            reason: reason,
+            step: @step_name,
+            iteration: @iteration_count,
+            consecutive_failures: @consecutive_failures)
+
+          # Reset last tier to trigger display of new tier
+          @last_tier = nil
+        else
+          Aidp.logger.debug("work_loop", "Cannot escalate tier further",
+            current: old_tier,
+            max: @thinking_depth_manager.max_tier,
+            reason: reason)
+        end
+      end
+
+      # Estimate number of modules touched based on file paths
+      def estimate_modules_touched(files)
+        # Group files by their top-level directory or module
+        modules = files.map do |file|
+          parts = file.split("/")
+          # Consider top 2 levels as module identifier
+          parts.take(2).join("/")
+        end.uniq
+
+        modules.size
+      end
+
+      # Get thinking depth status for display
+      def thinking_depth_status
+        {
+          current_tier: @thinking_depth_manager.current_tier,
+          max_tier: @thinking_depth_manager.max_tier,
+          can_escalate: @thinking_depth_manager.can_escalate?,
+          consecutive_failures: @consecutive_failures,
+          escalation_count: @thinking_depth_manager.escalation_count
+        }
+      end
     end
   end
 end

data/lib/aidp/harness/config_loader.rb

@@ -316,17 +316,19 @@ module Aidp
       def handle_validation_errors(errors)
         error_message = "Configuration validation failed:\n" + errors.join("\n")
 
-        # Log error
-        if defined?(Rails) && Rails.logger
-          Rails.logger.error(error_message)
-        else
-          warn(error_message)
+        # Log error (suppress in test/CI environments)
+        unless suppress_config_warnings?
+          if defined?(Rails) && Rails.logger
+            Rails.logger.error(error_message)
+          else
+            warn(error_message)
+          end
         end
 
         # In development, try to fix common issues
         if ENV["AIDP_ENV"] == "development" || ENV["RACK_ENV"] == "development"
           if @validator.fix_common_issues
-            warn("Attempted to fix configuration issues. Please review the updated configuration file.")
+            warn("Attempted to fix configuration issues. Please review the updated configuration file.") unless suppress_config_warnings?
           end
         end
       end
@@ -334,11 +336,13 @@ module Aidp
       def log_warnings(warnings)
         warning_message = "Configuration warnings:\n" + warnings.join("\n")
 
-        # Log warnings
-        if defined?(Rails) && Rails.logger
-          Rails.logger.warn(warning_message)
-        else
-          warn(warning_message)
+        # Log warnings (suppress in test/CI environments)
+        unless suppress_config_warnings?
+          if defined?(Rails) && Rails.logger
+            Rails.logger.warn(warning_message)
+          else
+            warn(warning_message)
+          end
         end
       end
 
@@ -390,6 +394,11 @@ module Aidp
           false
         end
       end
+
+      # Suppress configuration warnings in test/CI environments
+      def suppress_config_warnings?
+        ENV["RSPEC_RUNNING"] || ENV["CI"] || ENV["RAILS_ENV"] == "test" || ENV["RACK_ENV"] == "test"
+      end
     end
   end
 end

data/lib/aidp/harness/config_schema.rb

@@ -375,6 +375,9 @@ module Aidp
                 max_iterations: 50,
                 test_commands: [],
                 lint_commands: [],
+                formatter_commands: [],
+                build_commands: [],
+                documentation_commands: [],
                 units: {},
                 guards: {enabled: false},
                 version_control: {tool: "git", behavior: "nothing", conventional_commits: false},
@@ -397,18 +400,37 @@ module Aidp
                 test_commands: {
                   type: :array,
                   required: false,
-                  default: [],
-                  items: {
-                    type: :string
-                  }
+                  default: []
+                  # Items can be strings or {command: string, required: boolean}
+                  # Validation handled in Configuration class for flexibility
                 },
                 lint_commands: {
                   type: :array,
                   required: false,
-                  default: [],
-                  items: {
-                    type: :string
-                  }
+                  default: []
+                  # Items can be strings or {command: string, required: boolean}
+                  # Validation handled in Configuration class for flexibility
+                },
+                formatter_commands: {
+                  type: :array,
+                  required: false,
+                  default: []
+                  # Items can be strings or {command: string, required: boolean}
+                  # Validation handled in Configuration class for flexibility
+                },
+                build_commands: {
+                  type: :array,
+                  required: false,
+                  default: []
+                  # Items can be strings or {command: string, required: boolean}
+                  # Validation handled in Configuration class for flexibility
+                },
+                documentation_commands: {
+                  type: :array,
+                  required: false,
+                  default: []
+                  # Items can be strings or {command: string, required: boolean}
+                  # Validation handled in Configuration class for flexibility
                 },
                 units: {
                   type: :hash,