aidp 0.26.0 → 0.28.0

data/lib/aidp/harness/ai_decision_engine.rb

@@ -157,6 +157,36 @@ module Aidp
           },
           default_tier: "mini",
           cache_ttl: nil
+        },
+
+        implementation_verification: {
+          prompt_template: "{{prompt}}",  # Custom prompt provided by caller
+          schema: {
+            type: "object",
+            properties: {
+              fully_implemented: {
+                type: "boolean",
+                description: "True if the implementation fully addresses all issue requirements"
+              },
+              reasoning: {
+                type: "string",
+                description: "Detailed explanation of the verification decision"
+              },
+              missing_requirements: {
+                type: "array",
+                items: {type: "string"},
+                description: "List of specific requirements from the issue that are not yet implemented"
+              },
+              additional_work_needed: {
+                type: "array",
+                items: {type: "string"},
+                description: "List of specific tasks needed to complete the implementation"
+              }
+            },
+            required: ["fully_implemented", "reasoning", "missing_requirements", "additional_work_needed"]
+          },
+          default_tier: "mini",
+          cache_ttl: nil
         }
       }.freeze
 
@@ -204,9 +234,12 @@ module Aidp
         # Select tier
         selected_tier = tier || template[:default_tier]
 
-        # Get model for tier
+        # Get model for tier, using harness default provider
         thinking_manager = ThinkingDepthManager.new(config)
-        provider_name, model_name, _model_data = thinking_manager.select_model_for_tier(selected_tier)
+        provider_name, model_name, _model_data = thinking_manager.select_model_for_tier(
+          selected_tier,
+          provider: config.default_provider
+        )
 
         Aidp.log_debug("ai_decision_engine", "Making AI decision", {
           decision_type: decision_type,

data/lib/aidp/harness/config_manager.rb

@@ -103,11 +103,6 @@ module Aidp
         }
       end
 
-      # Get max retries (alias for backward compatibility with ErrorHandler)
-      def max_retries(options = {})
-        retry_config(options)[:max_attempts]
-      end
-
       # Get circuit breaker configuration
       def circuit_breaker_config(options = {})
         harness_config = harness_config(options)
@@ -359,19 +354,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/config_schema.rb

@@ -378,6 +378,7 @@ module Aidp
                 formatter_commands: [],
                 build_commands: [],
                 documentation_commands: [],
+                task_completion_required: true,
                 units: {},
                 guards: {enabled: false},
                 version_control: {tool: "git", behavior: "nothing", conventional_commits: false},
@@ -432,6 +433,13 @@ module Aidp
                   # Items can be strings or {command: string, required: boolean}
                   # Validation handled in Configuration class for flexibility
                 },
+                task_completion_required: {
+                  type: :boolean,
+                  required: false,
+                  default: true
+                  # When true, all tasks for the current session must be completed or
+                  # explicitly abandoned (with user confirmation) before work loop can finish
+                },
                 units: {
                   type: :hash,
                   required: false,

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] || [])
@@ -383,12 +388,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 +437,39 @@ module Aidp
         thinking_overrides[key] || thinking_overrides[key.to_sym]
       end
 
+      # 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 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
+
+        # Return simple array of model name strings
+        Array(models).map(&:to_s).compact
+      end
+
+      # 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
       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)
@@ -101,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?
@@ -158,6 +160,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
@@ -165,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

@@ -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
@@ -80,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)
@@ -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
 
@@ -394,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,
@@ -483,7 +451,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 +465,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 +660,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
             {
@@ -705,37 +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
-            {
-              action: :switch_provider,
-              reason: "Authentication/permission issue – switching provider to continue",
-              priority: :critical
-            }
-          when :rate_limit
-            {
-              action: :switch_provider,
-              reason: "Rate limit reached, switching provider",
-              priority: :high
-            }
           else
             {
               action: :switch_provider,

data/lib/aidp/harness/model_cache.rb

@@ -0,0 +1,269 @@
+# frozen_string_literal: true
+
+require "json"
+require "fileutils"
+
+module Aidp
+  module Harness
+    # Manages caching of discovered models with TTL support
+    #
+    # Cache is stored in ~/.aidp/cache/models.json
+    # Each provider's models are cached separately with timestamps
+    #
+    # Usage:
+    #   cache = ModelCache.new
+    #   cache.cache_models("anthropic", models_array)
+    #   cached = cache.get_cached_models("anthropic")
+    #   cache.invalidate("anthropic")
+    class ModelCache
+      class CacheError < StandardError; end
+
+      DEFAULT_TTL = 86400 # 24 hours in seconds
+
+      attr_reader :cache_file
+
+      def initialize(cache_file: nil, cache_dir: nil)
+        @cache_file = determine_cache_file(cache_file, cache_dir)
+        @cache_enabled = ensure_cache_directory
+
+        if @cache_enabled
+          Aidp.log_debug("model_cache", "initialized", cache_file: @cache_file)
+        else
+          Aidp.log_warn("model_cache", "cache disabled due to permission issues")
+        end
+      end
+
+      # Get cached models for a provider if not expired
+      #
+      # @param provider [String] Provider name
+      # @return [Array<Hash>, nil] Cached models or nil if expired/not found
+      def get_cached_models(provider)
+        cache_data = load_cache
+        provider_cache = cache_data[provider]
+
+        return nil unless provider_cache
+
+        cached_at = begin
+          Time.parse(provider_cache["cached_at"])
+        rescue
+          nil
+        end
+        return nil unless cached_at
+
+        ttl = provider_cache["ttl"] || DEFAULT_TTL
+        expires_at = cached_at + ttl
+
+        if Time.now > expires_at
+          Aidp.log_debug("model_cache", "cache expired",
+            provider: provider, cached_at: cached_at, expires_at: expires_at)
+          return nil
+        end
+
+        models = provider_cache["models"]
+        # Convert string keys to symbols for consistency with fresh discovery
+        models = models.map { |m| m.transform_keys(&:to_sym) } if models
+        Aidp.log_debug("model_cache", "cache hit",
+          provider: provider, count: models&.size || 0)
+        models
+      rescue => e
+        Aidp.log_error("model_cache", "failed to read cache",
+          provider: provider, error: e.message)
+        nil
+      end
+
+      # Cache models for a provider with TTL
+      #
+      # @param provider [String] Provider name
+      # @param models [Array<Hash>] Models to cache
+      # @param ttl [Integer] Time to live in seconds (default: 24 hours)
+      def cache_models(provider, models, ttl: DEFAULT_TTL)
+        unless @cache_enabled
+          Aidp.log_debug("model_cache", "caching disabled, skipping",
+            provider: provider)
+          return false
+        end
+
+        cache_data = load_cache
+
+        cache_data[provider] = {
+          "cached_at" => Time.now.iso8601,
+          "ttl" => ttl,
+          "models" => models
+        }
+
+        if save_cache(cache_data)
+          Aidp.log_info("model_cache", "cached models",
+            provider: provider, count: models.size, ttl: ttl)
+          true
+        else
+          Aidp.log_warn("model_cache", "failed to cache models",
+            provider: provider)
+          false
+        end
+      rescue => e
+        Aidp.log_error("model_cache", "error caching models",
+          provider: provider, error: e.message)
+        false
+      end
+
+      # Invalidate cache for a specific provider
+      #
+      # @param provider [String] Provider name
+      def invalidate(provider)
+        return false unless @cache_enabled
+
+        cache_data = load_cache
+        cache_data.delete(provider)
+        save_cache(cache_data)
+        Aidp.log_info("model_cache", "invalidated cache", provider: provider)
+        true
+      rescue => e
+        Aidp.log_error("model_cache", "failed to invalidate cache",
+          provider: provider, error: e.message)
+        false
+      end
+
+      # Invalidate all cached models
+      def invalidate_all
+        return false unless @cache_enabled
+
+        save_cache({})
+        Aidp.log_info("model_cache", "invalidated all caches")
+        true
+      rescue => e
+        Aidp.log_error("model_cache", "failed to invalidate all",
+          error: e.message)
+        false
+      end
+
+      # Get list of providers with cached models
+      #
+      # @return [Array<String>] Provider names with valid caches
+      def cached_providers
+        cache_data = load_cache
+        providers = []
+
+        cache_data.each do |provider, data|
+          cached_at = begin
+            Time.parse(data["cached_at"])
+          rescue
+            nil
+          end
+          next unless cached_at
+
+          ttl = data["ttl"] || DEFAULT_TTL
+          expires_at = cached_at + ttl
+
+          providers << provider if Time.now <= expires_at
+        end
+
+        providers
+      rescue => e
+        Aidp.log_error("model_cache", "failed to get cached providers",
+          error: e.message)
+        []
+      end
+
+      # Get cache statistics
+      #
+      # @return [Hash] Statistics about the cache
+      def stats
+        cache_data = load_cache
+        file_size = begin
+          File.size(@cache_file)
+        rescue
+          0
+        end
+
+        {
+          total_providers: cache_data.size,
+          cached_providers: cached_providers,
+          cache_file_size: file_size
+        }
+      rescue => e
+        Aidp.log_error("model_cache", "failed to get stats",
+          error: e.message)
+        {total_providers: 0, cached_providers: [], cache_file_size: 0}
+      end
+
+      private
+
+      def determine_cache_file(cache_file, cache_dir)
+        return cache_file if cache_file
+
+        if cache_dir
+          File.join(cache_dir, "models.json")
+        else
+          default_cache_file
+        end
+      end
+
+      def default_cache_file
+        File.join(Dir.home, ".aidp", "cache", "models.json")
+      rescue => e
+        # Fallback to temp directory if home directory is not accessible
+        Aidp.log_debug("model_cache", "home directory not accessible, using temp",
+          error: e.message)
+        File.join(Dir.tmpdir, "aidp_cache", "models.json")
+      end
+
+      def ensure_cache_directory
+        cache_dir = File.dirname(@cache_file)
+        return true if File.directory?(cache_dir)
+
+        FileUtils.mkdir_p(cache_dir)
+        true
+      rescue Errno::EACCES, Errno::EPERM => e
+        Aidp.log_warn("model_cache", "permission denied creating cache directory",
+          cache_dir: cache_dir, error: e.message)
+
+        # Try fallback to temp directory
+        @cache_file = File.join(Dir.tmpdir, "aidp_cache", "models.json")
+        fallback_dir = File.dirname(@cache_file)
+
+        begin
+          FileUtils.mkdir_p(fallback_dir) unless File.directory?(fallback_dir)
+          Aidp.log_info("model_cache", "using fallback cache directory",
+            cache_file: @cache_file)
+          true
+        rescue => fallback_error
+          Aidp.log_error("model_cache", "failed to create fallback cache directory",
+            error: fallback_error.message)
+          false
+        end
+      rescue => e
+        Aidp.log_error("model_cache", "failed to create cache directory",
+          cache_dir: cache_dir, error: e.message)
+        false
+      end
+
+      def load_cache
+        return {} unless File.exist?(@cache_file)
+
+        content = File.read(@cache_file)
+        JSON.parse(content)
+      rescue JSON::ParserError => e
+        Aidp.log_warn("model_cache", "corrupted cache file, resetting",
+          error: e.message)
+        # Reset corrupted cache
+        {}
+      rescue => e
+        Aidp.log_error("model_cache", "failed to load cache",
+          error: e.message)
+        {}
+      end
+
+      def save_cache(data)
+        return false unless @cache_enabled
+
+        ensure_cache_directory
+        File.write(@cache_file, JSON.pretty_generate(data))
+        true
+      rescue => e
+        Aidp.log_error("model_cache", "failed to save cache",
+          error: e.message, cache_file: @cache_file)
+        false
+      end
+    end
+  end
+end