aidp 0.25.0 → 0.27.0

data/lib/aidp/harness/configuration.rb

@@ -168,12 +168,47 @@ module Aidp
 
       # Get test commands
       def test_commands
-        work_loop_config[:test_commands] || []
+        normalize_commands(work_loop_config[:test_commands] || [])
       end
 
       # Get lint commands
       def lint_commands
-        work_loop_config[:lint_commands] || []
+        normalize_commands(work_loop_config[:lint_commands] || [])
+      end
+
+      # Get formatter commands
+      def formatter_commands
+        normalize_commands(work_loop_config[:formatter_commands] || [])
+      end
+
+      # Get build commands
+      def build_commands
+        normalize_commands(work_loop_config[:build_commands] || [])
+      end
+
+      # Get documentation commands
+      def documentation_commands
+        normalize_commands(work_loop_config[:documentation_commands] || [])
+      end
+
+      # Get test output mode
+      def test_output_mode
+        work_loop_config.dig(:test, :output_mode) || :full
+      end
+
+      # Get max output lines for tests
+      def test_max_output_lines
+        work_loop_config.dig(:test, :max_output_lines) || 500
+      end
+
+      # Get lint output mode
+      def lint_output_mode
+        work_loop_config.dig(:lint, :output_mode) || :full
+      end
+
+      # Get max output lines for linters
+      def lint_max_output_lines
+        work_loop_config.dig(:lint, :max_output_lines) || 300
       end
 
       # Get guards configuration
@@ -348,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
@@ -397,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
@@ -704,6 +769,42 @@ module Aidp
 
       private
 
+      # Normalize command configuration to consistent format
+      # Supports both string format and object format with required flag
+      # Examples:
+      #   "bundle exec rspec" -> {command: "bundle exec rspec", required: true}
+      #   {command: "rubocop", required: false} -> {command: "rubocop", required: false}
+      def normalize_commands(commands)
+        return [] if commands.nil? || commands.empty?
+
+        commands.map do |cmd|
+          case cmd
+          when String
+            {command: cmd, required: true}
+          when Hash
+            # Handle both symbol and string keys
+            command_value = cmd[:command] || cmd["command"]
+            required_value = if cmd.key?(:required)
+              cmd[:required]
+            else
+              (cmd.key?("required") ? cmd["required"] : true)
+            end
+
+            unless command_value.is_a?(String) && !command_value.empty?
+              raise ConfigurationError, "Command must be a non-empty string, got: #{command_value.inspect}"
+            end
+
+            unless [true, false].include?(required_value)
+              raise ConfigurationError, "Required flag must be boolean, got: #{required_value.inspect}"
+            end
+
+            {command: command_value, required: required_value}
+          else
+            raise ConfigurationError, "Command must be a string or hash, got: #{cmd.class}"
+          end
+        end
+      end
+
       def validate_configuration!
         errors = Aidp::Config.validate_harness_config(@config, @project_dir)
 

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
             {

data/lib/aidp/harness/filter_strategy.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+module Aidp
+  module Harness
+    # Base class for framework-specific filtering strategies
+    class FilterStrategy
+      # @param output [String] Raw output
+      # @param filter [OutputFilter] Filter instance for config access
+      # @return [String] Filtered output
+      def filter(output, filter_instance)
+        raise NotImplementedError, "Subclasses must implement #filter"
+      end
+
+      protected
+
+      # Extract lines around a match (for context)
+      def extract_with_context(lines, index, context_lines)
+        start_idx = [0, index - context_lines].max
+        end_idx = [lines.length - 1, index + context_lines].min
+
+        lines[start_idx..end_idx]
+      end
+
+      # Find failure markers in output
+      def find_failure_markers(output)
+        lines = output.lines
+        markers = []
+
+        lines.each_with_index do |line, index|
+          # Check for failure patterns using safe string methods
+          if line.match?(/FAILED/i) ||
+              line.match?(/ERROR/i) ||
+              line.match?(/FAIL:/i) ||
+              line.match?(/failures?:/i) ||
+              line.match?(/^\s*\d{1,4}\)\s/) ||  # Numbered failures (limit digits to prevent ReDoS)
+              line.include?(") ")  # Additional simple check for numbered patterns
+            markers << index
+          end
+        end
+
+        markers
+      end
+    end
+  end
+end

data/lib/aidp/harness/generic_filter_strategy.rb

@@ -0,0 +1,63 @@
+# frozen_string_literal: true
+
+require_relative "filter_strategy"
+
+module Aidp
+  module Harness
+    # Generic filtering for unknown frameworks
+    class GenericFilterStrategy < FilterStrategy
+      def filter(output, filter_instance)
+        case filter_instance.mode
+        when :failures_only
+          extract_failure_lines(output, filter_instance)
+        when :minimal
+          extract_summary(output, filter_instance)
+        else
+          output
+        end
+      end
+
+      private
+
+      def extract_failure_lines(output, filter_instance)
+        lines = output.lines
+        failure_indices = find_failure_markers(output)
+
+        return output if failure_indices.empty?
+
+        # Extract failures with context
+        relevant_lines = Set.new
+        failure_indices.each do |index|
+          if filter_instance.include_context
+            extract_with_context(lines, index, filter_instance.context_lines)
+            start_idx = [0, index - filter_instance.context_lines].max
+            end_idx = [lines.length - 1, index + filter_instance.context_lines].min
+            (start_idx..end_idx).each { |idx| relevant_lines.add(idx) }
+          else
+            relevant_lines.add(index)
+          end
+        end
+
+        selected = relevant_lines.to_a.sort.map { |idx| lines[idx] }
+        selected.join
+      end
+
+      def extract_summary(output, filter_instance)
+        lines = output.lines
+
+        # Take first line, last line, and any lines with numbers/statistics
+        parts = []
+        parts << lines.first if lines.first
+
+        summary_lines = lines.select do |line|
+          line.match?(/\d+/) || line.match?(/summary|total|passed|failed/i)
+        end
+
+        parts.concat(summary_lines.uniq)
+        parts << lines.last if lines.last && !parts.include?(lines.last)
+
+        parts.join("\n")
+      end
+    end
+  end
+end

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