aidp 0.27.0 → 0.28.0

data/lib/aidp/harness/configuration.rb

@@ -166,6 +166,11 @@ module Aidp
         work_loop_config[:max_iterations]
       end
 
+      # Check if task completion is required for work loop completion
+      def task_completion_required?
+        work_loop_config.fetch(:task_completion_required, true)
+      end
+
       # Get test commands
       def test_commands
         normalize_commands(work_loop_config[:test_commands] || [])
@@ -432,34 +437,37 @@ module Aidp
         thinking_overrides[key] || thinking_overrides[key.to_sym]
       end
 
-      # Get tiers configuration from user's config
-      def thinking_tiers_config
-        thinking_config[:tiers] || {}
+      # Get thinking tiers configuration for a specific provider
+      # @param provider_name [String] The provider name
+      # @return [Hash] The thinking tiers configuration for the provider
+      def provider_thinking_tiers(provider_name)
+        provider_cfg = provider_config(provider_name)
+        provider_cfg[:thinking_tiers] || provider_cfg["thinking_tiers"] || {}
       end
 
-      # Get models configured for a specific tier
-      # Returns array of {provider:, model:} hashes
-      def models_for_tier(tier)
-        tier_config = thinking_tiers_config[tier] || thinking_tiers_config[tier.to_sym]
+      # Get models configured for a specific tier and provider
+      # @param tier [String, Symbol] The tier name (mini, standard, thinking, pro, max)
+      # @param provider_name [String] The provider name (required)
+      # @return [Array<String>] Array of model names for the tier
+      def models_for_tier(tier, provider_name)
+        return [] unless provider_name
+
+        tier_config = provider_thinking_tiers(provider_name)[tier] ||
+          provider_thinking_tiers(provider_name)[tier.to_sym]
         return [] unless tier_config
 
         models = tier_config[:models] || tier_config["models"]
         return [] unless models
 
-        # Normalize to array of hashes with symbol keys
-        Array(models).map do |model_entry|
-          if model_entry.is_a?(Hash)
-            {
-              provider: (model_entry[:provider] || model_entry["provider"]).to_s,
-              model: (model_entry[:model] || model_entry["model"]).to_s
-            }
-          end
-        end.compact
+        # Return simple array of model name strings
+        Array(models).map(&:to_s).compact
       end
 
-      # Get all configured tiers
-      def configured_tiers
-        thinking_tiers_config.keys.map(&:to_s)
+      # Get all configured tiers for a provider
+      # @param provider_name [String] The provider name
+      # @return [Array<String>] Array of tier names
+      def configured_tiers(provider_name)
+        provider_thinking_tiers(provider_name).keys.map(&:to_s)
       end
 
       # Get fallback configuration

data/lib/aidp/harness/enhanced_runner.rb

@@ -106,9 +106,6 @@ module Aidp
         @tui.show_message("🚀 Starting #{@mode.to_s.capitalize} Mode", :info)
 
         begin
-          # Start TUI display loop
-          @tui.start_display_loop
-
           # Load existing state if resuming
           # Temporarily disabled to test
           # load_state if @state_manager.has_state?
@@ -174,7 +171,7 @@ module Aidp
         ensure
           # Save state before exiting
           save_state
-          @tui.stop_display_loop
+          @tui.restore_screen
           cleanup
         end
 

data/lib/aidp/harness/error_handler.rb

@@ -81,7 +81,7 @@ 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)
+          if error_info[:error_type].to_sym == :auth_expired
             # Mark provider unhealthy to avoid immediate re-selection
             begin
               if @provider_manager.respond_to?(:mark_provider_auth_failure)
@@ -399,43 +399,6 @@ module Aidp
             jitter: false
           },
 
-          # Legacy aliases for backward compatibility
-          network_error: {
-            name: "network_error",
-            enabled: true,
-            max_retries: 3,
-            backoff_strategy: :exponential,
-            base_delay: 1.0,
-            max_delay: 30.0,
-            jitter: true
-          },
-          server_error: {
-            name: "server_error",
-            enabled: true,
-            max_retries: 2,
-            backoff_strategy: :linear,
-            base_delay: 2.0,
-            max_delay: 10.0,
-            jitter: true
-          },
-          timeout: {
-            name: "timeout",
-            enabled: true,
-            max_retries: 2,
-            backoff_strategy: :exponential,
-            base_delay: 1.0,
-            max_delay: 15.0,
-            jitter: true
-          },
-          rate_limit: {
-            name: "rate_limit",
-            enabled: false,
-            max_retries: 0,
-            backoff_strategy: :none,
-            base_delay: 0.0,
-            max_delay: 0.0,
-            jitter: false
-          },
           authentication: {
             name: "authentication",
             enabled: false,
@@ -723,40 +686,6 @@ module Aidp
               reason: "Permanent error, requires manual intervention",
               priority: :critical
             }
-          # Legacy error type mappings for backward compatibility
-          when :timeout
-            {
-              action: :switch_model,
-              reason: "Timeout error, trying faster model",
-              priority: :medium
-            }
-          when :network_error
-            {
-              action: :switch_provider,
-              reason: "Network error, switching provider",
-              priority: :medium
-            }
-          when :server_error
-            {
-              action: :switch_provider,
-              reason: "Server error, switching provider",
-              priority: :medium
-            }
-          when :authentication, :permission_denied
-            # Try to switch to another provider. If no providers available, this will
-            # be detected in attempt_recovery and we'll crash (crash-early principle)
-            {
-              action: :switch_provider,
-              reason: "Authentication/permission issue – switching provider to continue",
-              priority: :critical,
-              crash_if_no_fallback: true
-            }
-          when :rate_limit
-            {
-              action: :switch_provider,
-              reason: "Rate limit reached, switching provider",
-              priority: :high
-            }
           else
             {
               action: :switch_provider,

data/lib/aidp/harness/provider_factory.rb

@@ -9,6 +9,7 @@ require_relative "../providers/opencode"
 require_relative "../providers/kilocode"
 require_relative "../providers/github_copilot"
 require_relative "../providers/codex"
+require_relative "../providers/aider"
 
 module Aidp
   module Harness
@@ -22,7 +23,8 @@ module Aidp
         "opencode" => Aidp::Providers::Opencode,
         "kilocode" => Aidp::Providers::Kilocode,
         "github_copilot" => Aidp::Providers::GithubCopilot,
-        "codex" => Aidp::Providers::Codex
+        "codex" => Aidp::Providers::Codex,
+        "aider" => Aidp::Providers::Aider
       }.freeze
 
       def initialize(config_manager = nil)
@@ -240,8 +242,15 @@ module Aidp
 
       def configure_provider(provider_instance, provider_config, options)
         # Set basic configuration
+        config_hash = provider_config.config(options).dup
+
+        # Add model to config if specified in options
+        if options[:model]
+          config_hash[:model] = options[:model]
+        end
+
         if provider_instance.respond_to?(:configure)
-          provider_instance.configure(provider_config.config(options))
+          provider_instance.configure(config_hash)
         end
 
         # Set harness context if available

data/lib/aidp/harness/state_manager.rb

@@ -103,13 +103,6 @@ module Aidp
         save_state(updated_state)
       end
 
-      # Get current step from state (legacy method - use progress tracker integration instead)
-      def current_step_from_state
-        state = load_state
-        return nil unless state
-        state[:current_step]
-      end
-
       # Set current step
       def set_current_step(step_name)
         update_state(current_step: step_name, last_updated: Time.now)

data/lib/aidp/harness/thinking_depth_manager.rb

@@ -153,40 +153,32 @@ module Aidp
         tier ||= current_tier
         validate_tier!(tier)
 
-        # First, try to get models from user's configuration for this tier
-        configured_models = configuration.models_for_tier(tier)
-
-        if configured_models.any?
-          # If provider specified, try to find model for that provider in config
-          if provider
-            matching_model = configured_models.find { |m| m[:provider] == provider }
-            if matching_model
-              Aidp.log_debug("thinking_depth_manager", "Selected model from user config",
-                tier: tier,
-                provider: provider,
-                model: matching_model[:model])
-              return [matching_model[:provider], matching_model[:model], {}]
-            end
-
-            # If provider doesn't support tier and switching allowed, try other providers in config
-            unless configuration.allow_provider_switch_for_tier?
-              Aidp.log_warn("thinking_depth_manager", "Provider lacks tier in config, switching disabled",
-                tier: tier,
-                provider: provider)
-              return nil
-            end
-          end
+        # First, try to get models from user's configuration for this tier and provider
+        if provider
+          configured_models = configuration.models_for_tier(tier, provider)
 
-          # Try any configured model for this tier (prioritize first in list)
-          first_model = configured_models.first
-          if first_model
-            Aidp.log_info("thinking_depth_manager", "Selected model from user config",
+          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,
-              original_provider: provider,
-              selected_provider: first_model[:provider],
-              model: first_model[:model])
-            return [first_model[:provider], first_model[:model], {}]
+              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
@@ -396,37 +388,22 @@ module Aidp
         fallback_tiers = generate_fallback_tier_order(requested_tier)
 
         fallback_tiers.each do |fallback_tier|
-          # First, try user's configuration for this fallback tier
-          configured_models = configuration.models_for_tier(fallback_tier)
-
-          if configured_models.any?
-            # Try specified provider first if given
-            if provider
-              matching_model = configured_models.find { |m| m[:provider] == provider }
-              if matching_model
-                Aidp.log_warn("thinking_depth_manager", "Falling back to different tier (from config)",
-                  requested_tier: requested_tier,
-                  fallback_tier: fallback_tier,
-                  provider: provider,
-                  model: matching_model[:model])
-                return [matching_model[:provider], matching_model[:model], {}]
-              end
-            end
+          # First, try user's configuration for this fallback tier and provider
+          if provider
+            configured_models = configuration.models_for_tier(fallback_tier, provider)
 
-            # Try any configured model for this tier
-            first_model = configured_models.first
-            if first_model
-              Aidp.log_warn("thinking_depth_manager", "Falling back to different tier and provider (from config)",
+            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,
-                requested_provider: provider,
-                fallback_provider: first_model[:provider],
-                model: first_model[:model])
-              return [first_model[:provider], first_model[:model], {}]
+                provider: provider,
+                model: model_name)
+              return [provider, model_name, {}]
             end
           end
 
-          # Fall back to catalog if no models in config
+          # 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)
@@ -440,19 +417,21 @@ module Aidp
             end
           end
 
-          # Try all available providers in catalog
-          @registry.provider_names.each do |prov_name|
-            next if prov_name == provider # Skip if already tried above
+          # 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]
+              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

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