aidp 0.10.0 → 0.12.0

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
@@ -55,6 +55,27 @@ module Aidp
         @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]

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

@@ -8,6 +8,7 @@ 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
@@ -16,10 +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,
-        "github_copilot" => Aidp::Providers::GithubCopilot
+        "github_copilot" => Aidp::Providers::GithubCopilot,
+        "codex" => Aidp::Providers::Codex
       }.freeze
 
       def initialize(config_manager = nil)