aidp 0.10.0 → 0.11.0

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)

data/lib/aidp/harness/provider_manager.rb

@@ -7,6 +7,8 @@ module Aidp
   module Harness
     # Manages provider switching and fallback logic
     class ProviderManager
+      include Aidp::MessageDisplay
+
       def initialize(configuration, prompt: TTY::Prompt.new)
         @configuration = configuration
         @prompt = prompt
@@ -31,6 +33,9 @@ module Aidp
         @model_fallback_chains = {}
         @model_switching_enabled = true
         @model_weights = {}
+        @unavailable_cache = {}
+        @binary_check_cache = {}
+        @binary_check_ttl = 300 # seconds
         initialize_fallback_chains
         initialize_provider_health
         initialize_model_configs
@@ -562,9 +567,39 @@ module Aidp
 
       # Check if provider is available (not rate limited, healthy, circuit breaker closed)
       def is_provider_available?(provider_name)
-        !is_rate_limited?(provider_name) &&
-          is_provider_healthy?(provider_name) &&
-          !is_provider_circuit_breaker_open?(provider_name)
+        cli_ok, _reason = provider_cli_available?(provider_name)
+        return false unless cli_ok
+        return false if is_rate_limited?(provider_name)
+        return false unless is_provider_healthy?(provider_name)
+        return false if is_provider_circuit_breaker_open?(provider_name)
+        true
+      end
+
+      # Mark provider unhealthy (auth or generic) and optionally open circuit breaker
+      def mark_provider_unhealthy(provider_name, reason: "manual", open_circuit: true)
+        return unless @provider_health[provider_name]
+        health = @provider_health[provider_name]
+        health[:status] = (reason == "auth") ? "unhealthy_auth" : "unhealthy"
+        health[:last_updated] = Time.now
+        health[:unhealthy_reason] = reason
+        if open_circuit
+          health[:circuit_breaker_open] = true
+          health[:circuit_breaker_opened_at] = Time.now
+          log_circuit_breaker_event(provider_name, "opened")
+        end
+      end
+
+      def mark_provider_auth_failure(provider_name)
+        mark_provider_unhealthy(provider_name, reason: "auth", open_circuit: true)
+      end
+
+      # Mark provider unhealthy specifically due to failure exhaustion (non-auth)
+      def mark_provider_failure_exhausted(provider_name)
+        return unless @provider_health[provider_name]
+        health = @provider_health[provider_name]
+        # Don't override more critical states (auth or circuit already open)
+        return if health[:unhealthy_reason] == "auth"
+        mark_provider_unhealthy(provider_name, reason: "fail_exhausted", open_circuit: true)
       end
 
       # Check if model is rate limited
@@ -950,6 +985,198 @@ module Aidp
         @provider_metrics.dup
       end
 
+      # Determine whether a provider CLI/binary appears installed
+      def provider_installed?(provider_name)
+        return @unavailable_cache[provider_name] unless @unavailable_cache[provider_name].nil?
+        installed = true
+        begin
+          case provider_name
+          when "anthropic", "claude"
+            # Prefer direct binary probe instead of Anthropic.available? (which uses which internally)
+            path = begin
+              Aidp::Util.which("claude")
+            rescue
+              nil
+            end
+            installed = !path.nil?
+          when "cursor"
+            require_relative "../providers/cursor"
+            installed = Aidp::Providers::Cursor.available?
+          end
+        rescue LoadError
+          installed = false
+        end
+        @unavailable_cache[provider_name] = installed
+      end
+
+      # Attempt to run a provider's CLI with --version (or no-op) to verify executable health
+      def provider_cli_available?(provider_name)
+        normalized = normalize_provider_name(provider_name)
+
+        # Handle test environment overrides
+        if defined?(RSpec) || ENV["RSPEC_RUNNING"]
+          # Force claude to be missing for testing
+          if ENV["AIDP_FORCE_CLAUDE_MISSING"] == "1" && normalized == "claude"
+            return [false, "binary_missing"]
+          end
+          # Force claude to be available for testing
+          if ENV["AIDP_FORCE_CLAUDE_AVAILABLE"] == "1" && normalized == "claude"
+            return [true, "available"]
+          end
+        end
+
+        cache_key = "#{provider_name}:#{normalized}"
+        cached = @binary_check_cache[cache_key]
+        if cached && (Time.now - cached[:checked_at] < @binary_check_ttl)
+          return [cached[:ok], cached[:reason]]
+        end
+        # Map normalized provider -> binary
+        binary = case normalized
+        when "claude" then "claude"
+        when "cursor" then "cursor"
+        when "gemini" then "gemini"
+        when "macos" then nil # passthrough; no direct binary expected
+        end
+        unless binary
+          @binary_check_cache[cache_key] = {ok: true, reason: nil, checked_at: Time.now}
+          return [true, nil]
+        end
+        path = begin
+          Aidp::Util.which(binary)
+        rescue
+          nil
+        end
+        unless path
+          @binary_check_cache[cache_key] = {ok: false, reason: "binary_missing", checked_at: Time.now}
+          return [false, "binary_missing"]
+        end
+        # Light command execution to ensure it responds quickly
+        ok = true
+        reason = nil
+        begin
+          # Use IO.popen to avoid shell injection and impose a short timeout
+          r, w = IO.pipe
+          pid = Process.spawn(binary, "--version", out: w, err: w)
+          w.close
+          deadline = Time.now + 3
+          status = nil
+          while Time.now < deadline
+            pid_done, status = Process.waitpid2(pid, Process::WNOHANG)
+            break if pid_done
+            sleep 0.05
+          end
+          unless status
+            # Timeout -> kill
+            begin
+              Process.kill("TERM", pid)
+            rescue
+              nil
+            end
+            sleep 0.1
+            begin
+              Process.kill("KILL", pid)
+            rescue
+              nil
+            end
+            ok = false
+            reason = "binary_timeout"
+          end
+          output = r.read.to_s
+          r.close
+          if ok && output.strip.empty?
+            # Some CLIs require just calling without args; treat empty as still OK
+            ok = true
+          end
+        rescue => e
+          ok = false
+          reason = e.class.name.downcase.include?("enoent") ? "binary_missing" : "binary_error"
+        end
+        @binary_check_cache[cache_key] = {ok: ok, reason: reason, checked_at: Time.now}
+        [ok, reason]
+      end
+
+      # Summarize health and metrics for dashboard/CLI display
+      def health_dashboard
+        now = Time.now
+        statuses = get_provider_health_status
+        metrics = all_metrics
+        configured = @configuration.configured_providers
+        # Ensure fresh binary probe results in test mode so stubs of Aidp::Util.which take effect
+        if defined?(RSpec) || ENV["RSPEC_RUNNING"]
+          @binary_check_cache.clear
+        end
+        rows_by_normalized = {}
+        configured.each do |prov|
+          # Temporarily hide macos provider until it's user-configurable
+          next if prov == "macos"
+          normalized = normalize_provider_name(prov)
+          cli_ok_prefetch, cli_reason_prefetch = provider_cli_available?(prov)
+          h = statuses[prov] || {}
+          m = metrics[prov] || {}
+          rl = @rate_limit_info[prov]
+          reset_in = (rl && rl[:reset_time]) ? [(rl[:reset_time] - now).to_i, 0].max : nil
+          cb_remaining = if h[:circuit_breaker_open] && h[:circuit_breaker_opened_at]
+            elapsed = now - h[:circuit_breaker_opened_at]
+            rem = @circuit_breaker_timeout - elapsed
+            rem.positive? ? rem.to_i : 0
+          end
+          row = {
+            provider: normalized,
+            installed: provider_installed?(prov),
+            status: h[:status] || (provider_installed?(prov) ? "unknown" : "uninstalled"),
+            unhealthy_reason: h[:unhealthy_reason],
+            available: false, # will set true below only if all checks pass
+            circuit_breaker: h[:circuit_breaker_open] ? "open" : "closed",
+            circuit_breaker_remaining: cb_remaining,
+            rate_limited: !!rl,
+            rate_limit_reset_in: reset_in,
+            total_requests: m[:total_requests] || 0,
+            failed_requests: m[:failed_requests] || 0,
+            success_requests: m[:successful_requests] || 0,
+            total_tokens: m[:total_tokens] || 0,
+            last_used: m[:last_used]
+          }
+          # Incorporate CLI check outcome into reason/availability if failing
+          unless cli_ok_prefetch
+            row[:available] = false
+            row[:unhealthy_reason] ||= cli_reason_prefetch
+            row[:status] = "unhealthy" if row[:status] == "healthy" || row[:status] == "healthy_auth"
+          end
+          if cli_ok_prefetch && is_provider_available?(prov)
+            row[:available] = true
+          end
+          if (existing = rows_by_normalized[normalized])
+            # Merge metrics: sum counts/tokens, keep most severe status, earliest unhealthy reason if any
+            existing[:total_requests] += row[:total_requests]
+            existing[:failed_requests] += row[:failed_requests]
+            existing[:success_requests] += row[:success_requests]
+            existing[:total_tokens] += row[:total_tokens]
+            # If either unavailable then mark unavailable
+            existing[:available] &&= row[:available]
+            # Prefer an unhealthy or circuit breaker status over healthy
+            existing[:status] = merge_status_priority(existing[:status], row[:status])
+            existing[:unhealthy_reason] ||= row[:unhealthy_reason]
+            # Circuit breaker open takes precedence
+            if row[:circuit_breaker] == "open"
+              existing[:circuit_breaker] = "open"
+              existing[:circuit_breaker_remaining] = [existing[:circuit_breaker_remaining].to_i, row[:circuit_breaker_remaining].to_i].max
+            end
+            # Rate limited if any underlying
+            if row[:rate_limited]
+              existing[:rate_limited] = true
+              existing[:rate_limit_reset_in] = [existing[:rate_limit_reset_in].to_i, row[:rate_limit_reset_in].to_i].max
+            end
+            # Keep most recent last_used
+            if row[:last_used] && (!existing[:last_used] || row[:last_used] > existing[:last_used])
+              existing[:last_used] = row[:last_used]
+            end
+          else
+            rows_by_normalized[normalized] = row
+          end
+        end
+        rows_by_normalized.values
+      end
+
       # Get provider history
       def provider_history
         @provider_history.dup
@@ -1006,7 +1233,9 @@ module Aidp
             circuit_breaker_open: health[:circuit_breaker_open],
             last_updated: health[:last_updated],
             last_used: health[:last_used],
-            last_rate_limited: health[:last_rate_limited]
+            last_rate_limited: health[:last_rate_limited],
+            circuit_breaker_opened_at: health[:circuit_breaker_opened_at],
+            unhealthy_reason: health[:unhealthy_reason]
           }
         end
       end
@@ -1203,17 +1432,23 @@ module Aidp
 
       private
 
-      def display_message(message, type: :info)
-        color = case type
-        when :error then :red
-        when :success then :green
-        when :warning then :yellow
-        when :info then :blue
-        when :highlight then :cyan
-        when :muted then :bright_black
-        else :white
-        end
-        @prompt.say(message, color: color)
+      # Normalize provider naming for display (hide legacy 'anthropic')
+      def normalize_provider_name(name)
+        return "claude" if name == "anthropic"
+        name
+      end
+
+      # Status priority for merging duplicate normalized providers
+      def merge_status_priority(a, b)
+        order = {
+          "circuit_breaker_open" => 5,
+          "unhealthy_auth" => 4,
+          "unhealthy" => 3,
+          "unknown" => 2,
+          "healthy" => 1,
+          nil => 0
+        }
+        ((order[a] || 0) >= (order[b] || 0)) ? a : b
       end
 
       public

data/lib/aidp/harness/runner.rb

@@ -15,6 +15,8 @@ module Aidp
   module Harness
     # Main harness runner that orchestrates the execution loop
     class Runner
+      include Aidp::MessageDisplay
+
       # Harness execution states
       STATES = {
         idle: "idle",
@@ -38,7 +40,7 @@ module Aidp
         @start_time = nil
         @current_step = nil
         @current_provider = nil
-        @user_input = options[:user_input] || {}  # Include user input from workflow selection
+        @user_input = options[:user_input] || {} # Include user input from workflow selection
         @execution_log = []
         @prompt = options[:prompt] || TTY::Prompt.new
 
@@ -412,19 +414,6 @@ module Aidp
       end
 
       private
-
-      def display_message(message, type: :info)
-        color = case type
-        when :error then :red
-        when :success then :green
-        when :warning then :yellow
-        when :info then :blue
-        when :highlight then :cyan
-        when :muted then :bright_black
-        else :white
-        end
-        @prompt.say(message, color: color)
-      end
     end
   end
 end

data/lib/aidp/harness/simple_user_interface.rb

@@ -7,6 +7,8 @@ module Aidp
     # Simple, focused user interface for collecting feedback
     # Replaces the bloated UserInterface with minimal, clean code
     class SimpleUserInterface
+      include Aidp::MessageDisplay
+
       def initialize(prompt: TTY::Prompt.new)
         @prompt = prompt
       end
@@ -26,21 +28,6 @@ module Aidp
 
       private
 
-      # Helper method for consistent message display using TTY::Prompt
-      def display_message(message, type: :info)
-        color = case type
-        when :error then :red
-        when :success then :green
-        when :warning then :yellow
-        when :info then :blue
-        when :highlight then :cyan
-        when :muted then :bright_black
-        else :white
-        end
-
-        @prompt.say(message, color: color)
-      end
-
       def show_context(context)
         display_message("\n🤖 Agent needs feedback", type: :info)
         display_message("Context: #{context[:description]}", type: :info) if context[:description]