aidp 0.9.6 → 0.11.0

data/lib/aidp/harness/provider_manager.rb

@@ -1,13 +1,17 @@
 # frozen_string_literal: true
 
+require "tty-prompt"
 require_relative "provider_factory"
 
 module Aidp
   module Harness
     # Manages provider switching and fallback logic
     class ProviderManager
-      def initialize(configuration)
+      include Aidp::MessageDisplay
+
+      def initialize(configuration, prompt: TTY::Prompt.new)
         @configuration = configuration
+        @prompt = prompt
         @current_provider = nil
         @current_model = nil
         @provider_history = []
@@ -29,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
@@ -560,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
@@ -948,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
@@ -1004,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
@@ -1199,20 +1430,43 @@ module Aidp
         [delay, 60].min # Cap at 60 seconds
       end
 
+      private
+
+      # 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
+
       # Log provider switch
       def log_provider_switch(from_provider, to_provider, reason, context)
-        puts "🔄 Provider switch: #{from_provider} → #{to_provider} (#{reason})"
+        display_message("🔄 Provider switch: #{from_provider} → #{to_provider} (#{reason})", type: :info)
         if context.any?
-          puts "   Context: #{context.inspect}"
+          display_message("   Context: #{context.inspect}", type: :muted)
         end
       end
 
       # Log no providers available
       def log_no_providers_available(reason, context)
-        puts "❌ No providers available for switching (#{reason})"
-        puts "   All providers are rate limited, unhealthy, or circuit breaker open"
+        display_message("❌ No providers available for switching (#{reason})", type: :error)
+        display_message("   All providers are rate limited, unhealthy, or circuit breaker open", type: :warning)
         if context.any?
-          puts "   Context: #{context.inspect}"
+          display_message("   Context: #{context.inspect}", type: :muted)
         end
       end
 
@@ -1220,26 +1474,26 @@ module Aidp
       def log_circuit_breaker_event(provider_name, event)
         case event
         when "opened"
-          puts "🔴 Circuit breaker opened for provider: #{provider_name}"
+          display_message("🔴 Circuit breaker opened for provider: #{provider_name}", type: :error)
         when "reset"
-          puts "🟢 Circuit breaker reset for provider: #{provider_name}"
+          display_message("🟢 Circuit breaker reset for provider: #{provider_name}", type: :success)
         end
       end
 
       # Log model switch
       def log_model_switch(from_model, to_model, reason, context)
-        puts "🔄 Model switch: #{from_model} → #{to_model} (#{reason})"
+        display_message("🔄 Model switch: #{from_model} → #{to_model} (#{reason})", type: :info)
         if context.any?
-          puts "   Context: #{context.inspect}"
+          display_message("   Context: #{context.inspect}", type: :muted)
         end
       end
 
       # Log no models available
       def log_no_models_available(provider_name, reason, context)
-        puts "❌ No models available for provider #{provider_name} (#{reason})"
-        puts "   All models are rate limited, unhealthy, or circuit breaker open"
+        display_message("❌ No models available for provider #{provider_name} (#{reason})", type: :error)
+        display_message("   All models are rate limited, unhealthy, or circuit breaker open", type: :warning)
         if context.any?
-          puts "   Context: #{context.inspect}"
+          display_message("   Context: #{context.inspect}", type: :muted)
         end
       end
 
@@ -1247,9 +1501,9 @@ module Aidp
       def log_model_circuit_breaker_event(provider_name, model_name, event)
         case event
         when "opened"
-          puts "🔴 Circuit breaker opened for model: #{provider_name}:#{model_name}"
+          display_message("🔴 Circuit breaker opened for model: #{provider_name}:#{model_name}", type: :error)
         when "reset"
-          puts "🟢 Circuit breaker reset for model: #{provider_name}:#{model_name}"
+          display_message("🟢 Circuit breaker reset for model: #{provider_name}:#{model_name}", type: :success)
         end
       end
 

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",
@@ -27,6 +29,9 @@ module Aidp
         error: "error"
       }.freeze
 
+      # Public accessors for testing and integration
+      attr_reader :current_provider, :current_step, :user_input, :execution_log, :provider_manager
+
       def initialize(project_dir, mode = :analyze, options = {})
         @project_dir = project_dir
         @mode = mode.to_sym
@@ -35,8 +40,9 @@ 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
 
         # Store workflow configuration
         @selected_steps = options[:selected_steps]
@@ -46,7 +52,7 @@ 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: @prompt)
         @user_interface = SimpleUserInterface.new
         @error_handler = ErrorHandler.new(@provider_manager, @configuration)
         @status_display = StatusDisplay.new
@@ -96,8 +102,8 @@ module Aidp
               log_execution("Harness completed successfully - all criteria met", completion_status)
             else
               log_execution("Steps completed but completion criteria not met", completion_status)
-              puts "\n⚠️  All steps completed but some completion criteria not met:"
-              puts completion_status[:summary]
+              display_message("\n⚠️  All steps completed but some completion criteria not met:", type: :warning)
+              display_message(completion_status[:summary], type: :info)
 
               # Ask user if they want to continue anyway
               if @user_interface.get_confirmation("Continue anyway? This may indicate issues that should be addressed.", default: false)
@@ -181,9 +187,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
@@ -406,6 +412,8 @@ module Aidp
           "Harness finished in state: #{@state}"
         end
       end
+
+      private
     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
@@ -27,9 +29,9 @@ module Aidp
       private
 
       def show_context(context)
-        puts "\n🤖 Agent needs feedback"
-        puts "Context: #{context[:description]}" if context[:description]
-        puts ""
+        display_message("\n🤖 Agent needs feedback", type: :info)
+        display_message("Context: #{context[:description]}", type: :info) if context[:description]
+        display_message("", type: :info)
       end
 
       def ask_question(question_data)
@@ -39,7 +41,7 @@ module Aidp
         required = question_data[:required] != false
         options = question_data[:options]
 
-        puts "\n#{question}"
+        display_message("\n#{question}", type: :info)
 
         case type
         when "text"