aidp 0.9.6 → 0.11.0

data/lib/aidp/execute/workflow_selector.rb

@@ -1,32 +1,56 @@
 # frozen_string_literal: true
 
 require "tty-prompt"
+require_relative "../workflows/definitions"
+require_relative "../workflows/selector"
 
 module Aidp
   module Execute
     # Handles interactive workflow selection and project setup
     class WorkflowSelector
+      include Aidp::MessageDisplay
+
       def initialize(prompt: TTY::Prompt.new)
         @user_input = {}
         @prompt = prompt
+        @workflow_selector = Aidp::Workflows::Selector.new(prompt: @prompt)
       end
 
       # Main entry point for interactive workflow selection
-      def select_workflow(harness_mode: false)
+      def select_workflow(harness_mode: false, use_new_selector: true, mode: nil)
         if harness_mode
           # In harness mode, use default values to avoid blocking
           select_workflow_with_defaults
+        elsif use_new_selector
+          # Use new unified workflow selector (default as of Issue #79)
+          select_workflow_with_new_selector(mode)
         else
-          # Interactive mode for standalone usage
+          # Legacy interactive mode for backward compatibility
           select_workflow_interactive
         end
       end
 
       private
 
+      def select_workflow_with_new_selector(mode = nil)
+        # Step 1: Collect project information (still useful for all workflows)
+        collect_project_info
+
+        # Step 2: Use new workflow selector, defaulting to execute mode if not specified
+        workflow_mode = mode || :execute
+        result = @workflow_selector.select_workflow(workflow_mode)
+
+        {
+          workflow_type: result[:workflow_key],
+          steps: result[:steps],
+          user_input: @user_input,
+          workflow: result[:workflow]
+        }
+      end
+
       def select_workflow_interactive
-        puts "\n🚀 Welcome to AI Dev Pipeline!"
-        puts "Let's set up your development workflow.\n\n"
+        display_message("\n🚀 Welcome to AI Dev Pipeline!", type: :highlight)
+        display_message("Let's set up your development workflow.\n\n")
 
         # Step 1: Collect project information
         collect_project_info
@@ -45,7 +69,7 @@ module Aidp
       end
 
       def select_workflow_with_defaults
-        puts "\n🚀 Starting harness with default workflow configuration..."
+        display_message("\n🚀 Starting harness with default workflow configuration...", type: :highlight)
 
         # Use default project information
         @user_input = {
@@ -71,7 +95,7 @@ module Aidp
       private
 
       def collect_project_info
-        puts "📋 First, tell us about your project:\n"
+        display_message("📋 First, tell us about your project:\n", type: :highlight)
 
         @user_input[:project_description] = prompt_required(
           "What do you want to build? (Be specific about features and goals)"
@@ -91,17 +115,17 @@ module Aidp
       end
 
       def choose_workflow_type
-        puts "\n🎯 Choose your development approach:\n"
-        puts "1. 🔬 Exploration/Experiment - Quick prototype or proof of concept"
-        puts "   • Fast iteration, minimal documentation"
-        puts "   • Focus on core functionality and validation"
-        puts "   • Steps: PRD → Tasks → Implementation"
-        puts ""
-        puts "2. 🏗️  Full Development - Production-ready feature or system"
-        puts "   • Comprehensive planning and documentation"
-        puts "   • You can customize which steps to include"
-        puts "   • Full enterprise workflow available"
-        puts ""
+        display_message("\n🎯 Choose your development approach:\n", type: :highlight)
+        display_message("1. 🔬 Exploration/Experiment - Quick prototype or proof of concept")
+        display_message("   • Fast iteration, minimal documentation", type: :muted)
+        display_message("   • Focus on core functionality and validation", type: :muted)
+        display_message("   • Steps: PRD → Tasks → Implementation", type: :muted)
+        display_message("")
+        display_message("2. 🏗️  Full Development - Production-ready feature or system")
+        display_message("   • Comprehensive planning and documentation", type: :muted)
+        display_message("   • You can customize which steps to include", type: :muted)
+        display_message("   • Full enterprise workflow available", type: :muted)
+        display_message("")
 
         choice = prompt_choice("Which approach fits your project?", ["1", "2", "exploration", "full"])
 
@@ -111,7 +135,7 @@ module Aidp
         when "2", "full"
           :full
         else
-          puts "Invalid choice. Defaulting to exploration workflow."
+          display_message("Invalid choice. Defaulting to exploration workflow.", type: :warning)
           :exploration
         end
       end
@@ -129,16 +153,16 @@ module Aidp
 
       def exploration_workflow_steps
         [
-          "00_PRD",           # Generate PRD from user input (no manual gate)
+          "00_PRD", # Generate PRD from user input (no manual gate)
           "10_TESTING_STRATEGY", # Ensure we have tests
-          "11_STATIC_ANALYSIS",  # Code quality
-          "16_IMPLEMENTATION"    # Special step for actual development work
+          "11_STATIC_ANALYSIS", # Code quality
+          "16_IMPLEMENTATION" # Special step for actual development work
         ]
       end
 
       def full_workflow_steps
-        puts "\n🛠️ Customize your full development workflow:\n"
-        puts "Select the steps you want to include (enter numbers separated by commas):\n"
+        display_message("\n🛠️ Customize your full development workflow:\n", type: :highlight)
+        display_message("Select the steps you want to include (enter numbers separated by commas):\n")
 
         available_steps = {
           "1" => "00_PRD - Product Requirements Document",
@@ -155,8 +179,8 @@ module Aidp
           "12" => "13_DELIVERY_ROLLOUT - Deployment Planning"
         }
 
-        available_steps.each { |num, desc| puts "  #{num}. #{desc}" }
-        puts ""
+        available_steps.each { |num, desc| display_message("  #{num}. #{desc}") }
+        display_message("")
 
         selected = prompt_required("Enter step numbers (e.g., 1,3,5,9,10): ")
         selected_numbers = selected.split(",").map(&:strip).map(&:to_i)
@@ -193,7 +217,7 @@ module Aidp
           input = @prompt.ask("#{question}:")
 
           if input.nil? || input.strip.empty?
-            puts "❌ This field is required. Please provide an answer."
+            display_message("❌ This field is required. Please provide an answer.", type: :error)
             next
           end
 

data/lib/aidp/harness/condition_detector.rb

@@ -1310,13 +1310,13 @@ module Aidp
       # Get timeout duration for operation type
       def get_timeout_duration(operation_type, configuration = nil)
         default_timeouts = {
-          analyze: 300,      # 5 minutes
-          execute: 600,      # 10 minutes
+          analyze: 300, # 5 minutes
+          execute: 600, # 10 minutes
           provider_call: 120, # 2 minutes
           file_operation: 30, # 30 seconds
           network_request: 60, # 1 minute
-          user_input: 300,   # 5 minutes
-          default: 120       # 2 minutes
+          user_input: 300, # 5 minutes
+          default: 120 # 2 minutes
         }
 
         # Get timeout from configuration if available

data/lib/aidp/harness/config_schema.rb

@@ -366,6 +366,46 @@ module Aidp
                   enum: ["provider_model", "provider", "model", "none"]
                 }
               }
+            },
+            work_loop: {
+              type: :hash,
+              required: false,
+              default: {
+                enabled: true,
+                max_iterations: 50,
+                test_commands: [],
+                lint_commands: []
+              },
+              properties: {
+                enabled: {
+                  type: :boolean,
+                  required: false,
+                  default: true
+                },
+                max_iterations: {
+                  type: :integer,
+                  required: false,
+                  default: 50,
+                  min: 1,
+                  max: 200
+                },
+                test_commands: {
+                  type: :array,
+                  required: false,
+                  default: [],
+                  items: {
+                    type: :string
+                  }
+                },
+                lint_commands: {
+                  type: :array,
+                  required: false,
+                  default: [],
+                  items: {
+                    type: :string
+                  }
+                }
+              }
             }
           }
         },

data/lib/aidp/harness/config_validator.rb

@@ -76,8 +76,9 @@ module Aidp
         return false if config_exists?
 
         example_config = ConfigSchema.generate_example
-        config_path = File.join(@project_dir, "aidp.yml")
+        config_path = File.join(@project_dir, ".aidp", "aidp.yml")
 
+        FileUtils.mkdir_p(File.dirname(config_path))
         File.write(config_path, YAML.dump(example_config))
         true
       end
@@ -243,14 +244,10 @@ module Aidp
       private
 
       def find_config_file
-        # Try new aidp.yml format first, then fall back to .aidp.yml
-        config_file = File.join(@project_dir, "aidp.yml")
-        legacy_config_file = File.join(@project_dir, ".aidp.yml")
+        config_file = File.join(@project_dir, ".aidp", "aidp.yml")
 
         if File.exist?(config_file)
           config_file
-        elsif File.exist?(legacy_config_file)
-          legacy_config_file
         end
       end
 

data/lib/aidp/harness/configuration.rb

@@ -144,6 +144,31 @@ module Aidp
         harness_config[:session] || get_default_session_config
       end
 
+      # Get work loop configuration
+      def work_loop_config
+        harness_config[:work_loop] || get_default_work_loop_config
+      end
+
+      # Check if work loops are enabled
+      def work_loop_enabled?
+        work_loop_config[:enabled]
+      end
+
+      # Get maximum iterations for work loops
+      def work_loop_max_iterations
+        work_loop_config[:max_iterations]
+      end
+
+      # Get test commands
+      def test_commands
+        work_loop_config[:test_commands] || []
+      end
+
+      # Get lint commands
+      def lint_commands
+        work_loop_config[:lint_commands] || []
+      end
+
       # Get provider priority
       def provider_priority(provider_name)
         provider_config(provider_name)[:priority] || 0
@@ -186,7 +211,7 @@ module Aidp
 
       # Get configuration path
       def config_path
-        File.join(@project_dir, "aidp.yml")
+        File.join(@project_dir, ".aidp", "aidp.yml")
       end
 
       # Get logging configuration
@@ -416,6 +441,15 @@ module Aidp
         }
       end
 
+      def get_default_work_loop_config
+        {
+          enabled: true,
+          max_iterations: 50,
+          test_commands: [],
+          lint_commands: []
+        }
+      end
+
       def get_default_logging_config
         {
           log_level: :info,

data/lib/aidp/harness/enhanced_runner.rb

@@ -31,7 +31,7 @@ module Aidp
         @current_step = nil
         @current_provider = nil
         @user_input = options[:user_input] || {}
-        @user_input = {} if @user_input.nil?  # Ensure it's never nil
+        @user_input = {} if @user_input.nil? # Ensure it's never nil
         @execution_log = []
 
         # Store workflow configuration
@@ -50,11 +50,32 @@ module Aidp
         @configuration = Configuration.new(project_dir)
         @state_manager = StateManager.new(project_dir, @mode)
         @condition_detector = ConditionDetector.new
-        @provider_manager = ProviderManager.new(@configuration)
+        @provider_manager = ProviderManager.new(@configuration, prompt: TTY::Prompt.new)
         @error_handler = ErrorHandler.new(@provider_manager, @configuration)
         @completion_checker = CompletionChecker.new(@project_dir, @workflow_type)
       end
 
+      # Get current provider (delegate to provider manager)
+      def current_provider
+        @current_provider || @provider_manager&.current_provider || "unknown"
+      end
+
+      # Get current step
+      attr_reader :current_step
+
+      # Get user input
+      def user_input
+        @user_input || {}
+      end
+
+      # Get execution log
+      def execution_log
+        @execution_log || []
+      end
+
+      # Get provider manager
+      attr_reader :provider_manager
+
       # Main execution method with enhanced TUI
       def run
         @state = STATES[:running]
@@ -312,9 +333,9 @@ module Aidp
       def get_mode_runner
         case @mode
         when :analyze
-          Aidp::Analyze::Runner.new(@project_dir, self)
+          Aidp::Analyze::Runner.new(@project_dir, self, prompt: TTY::Prompt.new)
         when :execute
-          Aidp::Execute::Runner.new(@project_dir, self)
+          Aidp::Execute::Runner.new(@project_dir, self, prompt: TTY::Prompt.new)
         else
           raise ArgumentError, "Unsupported mode: #{@mode}"
         end

data/lib/aidp/harness/error_handler.rb

@@ -69,6 +69,17 @@ module Aidp
             error_type: error_info[:error_type],
             reason: "Retry not applicable or exhausted"
           })
+          if [:authentication, :permission_denied].include?(error_info[:error_type].to_sym)
+            # Mark provider unhealthy to avoid immediate re-selection
+            begin
+              if @provider_manager.respond_to?(:mark_provider_auth_failure)
+                @provider_manager.mark_provider_auth_failure(error_info[:provider])
+                debug_log("🔐 Marked provider #{error_info[:provider]} unhealthy due to auth error", level: :warn)
+              end
+            rescue => e
+              debug_log("⚠️ Failed to mark provider unhealthy after auth error", level: :warn, data: {error: e.message})
+            end
+          end
           attempt_recovery(error_info, context)
 
         end
@@ -76,35 +87,75 @@ module Aidp
 
       # Execute a block with retry logic
       def execute_with_retry(&block)
-        max_attempts = @configuration.max_retries + 1
-        attempt = 0
-
-        begin
-          attempt += 1
-          yield
-        rescue => error
-          if attempt < max_attempts
-            error_info = {
-              error: error,
-              provider: @provider_manager.current_provider,
-              model: @provider_manager.current_model,
-              error_type: @error_classifier.classify_error(error)
-            }
+        providers_tried = []
+
+        loop do
+          max_attempts = @configuration.max_retries + 1
+          attempt = 0
+
+          begin
+            attempt += 1
+            return yield
+          rescue => error
+            current_provider = get_current_provider_safely
+
+            if attempt < max_attempts
+              error_info = {
+                error: error,
+                provider: current_provider,
+                model: get_current_model_safely,
+                error_type: @error_classifier.classify_error(error)
+              }
+
+              strategy = get_retry_strategy(error_info[:error_type])
+              if should_retry?(error_info, strategy)
+                delay = @backoff_calculator.calculate_delay(attempt, strategy[:backoff_strategy] || :exponential, 1, 10)
+                debug_log("🔁 Retry attempt #{attempt} for #{current_provider}", level: :info, data: {delay: delay, error_type: error_info[:error_type]})
+                sleep(delay) if delay > 0
+                retry
+              end
+            end
 
-            strategy = get_retry_strategy(error_info[:error_type])
-            if should_retry?(error_info, strategy)
-              delay = @backoff_calculator.calculate_delay(attempt, strategy[:backoff_strategy] || :exponential, 1, 10)
-              # Use regular sleep for now (async not needed in this context)
-              sleep(delay)
-              retry
+            # Provider exhausted – attempt recovery (may switch provider)
+            debug_log("🚫 Exhausted retries for provider, attempting recovery", level: :warn, data: {provider: current_provider, attempt: attempt, max_attempts: max_attempts})
+            handle_error(error, {
+              provider: current_provider,
+              model: get_current_model_safely,
+              exhausted_retries: true
+            })
+
+            new_provider = get_current_provider_safely
+            if new_provider != current_provider && !providers_tried.include?(new_provider)
+              providers_tried << current_provider
+              # Reset retry counts for the new provider
+              begin
+                reset_retry_counts(new_provider)
+              rescue => e
+                debug_log("⚠️ Failed to reset retry counts for new provider", level: :warn, data: {error: e.message})
+              end
+              debug_log("🔀 Switched provider after failure – re-executing block", level: :info, data: {from: current_provider, to: new_provider})
+              # Start retry loop fresh for new provider
+              next
             end
-          end
 
-          # If we get here, all retries failed
-          handle_error(error, {
-            provider: @provider_manager.current_provider,
-            model: @provider_manager.current_model
-          })
+            # No new provider (or already tried) – return structured failure
+            debug_log("❌ No fallback provider available or all tried", level: :error, data: {providers_tried: providers_tried})
+            begin
+              if @provider_manager.respond_to?(:mark_provider_failure_exhausted)
+                @provider_manager.mark_provider_failure_exhausted(current_provider)
+                debug_log("🛑 Marked provider #{current_provider} unhealthy due to exhausted retries", level: :warn)
+              end
+            rescue => e
+              debug_log("⚠️ Failed to mark provider failure-exhausted", level: :warn, data: {error: e.message})
+            end
+            return {
+              status: "failed",
+              error: error,
+              message: error.message,
+              provider: current_provider,
+              providers_tried: providers_tried.dup
+            }
+          end
         end
       end
 
@@ -579,9 +630,12 @@ module Aidp
               priority: :high
             }
           when :authentication, :permission_denied
+            # Previously we escalated immediately. Instead, attempt a provider switch
+            # so workflows can continue with alternate providers (e.g., Gemini, Cursor)
+            # while the user resolves credentials for the failing provider.
             {
-              action: :escalate,
-              reason: "Authentication or permission issue requires manual intervention",
+              action: :switch_provider,
+              reason: "Authentication/permission issue – switching provider to continue",
               priority: :critical
             }
           when :timeout
@@ -611,6 +665,27 @@ module Aidp
           end
         end
       end
+
+      # Safe access to provider manager methods that may not exist
+      def get_current_provider_safely
+        return "unknown" unless @provider_manager
+        return "unknown" unless @provider_manager.respond_to?(:current_provider)
+
+        @provider_manager.current_provider || "unknown"
+      rescue => e
+        debug_log("⚠️ Failed to get current provider", level: :warn, data: {error: e.message})
+        "unknown"
+      end
+
+      def get_current_model_safely
+        return "unknown" unless @provider_manager
+        return "unknown" unless @provider_manager.respond_to?(:current_model)
+
+        @provider_manager.current_model || "unknown"
+      rescue => e
+        debug_log("⚠️ Failed to get current model", level: :warn, data: {error: e.message})
+        "unknown"
+      end
     end
   end
 end

data/lib/aidp/harness/provider_factory.rb

@@ -7,6 +7,8 @@ require_relative "../providers/anthropic"
 require_relative "../providers/gemini"
 require_relative "../providers/macos_ui"
 require_relative "../providers/opencode"
+require_relative "../providers/github_copilot"
+require_relative "../providers/codex"
 
 module Aidp
   module Harness
@@ -15,9 +17,12 @@ module Aidp
       PROVIDER_CLASSES = {
         "cursor" => Aidp::Providers::Cursor,
         "anthropic" => Aidp::Providers::Anthropic,
+        "claude" => Aidp::Providers::Anthropic,
         "gemini" => Aidp::Providers::Gemini,
         "macos" => Aidp::Providers::MacOSUI,
-        "opencode" => Aidp::Providers::Opencode
+        "opencode" => Aidp::Providers::Opencode,
+        "github_copilot" => Aidp::Providers::GithubCopilot,
+        "codex" => Aidp::Providers::Codex
       }.freeze
 
       def initialize(config_manager = nil)