aidp 0.25.0 → 0.27.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 348238e998f8d75ef9f23fcb5a8f4517b6fde0dd9612a4520583b03ab692cc23
-  data.tar.gz: ed8db8dbd0459211e65b76784b6074b65f2689cdb76f7b7c74bcb029d4c9f74d
+  metadata.gz: 174c58fcccbc5d5c927cb30dd3bf8c735de926cf52de5eb2a4bb56f2bc984cc3
+  data.tar.gz: 73efb11b31d3ff346a482fde9616047fd64525e44ffe768a81a6e4808e748cd1
 SHA512:
-  metadata.gz: ac5628709db6248036d75e5873252089e497b96bac785a610bcc9b153b350714d4a5e441610501b3897cf6994d9081fa36e990da67678b86c167d5e58b048f64
-  data.tar.gz: dd660df245ffd1bb28048e4b76b231efce515e880fc8cfa088af6a25b1fcb42b98562d592880d256ade4474a3db6879567f3fb2670e750da0ee94ea5347b2df7
+  metadata.gz: 407aecc4942fbda7fbf09e15ebfdfa6ba8595be9f282a0b425ce65dc22e45d3a524fe5dd211ce96ec59029801df01528a835412ba38f90cb273c5b1594df2016
+  data.tar.gz: 174a42200bb01198f3c88de3ec35198c9475f018f06a673e7d1d3c0e0dda9c294dd832519327261ac767a42323e965f1fa7ea1fa1d3b394425604ceaaa7bf371

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/cli/checkpoint_command.rb

@@ -0,0 +1,198 @@
+# frozen_string_literal: true
+
+require "tty-prompt"
+require_relative "../execute/checkpoint"
+require_relative "../execute/checkpoint_display"
+
+module Aidp
+  class CLI
+    # Command handler for `aidp checkpoint` subcommand
+    #
+    # Provides commands for managing workflow checkpoints:
+    #   - show: Display latest checkpoint data
+    #   - summary: Show progress summary with trends
+    #   - history: Show last N checkpoints
+    #   - metrics: Show detailed metrics
+    #   - clear: Clear all checkpoint data
+    #
+    # Usage:
+    #   aidp checkpoint show
+    #   aidp checkpoint summary --watch
+    #   aidp checkpoint history 10
+    #   aidp checkpoint metrics
+    #   aidp checkpoint clear --force
+    class CheckpointCommand
+      include Aidp::MessageDisplay
+
+      def initialize(prompt: TTY::Prompt.new, checkpoint_class: nil, display_class: nil, project_dir: nil)
+        @prompt = prompt
+        @checkpoint_class = checkpoint_class || Aidp::Execute::Checkpoint
+        @display_class = display_class || Aidp::Execute::CheckpointDisplay
+        @project_dir = project_dir || Dir.pwd
+      end
+
+      # Main entry point for checkpoint subcommands
+      def run(args)
+        sub = args.shift || "summary"
+        checkpoint = @checkpoint_class.new(@project_dir)
+        display = @display_class.new
+
+        case sub
+        when "show"
+          run_show_command(checkpoint, display)
+        when "summary"
+          run_summary_command(checkpoint, display, args)
+        when "history"
+          run_history_command(checkpoint, display, args)
+        when "metrics"
+          run_metrics_command(checkpoint)
+        when "clear"
+          run_clear_command(checkpoint, args)
+        else
+          display_usage
+        end
+      end
+
+      private
+
+      def run_show_command(checkpoint, display)
+        latest = checkpoint.latest_checkpoint
+        if latest
+          display.display_checkpoint(latest, show_details: true)
+        else
+          display_message("No checkpoint data found.", type: :info)
+        end
+      end
+
+      def run_summary_command(checkpoint, display, args)
+        watch = args.include?("--watch")
+        interval = extract_interval_option(args) || 5
+
+        if watch
+          watch_checkpoint_summary(checkpoint, display, interval)
+        else
+          summary = checkpoint.progress_summary
+          if summary
+            display.display_progress_summary(summary)
+          else
+            display_message("No checkpoint data found.", type: :info)
+          end
+        end
+      end
+
+      def run_history_command(checkpoint, display, args)
+        limit = args.shift || "10"
+        history = checkpoint.checkpoint_history(limit: limit.to_i)
+        if history.any?
+          display.display_checkpoint_history(history, limit: limit.to_i)
+        else
+          display_message("No checkpoint history found.", type: :info)
+        end
+      end
+
+      def run_metrics_command(checkpoint)
+        latest = checkpoint.latest_checkpoint
+        unless latest
+          display_message("No checkpoint data found.", type: :info)
+          return
+        end
+
+        display_message("", type: :info)
+        display_message("📊 Detailed Metrics", type: :info)
+        display_message("=" * 60, type: :muted)
+
+        metrics = latest[:metrics]
+        display_message("Lines of Code: #{metrics[:lines_of_code]}", type: :info)
+        display_message("File Count: #{metrics[:file_count]}", type: :info)
+        display_message("Test Coverage: #{metrics[:test_coverage]}%", type: :info)
+        display_message("Code Quality: #{metrics[:code_quality]}%", type: :info)
+        display_message("PRD Task Progress: #{metrics[:prd_task_progress]}%", type: :info)
+
+        if metrics.key?(:tests_passing)
+          status = metrics[:tests_passing] ? "✓ Passing" : "✗ Failing"
+          display_message("Tests: #{status}", type: :info)
+        end
+
+        if metrics.key?(:linters_passing)
+          status = metrics[:linters_passing] ? "✓ Passing" : "✗ Failing"
+          display_message("Linters: #{status}", type: :info)
+        end
+
+        display_message("=" * 60, type: :muted)
+        display_message("", type: :info)
+      end
+
+      def run_clear_command(checkpoint, args)
+        force = args.include?("--force")
+        unless force
+          confirm = @prompt.yes?("Are you sure you want to clear all checkpoint data?")
+          return unless confirm
+        end
+
+        checkpoint.clear
+        display_message("✓ Checkpoint data cleared.", type: :success)
+      end
+
+      def watch_checkpoint_summary(checkpoint, display, interval)
+        display_message("Watching checkpoint summary (refresh: #{interval}s, Ctrl+C to exit)...", type: :info)
+        display_message("", type: :info)
+
+        begin
+          loop do
+            # Clear screen
+            print "\e[2J\e[H"
+
+            summary = checkpoint.progress_summary
+            if summary
+              display.display_progress_summary(summary)
+
+              # Show last update time
+              if summary[:current] && summary[:current][:timestamp]
+                last_update = Time.parse(summary[:current][:timestamp])
+                age = Time.now - last_update
+                display_message("", type: :info)
+                display_message("Last update: #{format_time_ago_simple(age)} | Refreshing in #{interval}s...", type: :muted)
+              end
+            else
+              display_message("No checkpoint data found. Waiting for data...", type: :info)
+            end
+
+            sleep interval
+          end
+        rescue Interrupt
+          display_message("\nStopped watching checkpoint summary", type: :info)
+        end
+      end
+
+      def format_time_ago_simple(seconds)
+        if seconds < 60
+          "#{seconds.to_i}s ago"
+        elsif seconds < 3600
+          "#{(seconds / 60).to_i}m ago"
+        else
+          "#{(seconds / 3600).to_i}h ago"
+        end
+      end
+
+      def extract_interval_option(args)
+        args.each_with_index do |arg, i|
+          if arg == "--interval" && args[i + 1]
+            return args[i + 1].to_i
+          elsif arg.start_with?("--interval=")
+            return arg.split("=")[1].to_i
+          end
+        end
+        nil
+      end
+
+      def display_usage
+        display_message("Usage: aidp checkpoint <show|summary|history|metrics|clear>", type: :info)
+        display_message("  show              - Show the latest checkpoint data", type: :info)
+        display_message("  summary [--watch] - Show progress summary with trends", type: :info)
+        display_message("  history [N]       - Show last N checkpoints", type: :info)
+        display_message("  metrics           - Show detailed metrics", type: :info)
+        display_message("  clear [--force]   - Clear all checkpoint data", type: :info)
+      end
+    end
+  end
+end

data/lib/aidp/cli/config_command.rb

@@ -0,0 +1,71 @@
+# frozen_string_literal: true
+
+require "tty-prompt"
+require_relative "../setup/wizard"
+
+module Aidp
+  class CLI
+    # Command handler for `aidp config` subcommand
+    #
+    # Provides commands for managing AIDP configuration:
+    #   - Interactive configuration wizard
+    #   - Dry-run mode for testing configuration changes
+    #
+    # Usage:
+    #   aidp config --interactive
+    #   aidp config --interactive --dry-run
+    class ConfigCommand
+      include Aidp::MessageDisplay
+
+      def initialize(prompt: TTY::Prompt.new, wizard_class: nil, project_dir: nil)
+        @prompt = prompt
+        @wizard_class = wizard_class || Aidp::Setup::Wizard
+        @project_dir = project_dir || Dir.pwd
+      end
+
+      # Main entry point for config command
+      def run(args)
+        interactive = false
+        dry_run = false
+
+        until args.empty?
+          token = args.shift
+          case token
+          when "--interactive"
+            interactive = true
+          when "--dry-run"
+            dry_run = true
+          when "-h", "--help"
+            display_usage
+            return
+          else
+            display_message("Unknown option: #{token}", type: :error)
+            display_usage
+            return
+          end
+        end
+
+        unless interactive
+          display_usage
+          return
+        end
+
+        wizard = @wizard_class.new(@project_dir, prompt: @prompt, dry_run: dry_run)
+        wizard.run
+      end
+
+      private
+
+      def display_usage
+        display_message("\nUsage: aidp config --interactive [--dry-run]", type: :info)
+        display_message("\nOptions:", type: :info)
+        display_message("  --interactive    Run interactive configuration wizard", type: :info)
+        display_message("  --dry-run        Perform a dry run without making changes", type: :info)
+        display_message("  -h, --help       Show this help message", type: :info)
+        display_message("\nExamples:", type: :info)
+        display_message("  aidp config --interactive", type: :info)
+        display_message("  aidp config --interactive --dry-run", type: :info)
+      end
+    end
+  end
+end

data/lib/aidp/cli/enhanced_input.rb

@@ -21,6 +21,8 @@ module Aidp
       # - Ctrl-T: Transpose characters
       # - And many more Emacs-style bindings
 
+      attr_reader :use_reline, :show_hints
+
       def initialize(prompt: nil, input: nil, output: nil, use_reline: true)
         @use_reline = use_reline
         @input = input || $stdin

data/lib/aidp/cli/first_run_wizard.rb

@@ -10,10 +10,10 @@ module Aidp
     class FirstRunWizard
       include Aidp::MessageDisplay
 
-      def self.ensure_config(project_dir, non_interactive: false, prompt: TTY::Prompt.new)
+      def self.ensure_config(project_dir, non_interactive: false, prompt: TTY::Prompt.new, wizard_class: Aidp::Setup::Wizard)
         return true if Aidp::Config.config_exists?(project_dir)
 
-        wizard = new(project_dir, prompt: prompt)
+        wizard = new(project_dir, prompt: prompt, wizard_class: wizard_class)
 
         if non_interactive
           wizard.create_minimal_config
@@ -24,22 +24,23 @@ module Aidp
         end
       end
 
-      def self.setup_config(project_dir, non_interactive: false, prompt: TTY::Prompt.new)
+      def self.setup_config(project_dir, non_interactive: false, prompt: TTY::Prompt.new, wizard_class: Aidp::Setup::Wizard)
         if non_interactive
-          new(project_dir, prompt: prompt).send(:display_message, "Configuration setup skipped in non-interactive environment", type: :info)
+          new(project_dir, prompt: prompt, wizard_class: wizard_class).send(:display_message, "Configuration setup skipped in non-interactive environment", type: :info)
           return true
         end
 
-        new(project_dir, prompt: prompt).run
+        new(project_dir, prompt: prompt, wizard_class: wizard_class).run
       end
 
-      def initialize(project_dir, prompt: TTY::Prompt.new)
+      def initialize(project_dir, prompt: TTY::Prompt.new, wizard_class: Aidp::Setup::Wizard)
         @project_dir = project_dir
         @prompt = prompt
+        @wizard_class = wizard_class
       end
 
       def run
-        wizard = Aidp::Setup::Wizard.new(@project_dir, prompt: @prompt)
+        wizard = @wizard_class.new(@project_dir, prompt: @prompt)
         wizard.run
       end
 

data/lib/aidp/cli/harness_command.rb

@@ -0,0 +1,102 @@
+# frozen_string_literal: true
+
+require "tty-prompt"
+require_relative "../harness/runner"
+
+module Aidp
+  class CLI
+    # Command handler for `aidp harness status` and `aidp harness reset` subcommands
+    #
+    # Provides commands for viewing and managing harness state:
+    #   - status: Show detailed harness status for all modes
+    #   - reset: Reset harness state for a specific mode
+    #
+    # Usage:
+    #   aidp harness status
+    #   aidp harness reset --mode analyze
+    class HarnessCommand
+      include Aidp::MessageDisplay
+      include Aidp::RescueLogging
+
+      def initialize(prompt: TTY::Prompt.new, runner_class: nil, project_dir: nil)
+        @prompt = prompt
+        @runner_class = runner_class || Aidp::Harness::Runner
+        @project_dir = project_dir || Dir.pwd
+      end
+
+      # Main entry point for harness status/reset subcommands
+      def run(args, subcommand:, options: {})
+        case subcommand
+        when "status"
+          run_status_command
+        when "reset"
+          run_reset_command(options)
+        else
+          display_message("Unknown harness subcommand: #{subcommand}", type: :error)
+          display_help
+          1
+        end
+      end
+
+      private
+
+      def run_status_command
+        modes = %i[analyze execute]
+        display_message("🔧 Harness Status", type: :highlight)
+        modes.each do |mode|
+          status = fetch_harness_status(mode)
+          print_harness_mode_status(mode, status)
+        end
+      end
+
+      def run_reset_command(options)
+        mode = (options[:mode] || "analyze").to_s
+        unless %w[analyze execute].include?(mode)
+          display_message("❌ Invalid mode. Use 'analyze' or 'execute'", type: :error)
+          return
+        end
+
+        # Build a runner to access state manager
+        runner = @runner_class.new(@project_dir, mode.to_sym, {})
+        state_manager = runner.instance_variable_get(:@state_manager)
+        state_manager.reset_all if state_manager.respond_to?(:reset_all)
+        display_message("✅ Reset harness state for #{mode} mode", type: :success)
+      end
+
+      def fetch_harness_status(mode)
+        runner = @runner_class.new(@project_dir, mode, {})
+        if runner.respond_to?(:detailed_status)
+          runner.detailed_status
+        else
+          {harness: {state: "unknown"}}
+        end
+      rescue => e
+        log_rescue(e, component: "harness_command", action: "fetch_harness_status", fallback: {harness: {state: "error"}}, mode: mode)
+        {harness: {state: "error", error: e.message}}
+      end
+
+      def print_harness_mode_status(mode, status)
+        harness = status[:harness] || {}
+        display_message("\n📋 #{mode.to_s.capitalize} Mode:", type: :info)
+        display_message("   State: #{harness[:state]}", type: :info)
+        if harness[:progress]
+          prog = harness[:progress]
+          display_message("   Progress: #{prog[:completed_steps]}/#{prog[:total_steps]}", type: :success)
+          display_message("   Current Step: #{harness[:current_step]}", type: :info) if harness[:current_step]
+        end
+      end
+
+      def display_help
+        display_message("\nUsage: aidp harness <subcommand> [options]", type: :info)
+        display_message("\nSubcommands:", type: :info)
+        display_message("  status           Show harness status for all modes", type: :info)
+        display_message("  reset            Reset harness state for a mode", type: :info)
+        display_message("\nOptions:", type: :info)
+        display_message("  --mode MODE      Specify mode for reset (analyze|execute)", type: :info)
+        display_message("\nExamples:", type: :info)
+        display_message("  aidp harness status", type: :info)
+        display_message("  aidp harness reset --mode analyze", type: :info)
+      end
+    end
+  end
+end

data/lib/aidp/cli/jobs_command.rb

@@ -14,7 +14,7 @@ module Aidp
     class JobsCommand
       include Aidp::MessageDisplay
 
-      def initialize(input: nil, output: nil, prompt: TTY::Prompt.new)
+      def initialize(input: nil, output: nil, prompt: TTY::Prompt.new, file_manager: nil, background_runner: nil)
         @io = TerminalIO.new(input: input, output: output)
         @prompt = prompt
         @pastel = Pastel.new
@@ -22,8 +22,8 @@ module Aidp
         @view_mode = :list
         @selected_job_id = nil
         @jobs_displayed = false # Track if we've displayed jobs in interactive mode
-        @file_manager = Aidp::Storage::FileManager.new(File.join(Dir.pwd, ".aidp"))
-        @background_runner = Aidp::Jobs::BackgroundRunner.new(Dir.pwd)
+        @file_manager = file_manager || Aidp::Storage::FileManager.new(File.join(Dir.pwd, ".aidp"))
+        @background_runner = background_runner || Aidp::Jobs::BackgroundRunner.new(Dir.pwd)
         @screen_width = 80 # Default screen width
       end
 

data/lib/aidp/cli/mcp_dashboard.rb

@@ -10,9 +10,10 @@ module Aidp
     class McpDashboard
       include Aidp::MessageDisplay
 
-      def initialize(root_dir = nil)
+      def initialize(root_dir = nil, configuration: nil, provider_info_class: Aidp::Harness::ProviderInfo)
         @root_dir = root_dir || Dir.pwd
-        @configuration = Aidp::Harness::Configuration.new(@root_dir)
+        @configuration = configuration || Aidp::Harness::Configuration.new(@root_dir)
+        @provider_info_class = provider_info_class
       end
 
       # Display MCP dashboard showing all servers across all providers
@@ -101,7 +102,7 @@ module Aidp
         provider_servers = {} # provider_name => [server_info]
 
         providers.each do |provider|
-          provider_info = Aidp::Harness::ProviderInfo.new(provider, @root_dir)
+          provider_info = @provider_info_class.new(provider, @root_dir)
           info = provider_info.info
 
           next unless info[:mcp_support]