aidp 0.10.0 → 0.12.0

data/lib/aidp/harness/provider_info.rb

@@ -0,0 +1,366 @@
+# frozen_string_literal: true
+
+require "json"
+require "yaml"
+require "fileutils"
+
+module Aidp
+  module Harness
+    # Stores detailed information about AI providers gathered from their CLI tools
+    class ProviderInfo
+      attr_reader :provider_name, :info_file_path
+
+      def initialize(provider_name, root_dir = nil)
+        @provider_name = provider_name
+        @root_dir = root_dir || Dir.pwd
+        @info_file_path = File.join(@root_dir, ".aidp", "providers", "#{provider_name}_info.yml")
+        ensure_directory_exists
+      end
+
+      # Gather information about the provider by introspecting its CLI
+      def gather_info
+        info = {
+          provider: @provider_name,
+          last_checked: Time.now.iso8601,
+          cli_available: false,
+          help_output: nil,
+          capabilities: {},
+          permission_modes: [],
+          mcp_support: false,
+          mcp_servers: [],
+          auth_method: nil,
+          flags: {}
+        }
+
+        # Try to get help output from the provider CLI
+        help_output = fetch_help_output
+        if help_output
+          info[:cli_available] = true
+          info[:help_output] = help_output
+          info.merge!(parse_help_output(help_output))
+        end
+
+        # Try to get MCP server list if supported
+        if info[:mcp_support]
+          mcp_servers = fetch_mcp_servers
+          info[:mcp_servers] = mcp_servers if mcp_servers
+        end
+
+        save_info(info)
+        info
+      end
+
+      # Load stored provider info
+      def load_info
+        return nil unless File.exist?(@info_file_path)
+
+        YAML.safe_load_file(@info_file_path, permitted_classes: [Time, Symbol])
+      rescue => e
+        warn "Failed to load provider info for #{@provider_name}: #{e.message}"
+        nil
+      end
+
+      # Get provider info, refreshing if needed
+      def get_info(force_refresh: false, max_age: 86400)
+        existing_info = load_info
+
+        # Refresh if forced, missing, or stale
+        if force_refresh || existing_info.nil? || info_stale?(existing_info, max_age)
+          gather_info
+        else
+          existing_info
+        end
+      end
+
+      # Check if provider supports MCP servers
+      def supports_mcp?
+        info = load_info
+        return false unless info
+
+        info[:mcp_support] == true
+      end
+
+      # Get permission modes available
+      def permission_modes
+        info = load_info
+        return [] unless info
+
+        info[:permission_modes] || []
+      end
+
+      # Get authentication method
+      def auth_method
+        info = load_info
+        return nil unless info
+
+        info[:auth_method]
+      end
+
+      # Get available flags/options
+      def available_flags
+        info = load_info
+        return {} unless info
+
+        info[:flags] || {}
+      end
+
+      # Get configured MCP servers
+      def mcp_servers
+        info = load_info
+        return [] unless info
+
+        info[:mcp_servers] || []
+      end
+
+      # Check if provider has MCP servers configured
+      def has_mcp_servers?
+        mcp_servers.any?
+      end
+
+      private
+
+      def ensure_directory_exists
+        dir = File.dirname(@info_file_path)
+        FileUtils.mkdir_p(dir) unless Dir.exist?(dir)
+      end
+
+      def save_info(info)
+        File.write(@info_file_path, YAML.dump(info))
+      end
+
+      def info_stale?(info, max_age)
+        return true unless info[:last_checked]
+
+        last_checked = Time.parse(info[:last_checked].to_s)
+        (Time.now - last_checked) > max_age
+      rescue
+        true
+      end
+
+      def fetch_help_output
+        execute_provider_command("--help")
+      end
+
+      def fetch_mcp_servers
+        binary = get_binary_name
+        return nil unless binary
+
+        # Try different MCP list commands based on provider
+        mcp_output = case @provider_name
+        when "claude", "anthropic"
+          execute_provider_command("mcp", "list")
+        end
+
+        return nil unless mcp_output
+
+        parse_mcp_servers(mcp_output)
+      end
+
+      def execute_provider_command(*args)
+        binary = get_binary_name
+        return nil unless binary
+
+        # Try to find the binary
+        path = begin
+          Aidp::Util.which(binary)
+        rescue
+          nil
+        end
+        return nil unless path
+
+        # Execute command with timeout
+        begin
+          r, w = IO.pipe
+          pid = Process.spawn(binary, *args, out: w, err: w)
+          w.close
+
+          # Wait with timeout
+          deadline = Time.now + 5
+          status = nil
+          while Time.now < deadline
+            pid_done, status = Process.waitpid2(pid, Process::WNOHANG)
+            break if pid_done
+            sleep 0.05
+          end
+
+          # Kill if timed out
+          unless status
+            begin
+              Process.kill("TERM", pid)
+              sleep 0.1
+              Process.kill("KILL", pid)
+            rescue
+              nil
+            end
+            return nil
+          end
+
+          output = r.read
+          r.close
+          output
+        rescue
+          nil
+        end
+      end
+
+      def parse_mcp_servers(output)
+        servers = []
+        return servers unless output
+
+        # Parse MCP server list output
+        # Claude format (as of 2025):
+        # dash-api: uvx --from git+https://... - ✓ Connected
+        # or
+        # server-name: command - ✗ Error message
+        #
+        # Legacy format:
+        # Name              Status    Description
+        # filesystem        enabled   File system access
+
+        lines = output.lines
+
+        # Skip header lines
+        lines.reject! { |line| /checking mcp server health/i.match?(line) }
+
+        lines.each do |line|
+          line = line.strip
+          next if line.empty?
+
+          # Try to parse new Claude format: "name: command - ✓ Connected"
+          if line =~ /^([^:]+):\s*(.+?)\s*-\s*(✓|✗)\s*(.+)$/
+            name = Regexp.last_match(1).strip
+            command = Regexp.last_match(2).strip
+            status_symbol = Regexp.last_match(3)
+            status_text = Regexp.last_match(4).strip
+
+            servers << {
+              name: name,
+              status: (status_symbol == "✓") ? "connected" : "error",
+              description: command,
+              enabled: status_symbol == "✓",
+              error: (status_symbol == "✗") ? status_text : nil
+            }
+            next
+          end
+
+          # Try to parse legacy table format
+          # Skip header line
+          next if /Name.*Status/i.match?(line)
+          next if /^[-=]+$/.match?(line) # Skip separator lines
+
+          # Parse table format: columns separated by multiple spaces
+          parts = line.split(/\s{2,}/)
+          next if parts.size < 2
+
+          name = parts[0]&.strip
+          status = parts[1]&.strip
+          description = parts[2..]&.join(" ")&.strip
+
+          next unless name && !name.empty?
+
+          servers << {
+            name: name,
+            status: status || "unknown",
+            description: description,
+            enabled: status&.downcase == "enabled" || status&.downcase == "connected"
+          }
+        end
+
+        servers
+      end
+
+      def get_binary_name
+        case @provider_name
+        when "claude", "anthropic"
+          "claude"
+        when "cursor"
+          "cursor"
+        when "gemini"
+          "gemini"
+        when "codex"
+          "codex"
+        when "github_copilot"
+          "gh"
+        when "opencode"
+          "opencode"
+        else
+          @provider_name
+        end
+      end
+
+      def parse_help_output(help_text)
+        parsed = {
+          capabilities: {},
+          permission_modes: [],
+          mcp_support: false,
+          auth_method: nil,
+          flags: {}
+        }
+
+        # Check for MCP support
+        parsed[:mcp_support] = !!(help_text =~ /mcp|MCP|Model Context Protocol/i)
+
+        # Extract permission modes
+        if help_text =~ /--permission-mode\s+<mode>\s+.*?\(choices:\s*([^)]+)\)/m
+          modes = Regexp.last_match(1).split(",").map(&:strip).map { |m| m.gsub(/["']/, "") }
+          parsed[:permission_modes] = modes
+        end
+
+        # Check for dangerous skip permissions
+        parsed[:capabilities][:bypass_permissions] = !!(help_text =~ /--dangerously-skip-permissions/)
+
+        # Check for API key / subscription patterns
+        if /--api-key|API_KEY|setup-token|subscription/i.match?(help_text)
+          parsed[:auth_method] = if /setup-token|subscription/i.match?(help_text)
+            "subscription"
+          else
+            "api_key"
+          end
+        end
+
+        # Extract model configuration
+        parsed[:capabilities][:model_selection] = !!(help_text =~ /--model\s+<model>/)
+
+        # Extract MCP configuration
+        parsed[:capabilities][:mcp_config] = !!(help_text =~ /--mcp-config/)
+
+        # Extract allowed/disallowed tools
+        parsed[:capabilities][:tool_restrictions] = !!(help_text =~ /--allowed-tools|--disallowed-tools/)
+
+        # Extract session management
+        parsed[:capabilities][:session_management] = !!(help_text =~ /--continue|--resume|--fork-session/)
+
+        # Extract output formats
+        if help_text =~ /--output-format\s+.*?\(choices:\s*([^)]+)\)/m
+          formats = Regexp.last_match(1).split(",").map(&:strip).map { |f| f.gsub(/["']/, "") }
+          parsed[:capabilities][:output_formats] = formats
+        end
+
+        # Extract notable flags
+        extract_flags(help_text, parsed[:flags])
+
+        parsed
+      end
+
+      def extract_flags(help_text, flags_hash)
+        # Extract all flags with their descriptions
+        help_text.scan(/^\s+(--[\w-]+(?:\s+<\w+>)?)\s+(.+?)(?=^\s+(?:--|\w|$))/m).each do |flag, desc|
+          flag_name = flag.split.first.gsub(/^--/, "")
+          flags_hash[flag_name] = {
+            flag: flag.strip,
+            description: desc.strip.gsub(/\s+/, " ")
+          }
+        end
+
+        # Also capture short flags
+        help_text.scan(/^\s+(-\w),\s+(--[\w-]+(?:\s+<\w+>)?)\s+(.+?)(?=^\s+(?:--|-\w|$))/m).each do |short, long, desc|
+          flag_name = long.split.first.gsub(/^--/, "")
+          flags_hash[flag_name] ||= {}
+          flags_hash[flag_name][:short] = short
+          flags_hash[flag_name][:flag] = long.strip
+          flags_hash[flag_name][:description] = desc.strip.gsub(/\s+/, " ")
+        end
+      end
+    end
+  end
+end

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