aidp 0.26.0 → 0.28.0

data/lib/aidp/harness/thinking_depth_manager.rb

@@ -2,12 +2,15 @@
 
 require_relative "capability_registry"
 require_relative "configuration"
+require_relative "../message_display"
 
 module Aidp
   module Harness
     # Manages thinking depth tier selection and escalation
     # Integrates with CapabilityRegistry and Configuration to select appropriate models
     class ThinkingDepthManager
+      include Aidp::MessageDisplay
+
       attr_reader :configuration, :registry
 
       def initialize(configuration, registry: nil, root_dir: nil)
@@ -150,11 +153,40 @@ module Aidp
         tier ||= current_tier
         validate_tier!(tier)
 
-        # If provider specified, try to find model for that provider
+        # First, try to get models from user's configuration for this tier and provider
+        if provider
+          configured_models = configuration.models_for_tier(tier, provider)
+
+          if configured_models.any?
+            # Use first configured model for this provider and tier
+            model_name = configured_models.first
+            Aidp.log_debug("thinking_depth_manager", "Selected model from user config",
+              tier: tier,
+              provider: provider,
+              model: model_name)
+            return [provider, model_name, {}]
+          end
+
+          # Provider specified but has no models for this tier in config
+          # Try catalog for the specified provider before switching providers
+          Aidp.log_debug("thinking_depth_manager", "Provider has no configured models for tier, trying catalog",
+            tier: tier,
+            provider: provider)
+
+          # Continue to catalog-based selection below (will try specified provider first)
+        else
+          # No provider specified - this should not happen in normal flow
+          # Log warning and fall through to catalog-based selection
+          Aidp.log_warn("thinking_depth_manager", "select_model_for_tier called without provider",
+            tier: tier)
+        end
+
+        # Fall back to catalog-based selection if no models in user config
+        # If provider specified, try to find model for that provider in catalog
         if provider
           model_name, model_data = @registry.best_model_for_tier(tier, provider)
           if model_name
-            Aidp.log_debug("thinking_depth_manager", "Selected model",
+            Aidp.log_debug("thinking_depth_manager", "Selected model from catalog",
               tier: tier,
               provider: provider,
               model: model_name)
@@ -163,20 +195,24 @@ module Aidp
 
           # If provider doesn't support tier and switching allowed, try others
           unless configuration.allow_provider_switch_for_tier?
-            Aidp.log_warn("thinking_depth_manager", "Provider lacks tier, switching disabled",
+            Aidp.log_warn("thinking_depth_manager", "Provider lacks tier in catalog, switching disabled",
               tier: tier,
               provider: provider)
             return nil
           end
         end
 
-        # Try all providers
+        # Try all providers in catalog
+        if provider && !configuration.allow_provider_switch_for_tier?
+          return nil
+        end
+
         providers_to_try = provider ? [@registry.provider_names - [provider]].flatten : @registry.provider_names
 
         providers_to_try.each do |prov_name|
           model_name, model_data = @registry.best_model_for_tier(tier, prov_name)
           if model_name
-            Aidp.log_info("thinking_depth_manager", "Selected model from alternate provider",
+            Aidp.log_info("thinking_depth_manager", "Selected model from catalog (alternate provider)",
               tier: tier,
               original_provider: provider,
               selected_provider: prov_name,
@@ -185,10 +221,23 @@ module Aidp
           end
         end
 
-        Aidp.log_error("thinking_depth_manager", "No model found for tier",
+        # No model found for requested tier - try fallback to other tiers
+        Aidp.log_warn("thinking_depth_manager", "No model found for requested tier, trying fallback",
           tier: tier,
           provider: provider)
-        nil
+
+        result = try_fallback_tiers(tier, provider)
+
+        unless result
+          # Enhanced error message with discovery hints
+          display_enhanced_tier_error(tier, provider)
+
+          Aidp.log_error("thinking_depth_manager", "No model found for tier or fallback tiers",
+            tier: tier,
+            provider: provider)
+        end
+
+        result
       end
 
       # Get tier for a specific model
@@ -330,6 +379,152 @@ module Aidp
         # Keep history bounded
         @tier_history.shift if @tier_history.size > 100
       end
+
+      # Try to find a model in fallback tiers when requested tier has no models
+      # Tries lower tiers first (cheaper), then higher tiers
+      # Returns [provider_name, model_name, model_data] or nil
+      def try_fallback_tiers(requested_tier, provider)
+        # Generate fallback order: try lower tiers first, then higher
+        fallback_tiers = generate_fallback_tier_order(requested_tier)
+
+        fallback_tiers.each do |fallback_tier|
+          # First, try user's configuration for this fallback tier and provider
+          if provider
+            configured_models = configuration.models_for_tier(fallback_tier, provider)
+
+            if configured_models.any?
+              model_name = configured_models.first
+              Aidp.log_warn("thinking_depth_manager", "Falling back to different tier (from config)",
+                requested_tier: requested_tier,
+                fallback_tier: fallback_tier,
+                provider: provider,
+                model: model_name)
+              return [provider, model_name, {}]
+            end
+          end
+
+          # Fall back to catalog if no models in config for the provider
+          # Try specified provider first if given
+          if provider
+            model_name, model_data = @registry.best_model_for_tier(fallback_tier, provider)
+            if model_name
+              Aidp.log_warn("thinking_depth_manager", "Falling back to different tier (from catalog)",
+                requested_tier: requested_tier,
+                fallback_tier: fallback_tier,
+                provider: provider,
+                model: model_name)
+              return [provider, model_name, model_data]
+            end
+          end
+
+          # Try all available providers in catalog if switching allowed
+          if configuration.allow_provider_switch_for_tier?
+            @registry.provider_names.each do |prov_name|
+              next if prov_name == provider # Skip if already tried above
+
+              model_name, model_data = @registry.best_model_for_tier(fallback_tier, prov_name)
+              if model_name
+                Aidp.log_warn("thinking_depth_manager", "Falling back to different tier and provider (from catalog)",
+                  requested_tier: requested_tier,
+                  fallback_tier: fallback_tier,
+                  requested_provider: provider,
+                  fallback_provider: prov_name,
+                  model: model_name)
+                return [prov_name, model_name, model_data]
+              end
+            end
+          end
+        end
+
+        nil
+      end
+
+      # Generate fallback tier order: lower tiers first (cheaper), then higher
+      # For example, if tier is "standard", try: mini, thinking, pro, max
+      def generate_fallback_tier_order(tier)
+        current_priority = @registry.tier_priority(tier) || 1
+        all_tiers = CapabilityRegistry::VALID_TIERS
+
+        # Split into lower and higher tiers
+        lower_tiers = all_tiers.select { |t| (@registry.tier_priority(t) || 0) < current_priority }.reverse
+        higher_tiers = all_tiers.select { |t| (@registry.tier_priority(t) || 0) > current_priority }
+
+        # Try lower tiers first (cost optimization), then higher tiers
+        lower_tiers + higher_tiers
+      end
+
+      # Display enhanced error message with discovery hints
+      def display_enhanced_tier_error(tier, provider)
+        return unless defined?(Aidp::MessageDisplay)
+
+        # Check if there are discovered models in cache
+        discovered_models = check_discovered_models(tier, provider)
+
+        if discovered_models&.any?
+          display_tier_error_with_suggestions(tier, provider, discovered_models)
+        else
+          display_tier_error_with_discovery_hint(tier, provider)
+        end
+      end
+
+      # Check cache for discovered models for this tier
+      def check_discovered_models(tier, provider)
+        require_relative "model_cache"
+        require_relative "model_registry"
+
+        cache = Aidp::Harness::ModelCache.new
+        registry = Aidp::Harness::ModelRegistry.new
+
+        # Get all cached models for the provider
+        cached_models = cache.get_cached_models(provider)
+        return nil unless cached_models&.any?
+
+        # Filter to models for the requested tier
+        tier_models = cached_models.select do |model|
+          family = model[:family] || model["family"]
+          model_info = registry.get_model_info(family)
+          model_info && model_info["tier"] == tier.to_s
+        end
+
+        tier_models.any? ? tier_models : nil
+      rescue => e
+        Aidp.log_debug("thinking_depth_manager", "failed to check cached models",
+          error: e.message)
+        nil
+      end
+
+      # Display error with model suggestions from cache
+      def display_tier_error_with_suggestions(tier, provider, models)
+        display_message("\n❌ No model configured for '#{tier}' tier", type: :error)
+        display_message("   Provider: #{provider}", type: :info) if provider
+
+        display_message("\n💡 Discovered models for this tier:", type: :highlight)
+        models.first(3).each do |model|
+          model_name = model[:name] || model["name"]
+          display_message("   - #{model_name}", type: :info)
+        end
+
+        display_message("\n   Add to aidp.yml:", type: :highlight)
+        display_message("   providers:", type: :info)
+        display_message("     #{provider}:", type: :info)
+        display_message("       thinking:", type: :info)
+        display_message("         tiers:", type: :info)
+        display_message("           #{tier}:", type: :info)
+        display_message("             models:", type: :info)
+        first_model = models.first[:name] || models.first["name"]
+        display_message("               - model: #{first_model}\n", type: :info)
+      end
+
+      # Display error with discovery hint
+      def display_tier_error_with_discovery_hint(tier, provider)
+        display_message("\n❌ No model configured for '#{tier}' tier", type: :error)
+        display_message("   Provider: #{provider}", type: :info) if provider
+
+        display_message("\n💡 Suggested actions:", type: :highlight)
+        display_message("   1. Run 'aidp models discover' to find available models", type: :info)
+        display_message("   2. Run 'aidp models list --tier=#{tier}' to see models for this tier", type: :info)
+        display_message("   3. Run 'aidp models validate' to check your configuration\n", type: :info)
+      end
     end
   end
 end

data/lib/aidp/harness/ui/enhanced_tui.rb

@@ -43,16 +43,6 @@ module Aidp
           setup_signal_handlers
         end
 
-        # Simple display initialization - no background threads
-        def start_display_loop
-          # Display loop is now just a no-op for compatibility
-        end
-
-        def stop_display_loop
-          # Simple cleanup - no background threads to stop
-          restore_screen
-        end
-
         # Input methods using TTY::Prompt only - no background threads
         def get_user_input(prompt = "💬 You: ")
           @prompt.ask(prompt)
@@ -258,6 +248,12 @@ module Aidp
           @prompt.say("📝 #{message}", color: :cyan)
         end
 
+        def restore_screen
+          @cursor.show
+          @cursor.clear_screen
+          @cursor.move_to(1, 1)
+        end
+
         private
 
         def extract_questions_for_step(step_name)
@@ -284,20 +280,14 @@ module Aidp
           []
         end
 
-        def restore_screen
-          @cursor.show
-          @cursor.clear_screen
-          @cursor.move_to(1, 1)
-        end
-
         def setup_signal_handlers
           Signal.trap("INT") do
-            stop_display_loop
+            restore_screen
             exit(1)
           end
 
           Signal.trap("TERM") do
-            stop_display_loop
+            restore_screen
             exit(0)
           end
         end

data/lib/aidp/harness/ui/enhanced_workflow_selector.rb

@@ -86,24 +86,6 @@ module Aidp
           }
         end
 
-        # Legacy method - kept for backward compatibility if needed
-        def select_execute_workflow_interactive
-          # Step 1: Collect project information
-          collect_project_info_interactive
-
-          # Step 2: Choose workflow type
-          workflow_type = choose_workflow_type_interactive
-
-          # Step 3: Generate workflow steps
-          steps = generate_workflow_steps_interactive(workflow_type)
-
-          {
-            workflow_type: workflow_type,
-            steps: steps,
-            user_input: @user_input
-          }
-        end
-
         def select_analyze_workflow_defaults
           @tui.show_message("🚀 Starting analyze mode with default configuration...", :info)
 

data/lib/aidp/harness/ui/progress_display.rb

@@ -22,14 +22,18 @@ module Aidp
 
         def initialize(ui_components = {})
           super()
+          @output = ui_components[:output]
           @progress = ui_components[:progress] || TTY::ProgressBar
-          @pastel = Pastel.new
+          @pastel = if @output&.respond_to?(:tty?) && @output.tty?
+            Pastel.new(enabled: true)
+          else
+            Pastel.new(enabled: false)
+          end
           @formatter = ui_components[:formatter] || ProgressFormatter.new
           @display_history = []
           @auto_refresh_enabled = false
           @refresh_interval = 1.0
           @refresh_thread = nil
-          @output = ui_components[:output]
           @prompt = ui_components[:prompt] || TTY::Prompt.new
           @spinner_class = begin
             ui_components[:spinner] || TTY::Spinner

data/lib/aidp/harness/user_interface.rb

@@ -425,48 +425,6 @@ module Aidp
         display_message("\n🚀 Continuing execution...", type: :success)
       end
 
-      # Display question information (legacy method for compatibility)
-      def display_question_info(question_type, expected_input, options, default_value, required)
-        info_parts = []
-
-        # Question type
-        type_emojis = {
-          "text" => "📝",
-          "choice" => "🔘",
-          "confirmation" => "✅",
-          "file" => "📁",
-          "number" => "🔢",
-          "email" => "📧",
-          "url" => "🔗"
-        }
-        type_emoji = type_emojis[question_type] || "❓"
-        info_parts << "#{type_emoji} #{question_type.capitalize}"
-
-        # Expected input type
-        if expected_input != "text"
-          info_parts << "Expected: #{expected_input}"
-        end
-
-        # Options
-        if options && !options.empty?
-          info_parts << "Options: #{options.join(", ")}"
-        end
-
-        # Default value
-        if default_value
-          info_parts << "Default: #{default_value}"
-        end
-
-        # Required status
-        info_parts << if required
-          "Required: Yes"
-        else
-          "Required: No"
-        end
-
-        display_message("   #{info_parts.join(" | ")}", type: :info)
-      end
-
       # Get response for a specific question with enhanced validation
       def question_response(question_data, _question_number)
         question_type = question_data[:type] || "text"
@@ -1576,12 +1534,6 @@ module Aidp
         end
       end
 
-      # Find files matching search term (legacy method for compatibility)
-      def find_files(search_term)
-        search_options = parse_file_search_options(search_term)
-        find_files_advanced(search_options)
-      end
-
       # Display advanced file selection menu
       def display_advanced_file_menu(files, search_options)
         display_message("\n📁 Available files:", type: :info)
@@ -1659,11 +1611,6 @@ module Aidp
         end
       end
 
-      # Display file selection menu (legacy method for compatibility)
-      def display_file_menu(files)
-        display_advanced_file_menu(files, {term: "", extensions: [], directories: []})
-      end
-
       # Get advanced file selection from user
       def advanced_file_selection(max_files, _search_options)
         loop do
@@ -1763,11 +1710,6 @@ module Aidp
         @prompt.keypress("Press any key to continue...")
       end
 
-      # Get file selection from user (legacy method for compatibility)
-      def file_selection(max_files)
-        advanced_file_selection(max_files, {term: "", extensions: [], directories: []})
-      end
-
       # Get confirmation from user
       def confirmation(message, default: true)
         default_text = default ? "Y/n" : "y/N"

data/lib/aidp/init/runner.rb

@@ -337,8 +337,13 @@ module Aidp
           next unless tool_command
 
           # Check if command exists
-          unless system("which #{tool_command} > /dev/null 2>&1")
-            warnings << "   ⚠️  #{format_tool(tool_data[:tool])} detected but command '#{tool_command}' not found in PATH"
+          begin
+            unless system("which #{tool_command} > /dev/null 2>&1")
+              warnings << "   ⚠️  #{format_tool(tool_data[:tool])} detected but command '#{tool_command}' not found in PATH"
+            end
+          rescue IOError
+            # Streams may be closed in test environment - skip validation
+            Aidp.log_debug("init_runner", "skipping_tool_validation", tool: tool_command, reason: "closed_stream")
           end
         end
 

data/lib/aidp/message_display.rb

@@ -25,7 +25,6 @@ module Aidp
 
     # Instance helper for displaying a colored message via TTY::Prompt
     def display_message(message, type: :info)
-      return if suppress_display_message?(message)
       # Ensure message is UTF-8 encoded to handle emoji and special characters
       message_str = message.to_s
       message_str = message_str.force_encoding("UTF-8") if message_str.encoding.name == "ASCII-8BIT"
@@ -43,32 +42,9 @@ module Aidp
       end
     end
 
-    # Check if specific display message should be suppressed in test/CI environments
-    def suppress_display_message?(message)
-      return false unless in_test_environment?
-
-      message_str = message.to_s
-      # Only suppress specific automated status messages, not CLI output
-      message_str.include?("🔄 Provider switch:") ||
-        message_str.include?("🔄 Model switch:") ||
-        message_str.include?("🔴 Circuit breaker opened") ||
-        message_str.include?("🟢 Circuit breaker reset") ||
-        message_str.include?("❌ No providers available") ||
-        message_str.include?("❌ No models available") ||
-        message_str.include?("📊 Execution Summary") ||
-        message_str.include?("▶️  [") ||  # Workstream execution messages
-        message_str.include?("✅ [") ||    # Workstream success messages
-        message_str.include?("❌ [")       # Workstream failure messages
-    end
-
-    def in_test_environment?
-      ENV["RSPEC_RUNNING"] || ENV["CI"] || ENV["RAILS_ENV"] == "test" || ENV["RACK_ENV"] == "test"
-    end
-
     module ClassMethods
       # Class-level display helper (uses fresh prompt to respect $stdout changes)
       def display_message(message, type: :info)
-        return if suppress_display_message?(message)
         # Ensure message is UTF-8 encoded to handle emoji and special characters
         message_str = message.to_s
         message_str = message_str.force_encoding("UTF-8") if message_str.encoding.name == "ASCII-8BIT"
@@ -78,28 +54,6 @@ module Aidp
 
       private
 
-      # Check if specific display message should be suppressed in test/CI environments
-      def suppress_display_message?(message)
-        return false unless in_test_environment?
-
-        message_str = message.to_s
-        # Only suppress specific automated status messages, not CLI output
-        message_str.include?("🔄 Provider switch:") ||
-          message_str.include?("🔄 Model switch:") ||
-          message_str.include?("🔴 Circuit breaker opened") ||
-          message_str.include?("🟢 Circuit breaker reset") ||
-          message_str.include?("❌ No providers available") ||
-          message_str.include?("❌ No models available") ||
-          message_str.include?("📊 Execution Summary") ||
-          message_str.include?("▶️  [") ||  # Workstream execution messages
-          message_str.include?("✅ [") ||    # Workstream success messages
-          message_str.include?("❌ [")       # Workstream failure messages
-      end
-
-      def in_test_environment?
-        ENV["RSPEC_RUNNING"] || ENV["CI"] || ENV["RAILS_ENV"] == "test" || ENV["RACK_ENV"] == "test"
-      end
-
       # Don't memoize - create fresh prompt each time to respect $stdout redirection in tests
       def class_message_display_prompt
         TTY::Prompt.new