aidp 0.26.0 → 0.27.0

data/lib/aidp/execute/checkpoint_display.rb

@@ -8,17 +8,18 @@ module Aidp
     class CheckpointDisplay
       include Aidp::MessageDisplay
 
-      def initialize
+      def initialize(prompt: nil)
         @pastel = Pastel.new
+        @prompt = prompt || TTY::Prompt.new
       end
 
       # Display a checkpoint during work loop iteration
       def display_checkpoint(checkpoint_data, show_details: false)
         return unless checkpoint_data
 
-        puts
-        puts @pastel.bold("📊 Checkpoint - Iteration #{checkpoint_data[:iteration]}")
-        puts @pastel.dim("─" * 60)
+        @prompt.say("")
+        @prompt.say(@pastel.bold("📊 Checkpoint - Iteration #{checkpoint_data[:iteration]}"))
+        @prompt.say(@pastel.dim("─" * 60))
 
         display_metrics(checkpoint_data[:metrics])
         display_status(checkpoint_data[:status])
@@ -27,52 +28,52 @@ module Aidp
           display_trends(checkpoint_data[:trends]) if checkpoint_data[:trends]
         end
 
-        puts @pastel.dim("─" * 60)
-        puts
+        @prompt.say(@pastel.dim("─" * 60))
+        @prompt.say("")
       end
 
       # Display progress summary with trends
       def display_progress_summary(summary)
         return unless summary
 
-        puts
-        puts @pastel.bold("📈 Progress Summary")
-        puts @pastel.dim("=" * 60)
+        @prompt.say("")
+        @prompt.say(@pastel.bold("📈 Progress Summary"))
+        @prompt.say(@pastel.dim("=" * 60))
 
         current = summary[:current]
-        puts "Step: #{@pastel.cyan(current[:step_name])}"
-        puts "Iteration: #{current[:iteration]}"
-        puts "Status: #{format_status(current[:status])}"
-        puts
+        @prompt.say("Step: #{@pastel.cyan(current[:step_name])}")
+        @prompt.say("Iteration: #{current[:iteration]}")
+        @prompt.say("Status: #{format_status(current[:status])}")
+        @prompt.say("")
 
-        puts @pastel.bold("Current Metrics:")
+        @prompt.say(@pastel.bold("Current Metrics:"))
         display_metrics(current[:metrics])
 
         if summary[:trends]
-          puts
-          puts @pastel.bold("Trends:")
+          @prompt.say("")
+          @prompt.say(@pastel.bold("Trends:"))
           display_trends(summary[:trends])
         end
 
         if summary[:quality_score]
-          puts
+          @prompt.say("")
           display_quality_score(summary[:quality_score])
         end
 
-        puts @pastel.dim("=" * 60)
-        puts
+        @prompt.say(@pastel.dim("=" * 60))
+        @prompt.say("")
       end
 
       # Display checkpoint history as a table
       def display_checkpoint_history(history, limit: 10)
         return if history.empty?
 
-        puts
-        puts @pastel.bold("📜 Checkpoint History (Last #{[limit, history.size].min})")
-        puts @pastel.dim("=" * 80)
+        @prompt.say("")
+        @prompt.say(@pastel.bold("📜 Checkpoint History (Last #{[limit, history.size].min})"))
+        @prompt.say(@pastel.dim("=" * 80))
 
         # Table header
-        puts format_table_row([
+        @prompt.say(format_table_row([
           "Iteration",
           "Time",
           "LOC",
@@ -80,15 +81,15 @@ module Aidp
           "Quality",
           "PRD Progress",
           "Status"
-        ], header: true)
-        puts @pastel.dim("-" * 80)
+        ], header: true))
+        @prompt.say(@pastel.dim("-" * 80))
 
         # Table rows
         history.last(limit).each do |checkpoint|
           metrics = checkpoint[:metrics]
           timestamp = Time.parse(checkpoint[:timestamp]).strftime("%H:%M:%S")
 
-          puts format_table_row([
+          @prompt.say(format_table_row([
             checkpoint[:iteration].to_s,
             timestamp,
             metrics[:lines_of_code].to_s,
@@ -96,11 +97,11 @@ module Aidp
             "#{metrics[:code_quality]}%",
             "#{metrics[:prd_task_progress]}%",
             format_status(checkpoint[:status])
-          ])
+          ]))
         end
 
-        puts @pastel.dim("=" * 80)
-        puts
+        @prompt.say(@pastel.dim("=" * 80))
+        @prompt.say("")
       end
 
       # Display inline progress indicator (for work loop)
@@ -124,15 +125,15 @@ module Aidp
       private
 
       def display_metrics(metrics)
-        puts "  Lines of Code: #{@pastel.yellow(metrics[:lines_of_code].to_s)}"
-        puts "  Test Coverage: #{format_percentage_with_color(metrics[:test_coverage])}"
-        puts "  Code Quality: #{format_percentage_with_color(metrics[:code_quality])}"
-        puts "  PRD Task Progress: #{format_percentage_with_color(metrics[:prd_task_progress])}"
-        puts "  File Count: #{metrics[:file_count]}"
+        @prompt.say("  Lines of Code: #{@pastel.yellow(metrics[:lines_of_code].to_s)}")
+        @prompt.say("  Test Coverage: #{format_percentage_with_color(metrics[:test_coverage])}")
+        @prompt.say("  Code Quality: #{format_percentage_with_color(metrics[:code_quality])}")
+        @prompt.say("  PRD Task Progress: #{format_percentage_with_color(metrics[:prd_task_progress])}")
+        @prompt.say("  File Count: #{metrics[:file_count]}")
       end
 
       def display_status(status)
-        puts "  Overall Status: #{format_status(status)}"
+        @prompt.say("  Overall Status: #{format_status(status)}")
       end
 
       def format_status(status)
@@ -156,7 +157,7 @@ module Aidp
           arrow = trend_arrow(trend_data[:direction])
           change = format_change(trend_data[:change], trend_data[:change_percent])
 
-          puts "  #{metric_name}: #{arrow} #{change}"
+          @prompt.say("  #{metric_name}: #{arrow} #{change}")
         end
       end
 
@@ -185,7 +186,7 @@ module Aidp
           :red
         end
 
-        puts "  Quality Score: #{@pastel.send(color, "#{score.round(2)}%")}"
+        @prompt.say("  Quality Score: #{@pastel.send(color, "#{score.round(2)}%")}")
       end
 
       def format_percentage(value)

data/lib/aidp/execute/interactive_repl.rb

@@ -29,6 +29,7 @@ module Aidp
         @config = config
         @options = options
         @prompt = options[:prompt] || TTY::Prompt.new
+        @async_runner_class = options[:async_runner_class] || AsyncWorkLoopRunner
         @async_runner = nil
         @repl_macros = ReplMacros.new
         @output_display_thread = nil
@@ -38,7 +39,7 @@ module Aidp
 
       # Start work loop and enter interactive REPL
       def start_work_loop(step_name, step_spec, context = {})
-        @async_runner = AsyncWorkLoopRunner.new(
+        @async_runner = @async_runner_class.new(
           @project_dir,
           @provider_manager,
           @config,

data/lib/aidp/execute/prompt_manager.rb

@@ -17,20 +17,20 @@ module Aidp
 
       attr_reader :optimizer, :last_optimization_stats
 
-      def initialize(project_dir, config: nil)
+      def initialize(project_dir, config: nil, optimizer: nil)
         @project_dir = project_dir
         @aidp_dir = File.join(project_dir, ".aidp")
         @prompt_path = File.join(@aidp_dir, PROMPT_FILENAME)
         @archive_dir = File.join(project_dir, ARCHIVE_DIR)
         @config = config
-        @optimizer = nil
+        @optimizer = optimizer
         @last_optimization_stats = nil
 
         # Ensure .aidp directory exists
         FileUtils.mkdir_p(@aidp_dir)
 
-        # Initialize optimizer if enabled
-        if config&.respond_to?(:prompt_optimization_enabled?) && config.prompt_optimization_enabled?
+        # Initialize optimizer if enabled and not provided
+        if @optimizer.nil? && config&.respond_to?(:prompt_optimization_enabled?) && config.prompt_optimization_enabled?
           @optimizer = Aidp::PromptOptimization::Optimizer.new(
             project_dir: project_dir,
             config: config.prompt_optimization_config

data/lib/aidp/execute/work_loop_runner.rb

@@ -8,6 +8,7 @@ require_relative "work_loop_unit_scheduler"
 require_relative "deterministic_unit"
 require_relative "agent_signal_parser"
 require_relative "../harness/test_runner"
+require_relative "../errors"
 
 module Aidp
   module Execute
@@ -46,10 +47,11 @@ module Aidp
         @project_dir = project_dir
         @provider_manager = provider_manager
         @config = config
+        @prompt = options[:prompt] || TTY::Prompt.new
         @prompt_manager = PromptManager.new(project_dir, config: config)
         @test_runner = Aidp::Harness::TestRunner.new(project_dir, config)
         @checkpoint = Checkpoint.new(project_dir)
-        @checkpoint_display = CheckpointDisplay.new
+        @checkpoint_display = CheckpointDisplay.new(prompt: @prompt)
         @guard_policy = GuardPolicy.new(project_dir, config.guards_config)
         @persistent_tasklist = PersistentTasklist.new(project_dir)
         @iteration_count = 0
@@ -62,7 +64,7 @@ module Aidp
 
         # Initialize thinking depth manager for intelligent model selection
         require_relative "../harness/thinking_depth_manager"
-        @thinking_depth_manager = Aidp::Harness::ThinkingDepthManager.new(config)
+        @thinking_depth_manager = options[:thinking_depth_manager] || Aidp::Harness::ThinkingDepthManager.new(config)
         @consecutive_failures = 0
         @last_tier = nil
       end
@@ -160,6 +162,10 @@ module Aidp
           # Wrap agent call in exception handling for true fix-forward
           begin
             agent_result = apply_patch
+          rescue Aidp::Errors::ConfigurationError
+            # Configuration errors should crash immediately (crash-early principle)
+            # Re-raise without catching
+            raise
           rescue => e
             # Convert exception to error result for fix-forward handling
             Aidp.logger.error("work_loop", "Exception during agent call",
@@ -178,6 +184,27 @@ module Aidp
             next
           end
 
+          # Check for fatal configuration errors (crash early per LLM_STYLE_GUIDE)
+          if agent_result[:status] == "error" && agent_result[:message]&.include?("No model available")
+            tier = @thinking_depth_manager.current_tier
+            provider = @provider_manager.current_provider
+
+            error_msg = "No model configured for thinking tier '#{tier}'.\n\n" \
+                       "Current provider: #{provider}\n" \
+                       "Required tier: #{tier}\n\n" \
+                       "To fix this, add a model to your aidp.yml:\n\n" \
+                       "thinking_depth:\n" \
+                       "  tiers:\n" \
+                       "    #{tier}:\n" \
+                       "      models:\n" \
+                       "        - provider: #{provider}\n" \
+                       "          model: <model-name>  # e.g., claude-3-5-sonnet-20241022\n\n" \
+                       "Or run: aidp models list\n" \
+                       "to see available models for your configured providers."
+
+            raise Aidp::Errors::ConfigurationError, error_msg
+          end
+
           # Process agent output for task filing signals
           process_task_filing(agent_result)
 

data/lib/aidp/execute/workflow_selector.rb

@@ -10,10 +10,10 @@ module Aidp
     class WorkflowSelector
       include Aidp::MessageDisplay
 
-      def initialize(prompt: TTY::Prompt.new)
+      def initialize(prompt: TTY::Prompt.new, workflow_selector: nil)
         @user_input = {}
         @prompt = prompt
-        @workflow_selector = Aidp::Workflows::Selector.new(prompt: @prompt)
+        @workflow_selector = workflow_selector || Aidp::Workflows::Selector.new(prompt: @prompt)
       end
 
       # Main entry point for interactive workflow selection

data/lib/aidp/harness/config_manager.rb

@@ -359,19 +359,19 @@ module Aidp
       def load_config_with_options(options)
         # Apply different loading strategies based on options
         if options[:mode]
-          @loader.get_mode_config(options[:mode], options[:force_reload])
+          @loader.mode_config(options[:mode], options[:force_reload])
         elsif options[:environment]
-          @loader.get_environment_config(options[:environment], options[:force_reload])
+          @loader.environment_config(options[:environment], options[:force_reload])
         elsif options[:step]
           @loader.get_step_config(options[:step], options[:force_reload])
         elsif options[:features]
-          @loader.get_config_with_features(options[:features], options[:force_reload])
+          @loader.config_with_features(options[:features], options[:force_reload])
         elsif options[:user]
           @loader.get_user_config(options[:user], options[:force_reload])
         elsif options[:time_based]
-          @loader.get_time_based_config(options[:force_reload])
+          @loader.time_based_config(options[:force_reload])
         elsif options[:overrides]
-          @loader.get_config_with_overrides(options[:overrides])
+          @loader.config_with_overrides(options[:overrides])
         else
           @loader.load_config(options[:force_reload])
         end

data/lib/aidp/harness/configuration.rb

@@ -383,12 +383,12 @@ module Aidp
 
       # Get default thinking tier
       def default_tier
-        thinking_config[:default_tier] || "standard"
+        thinking_config[:default_tier] || default_thinking_config[:default_tier]
       end
 
       # Get maximum thinking tier
       def max_tier
-        thinking_config[:max_tier] || "standard"
+        thinking_config[:max_tier] || default_thinking_config[:max_tier]
       end
 
       # Check if provider switching for tier is allowed
@@ -432,6 +432,36 @@ 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] || {}
+      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]
+        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
+      end
+
+      # Get all configured tiers
+      def configured_tiers
+        thinking_tiers_config.keys.map(&:to_s)
+      end
+
       # Get fallback configuration
       def fallback_config
         harness_config[:fallback] || default_fallback_config

data/lib/aidp/harness/enhanced_runner.rb

@@ -6,6 +6,7 @@ require_relative "ui/job_monitor"
 require_relative "ui/workflow_controller"
 require_relative "ui/progress_display"
 require_relative "ui/status_widget"
+require_relative "../errors"
 
 module Aidp
   module Harness
@@ -47,27 +48,31 @@ module Aidp
         @selected_steps = options[:selected_steps] || []
         @workflow_type = options[:workflow_type] || :default
 
-        # Initialize enhanced TUI components
-        @tui = UI::EnhancedTUI.new
-        @workflow_selector = UI::EnhancedWorkflowSelector.new(@tui)
-        @job_monitor = UI::JobMonitor.new
-        @workflow_controller = UI::WorkflowController.new
-        @progress_display = UI::ProgressDisplay.new
-        @status_widget = UI::StatusWidget.new
+        # Initialize enhanced TUI components (with dependency injection)
+        @tui = options[:tui] || UI::EnhancedTUI.new
+        @workflow_selector = options[:workflow_selector] || UI::EnhancedWorkflowSelector.new(@tui)
+        @job_monitor = options[:job_monitor] || UI::JobMonitor.new
+        @workflow_controller = options[:workflow_controller] || UI::WorkflowController.new
+        @progress_display = options[:progress_display] || UI::ProgressDisplay.new
+        @status_widget = options[:status_widget] || UI::StatusWidget.new
 
-        # Initialize other components
-        @configuration = Configuration.new(project_dir)
-        @state_manager = StateManager.new(project_dir, @mode)
-        @provider_manager = ProviderManager.new(@configuration, prompt: @prompt)
+        # Initialize other components (with dependency injection)
+        @configuration = options[:configuration] || Configuration.new(project_dir)
+        @state_manager = options[:state_manager] || StateManager.new(project_dir, @mode)
+        @provider_manager = options[:provider_manager] || ProviderManager.new(@configuration, prompt: @prompt)
 
         # Use ZFC-enabled condition detector
         # ZfcConditionDetector will create its own ProviderFactory if needed
         # Falls back to legacy pattern matching when ZFC is disabled
-        require_relative "zfc_condition_detector"
-        @condition_detector = ZfcConditionDetector.new(@configuration)
+        if options[:condition_detector]
+          @condition_detector = options[:condition_detector]
+        else
+          require_relative "zfc_condition_detector"
+          @condition_detector = ZfcConditionDetector.new(@configuration)
+        end
 
-        @error_handler = ErrorHandler.new(@provider_manager, @configuration)
-        @completion_checker = CompletionChecker.new(@project_dir, @workflow_type)
+        @error_handler = options[:error_handler] || ErrorHandler.new(@provider_manager, @configuration)
+        @completion_checker = options[:completion_checker] || CompletionChecker.new(@project_dir, @workflow_type)
       end
 
       # Get current provider (delegate to provider manager)
@@ -158,6 +163,10 @@ module Aidp
               handle_completion_criteria_not_met(completion_status)
             end
           end
+        rescue Aidp::Errors::ConfigurationError
+          # Configuration errors should crash immediately (crash-early principle)
+          # Re-raise without catching
+          raise
         rescue => e
           @state = STATES[:error]
           # Single error message - don't duplicate

data/lib/aidp/harness/error_handler.rb

@@ -4,6 +4,7 @@ require "net/http"
 require_relative "../debug_mixin"
 require_relative "../concurrency"
 require_relative "../providers/error_taxonomy"
+require_relative "../errors"
 
 module Aidp
   module Harness
@@ -107,6 +108,10 @@ module Aidp
           begin
             attempt += 1
             return yield
+          rescue Aidp::Errors::ConfigurationError
+            # Configuration errors should crash immediately (crash-early principle)
+            # Re-raise without catching
+            raise
           rescue => error
             current_provider = current_provider_safely
 
@@ -483,7 +488,7 @@ module Aidp
         }
       end
 
-      def attempt_provider_switch(error_info, _recovery_plan)
+      def attempt_provider_switch(error_info, recovery_plan)
         new_provider = @provider_manager.switch_provider_for_error(
           error_info[:error_type],
           error_info[:context]
@@ -497,6 +502,18 @@ module Aidp
             reason: "Error recovery: #{error_info[:error_type]}"
           }
         else
+          # If this is an auth error and we have no fallback providers, crash
+          if recovery_plan[:crash_if_no_fallback]
+            error_msg = "All providers have failed authentication.\n\n" \
+                       "Last provider: #{error_info[:provider]}\n" \
+                       "Error: #{error_info[:error]&.message || error_info[:error]}\n\n" \
+                       "Please check your API credentials for all configured providers.\n" \
+                       "Run 'aidp config --interactive' to update credentials."
+
+            raise Aidp::Errors::ConfigurationError, error_msg
+          end
+
+          # For non-auth errors, return failure result
           {
             success: false,
             action: :provider_switch_failed,
@@ -680,12 +697,13 @@ module Aidp
               priority: :high
             }
           when :auth_expired
-            # Attempt a provider switch so workflows can continue with alternate providers
-            # while the user resolves credentials for the failing provider
+            # 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 expired – switching provider to continue",
-              priority: :critical
+              priority: :critical,
+              crash_if_no_fallback: true
             }
           when :quota_exceeded
             {
@@ -725,10 +743,13 @@ module Aidp
               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
+              priority: :critical,
+              crash_if_no_fallback: true
             }
           when :rate_limit
             {