aidp 0.12.1 → 0.13.0

data/lib/aidp/harness/config_manager.rb

@@ -18,7 +18,7 @@ module Aidp
       end
 
       # Get complete configuration
-      def get_config(options = {})
+      def config(options = {})
         cache_key = "config_#{options.hash}"
 
         if cache_valid?(cache_key)
@@ -31,16 +31,16 @@ module Aidp
       end
 
       # Get harness configuration
-      def get_harness_config(options = {})
-        config = get_config(options)
+      def harness_config(options = {})
+        config = config(options)
         return nil unless config
 
         config[:harness] || {}
       end
 
       # Get provider configuration
-      def get_provider_config(provider_name, options = {})
-        config = get_config(options)
+      def provider_config(provider_name, options = {})
+        config = config(options)
         return nil unless config
 
         providers = config[:providers] || {}
@@ -48,38 +48,38 @@ module Aidp
       end
 
       # Get all provider configurations
-      def get_all_providers(options = {})
-        config = get_config(options)
+      def all_providers(options = {})
+        config = config(options)
         return {} unless config
 
         config[:providers] || {}
       end
 
       # Get configured provider names
-      def get_provider_names(options = {})
-        providers = get_all_providers(options)
+      def provider_names(options = {})
+        providers = all_providers(options)
         providers.keys.map(&:to_s)
       end
 
       # Get default provider
-      def get_default_provider(options = {})
-        harness_config = get_harness_config(options)
+      def default_provider(options = {})
+        harness_config = harness_config(options)
         harness_config[:default_provider] || harness_config["default_provider"]
       end
 
       # Get fallback providers
-      def get_fallback_providers(options = {})
-        harness_config = get_harness_config(options)
+      def fallback_providers(options = {})
+        harness_config = harness_config(options)
         fallback_providers = harness_config[:fallback_providers] || harness_config["fallback_providers"] || []
 
         # Ensure fallback providers are configured
-        configured_providers = get_provider_names(options)
+        configured_providers = provider_names(options)
         fallback_providers.select { |provider| configured_providers.include?(provider) }
       end
 
       # Get provider weights
-      def get_provider_weights(options = {})
-        harness_config = get_harness_config(options)
+      def provider_weights(options = {})
+        harness_config = harness_config(options)
         weights = harness_config[:provider_weights] || harness_config["provider_weights"] || {}
 
         # Normalize weights to ensure they're positive integers
@@ -87,8 +87,8 @@ module Aidp
       end
 
       # Get retry configuration
-      def get_retry_config(options = {})
-        harness_config = get_harness_config(options)
+      def retry_config(options = {})
+        harness_config = harness_config(options)
         retry_config = harness_config[:retry] || harness_config["retry"] || {}
 
         {
@@ -102,8 +102,8 @@ module Aidp
       end
 
       # Get circuit breaker configuration
-      def get_circuit_breaker_config(options = {})
-        harness_config = get_harness_config(options)
+      def circuit_breaker_config(options = {})
+        harness_config = harness_config(options)
         cb_config = harness_config[:circuit_breaker] || harness_config["circuit_breaker"] || {}
 
         {
@@ -115,8 +115,8 @@ module Aidp
       end
 
       # Get rate limit configuration
-      def get_rate_limit_config(options = {})
-        harness_config = get_harness_config(options)
+      def rate_limit_config(options = {})
+        harness_config = harness_config(options)
         rate_limit_config = harness_config[:rate_limit] || harness_config["rate_limit"] || {}
 
         {
@@ -128,8 +128,8 @@ module Aidp
       end
 
       # Get load balancing configuration
-      def get_load_balancing_config(options = {})
-        harness_config = get_harness_config(options)
+      def load_balancing_config(options = {})
+        harness_config = harness_config(options)
         lb_config = harness_config[:load_balancing] || harness_config["load_balancing"] || {}
 
         {
@@ -141,8 +141,8 @@ module Aidp
       end
 
       # Get model switching configuration
-      def get_model_switching_config(options = {})
-        harness_config = get_harness_config(options)
+      def model_switching_config(options = {})
+        harness_config = harness_config(options)
         ms_config = harness_config[:model_switching] || harness_config["model_switching"] || {}
 
         {
@@ -154,8 +154,8 @@ module Aidp
       end
 
       # Get health check configuration
-      def get_health_check_config(options = {})
-        harness_config = get_harness_config(options)
+      def health_check_config(options = {})
+        harness_config = harness_config(options)
         hc_config = harness_config[:health_check] || harness_config["health_check"] || {}
 
         {
@@ -168,8 +168,8 @@ module Aidp
       end
 
       # Get metrics configuration
-      def get_metrics_config(options = {})
-        harness_config = get_harness_config(options)
+      def metrics_config(options = {})
+        harness_config = harness_config(options)
         metrics_config = harness_config[:metrics] || harness_config["metrics"] || {}
 
         {
@@ -181,8 +181,8 @@ module Aidp
       end
 
       # Get session configuration
-      def get_session_config(options = {})
-        harness_config = get_harness_config(options)
+      def session_config(options = {})
+        harness_config = harness_config(options)
         session_config = harness_config[:session] || harness_config["session"] || {}
 
         {
@@ -194,8 +194,8 @@ module Aidp
       end
 
       # Get provider models
-      def get_provider_models(provider_name, options = {})
-        provider_config = get_provider_config(provider_name, options)
+      def provider_models(provider_name, options = {})
+        provider_config = provider_config(provider_name, options)
         return [] unless provider_config
 
         models = provider_config[:models] || provider_config["models"] || []
@@ -203,8 +203,8 @@ module Aidp
       end
 
       # Get provider model weights
-      def get_provider_model_weights(provider_name, options = {})
-        provider_config = get_provider_config(provider_name, options)
+      def provider_model_weights(provider_name, options = {})
+        provider_config = provider_config(provider_name, options)
         return {} unless provider_config
 
         weights = provider_config[:model_weights] || provider_config["model_weights"] || {}
@@ -212,8 +212,8 @@ module Aidp
       end
 
       # Get provider model configuration
-      def get_provider_model_config(provider_name, model_name, options = {})
-        provider_config = get_provider_config(provider_name, options)
+      def provider_model_config(provider_name, model_name, options = {})
+        provider_config = provider_config(provider_name, options)
         return {} unless provider_config
 
         models_config = provider_config[:models_config] || provider_config["models_config"] || {}
@@ -227,8 +227,8 @@ module Aidp
       end
 
       # Get provider features
-      def get_provider_features(provider_name, options = {})
-        provider_config = get_provider_config(provider_name, options)
+      def provider_features(provider_name, options = {})
+        provider_config = provider_config(provider_name, options)
         return {} unless provider_config
 
         features = provider_config[:features] || provider_config["features"] || {}
@@ -242,8 +242,8 @@ module Aidp
       end
 
       # Get provider monitoring configuration
-      def get_provider_monitoring_config(provider_name, options = {})
-        provider_config = get_provider_config(provider_name, options)
+      def provider_monitoring_config(provider_name, options = {})
+        provider_config = provider_config(provider_name, options)
         return {} unless provider_config
 
         monitoring = provider_config[:monitoring] || provider_config["monitoring"] || {}
@@ -256,21 +256,21 @@ module Aidp
 
       # Check if provider supports feature
       def provider_supports_feature?(provider_name, feature, options = {})
-        features = get_provider_features(provider_name, options)
+        features = provider_features(provider_name, options)
         features[feature.to_sym] == true
       end
 
       # Get provider priority
-      def get_provider_priority(provider_name, options = {})
-        provider_config = get_provider_config(provider_name, options)
+      def provider_priority(provider_name, options = {})
+        provider_config = provider_config(provider_name, options)
         return 1 unless provider_config
 
         provider_config[:priority] || provider_config["priority"] || 1
       end
 
       # Get provider type
-      def get_provider_type(provider_name, options = {})
-        provider_config = get_provider_config(provider_name, options)
+      def provider_type(provider_name, options = {})
+        provider_config = provider_config(provider_name, options)
         return nil unless provider_config
 
         provider_config[:type] || provider_config["type"]
@@ -279,16 +279,16 @@ module Aidp
       # Provider type checking methods are now provided by ProviderTypeChecker module
 
       # Get provider max tokens
-      def get_provider_max_tokens(provider_name, options = {})
-        provider_config = get_provider_config(provider_name, options)
+      def provider_max_tokens(provider_name, options = {})
+        provider_config = provider_config(provider_name, options)
         return nil unless provider_config
 
         provider_config[:max_tokens] || provider_config["max_tokens"]
       end
 
       # Get provider default flags
-      def get_provider_default_flags(provider_name, options = {})
-        provider_config = get_provider_config(provider_name, options)
+      def provider_default_flags(provider_name, options = {})
+        provider_config = provider_config(provider_name, options)
         return [] unless provider_config
 
         flags = provider_config[:default_flags] || provider_config["default_flags"] || []
@@ -296,8 +296,8 @@ module Aidp
       end
 
       # Get provider auth configuration
-      def get_provider_auth_config(provider_name, options = {})
-        provider_config = get_provider_config(provider_name, options)
+      def provider_auth_config(provider_name, options = {})
+        provider_config = provider_config(provider_name, options)
         return {} unless provider_config
 
         auth = provider_config[:auth] || provider_config["auth"] || {}
@@ -309,8 +309,8 @@ module Aidp
       end
 
       # Get provider endpoints
-      def get_provider_endpoints(provider_name, options = {})
-        provider_config = get_provider_config(provider_name, options)
+      def provider_endpoints(provider_name, options = {})
+        provider_config = provider_config(provider_name, options)
         return {} unless provider_config
 
         endpoints = provider_config[:endpoints] || provider_config["endpoints"] || {}
@@ -326,13 +326,13 @@ module Aidp
       end
 
       # Get validation errors
-      def get_validation_errors
-        @loader.get_validation_errors
+      def validation_errors
+        @loader.validation_errors
       end
 
       # Get validation warnings
-      def get_validation_warnings
-        @loader.get_validation_warnings
+      def validation_warnings
+        @loader.validation_warnings
       end
 
       # Reload configuration
@@ -343,8 +343,8 @@ module Aidp
       end
 
       # Get configuration summary
-      def get_config_summary
-        @loader.get_config_summary
+      def config_summary
+        @loader.config_summary
       end
 
       private

data/lib/aidp/harness/config_validator.rb

@@ -41,7 +41,7 @@ module Aidp
       end
 
       # Get configuration with defaults applied
-      def get_validated_config
+      def validated_config
         return nil unless @validation_result&.dig(:valid)
 
         ConfigSchema.apply_defaults(@config)
@@ -110,7 +110,7 @@ module Aidp
       end
 
       # Get configuration summary
-      def get_summary
+      def summary
         return {error: "No configuration file found"} unless @config_file
 
         load_config
@@ -157,7 +157,7 @@ module Aidp
       end
 
       # Get provider configuration with defaults
-      def get_provider_config(provider_name)
+      def provider_config(provider_name)
         return nil unless @config_file
 
         load_config
@@ -195,7 +195,7 @@ module Aidp
       end
 
       # Get harness configuration with defaults
-      def get_harness_config
+      def harness_config
         return nil unless @config_file
 
         load_config
@@ -212,17 +212,17 @@ module Aidp
 
         load_config
         validate_config
-        validated_config = get_validated_config
-        return nil unless validated_config
+        config = validated_config
+        return nil unless config
 
         case format
         when :yaml
-          YAML.dump(validated_config)
+          YAML.dump(config)
         when :json
           require "json"
-          JSON.pretty_generate(validated_config)
+          JSON.pretty_generate(config)
         when :ruby
-          "CONFIG = #{validated_config.inspect}"
+          "CONFIG = #{config.inspect}"
         else
           raise ArgumentError, "Unsupported format: #{format}"
         end

data/lib/aidp/harness/configuration.rb

@@ -65,13 +65,13 @@ module Aidp
 
       # Get provider models configuration
       def provider_models(provider_name)
-        provider_config(provider_name)[:models] || get_default_models_for_provider(provider_name)
+        provider_config(provider_name)[:models] || default_models_for_provider(provider_name)
       end
 
       # Get default model for provider
       def default_model(provider_name)
         models = provider_models(provider_name)
-        models.first || get_default_model_for_provider(provider_name)
+        models.first || default_model_for_provider(provider_name)
       end
 
       # Get model configuration for provider
@@ -92,7 +92,7 @@ module Aidp
 
       # Get model-specific timeout
       def model_timeout(provider_name, model_name)
-        model_config(provider_name, model_name)[:timeout] || get_default_timeout_for_provider(provider_name)
+        model_config(provider_name, model_name)[:timeout] || default_timeout_for_provider(provider_name)
       end
 
       # Get provider weights for load balancing
@@ -107,47 +107,47 @@ module Aidp
 
       # Get circuit breaker configuration
       def circuit_breaker_config
-        harness_config[:circuit_breaker] || get_default_circuit_breaker_config
+        harness_config[:circuit_breaker] || default_circuit_breaker_config
       end
 
       # Get retry configuration
       def retry_config
-        harness_config[:retry] || get_default_retry_config
+        harness_config[:retry] || default_retry_config
       end
 
       # Get rate limit configuration
       def rate_limit_config
-        harness_config[:rate_limit] || get_default_rate_limit_config
+        harness_config[:rate_limit] || default_rate_limit_config
       end
 
       # Get load balancing configuration
       def load_balancing_config
-        harness_config[:load_balancing] || get_default_load_balancing_config
+        harness_config[:load_balancing] || default_load_balancing_config
       end
 
       # Get model switching configuration
       def model_switching_config
-        harness_config[:model_switching] || get_default_model_switching_config
+        harness_config[:model_switching] || default_model_switching_config
       end
 
       # Get provider health check configuration
       def health_check_config
-        harness_config[:health_check] || get_default_health_check_config
+        harness_config[:health_check] || default_health_check_config
       end
 
       # Get metrics configuration
       def metrics_config
-        harness_config[:metrics] || get_default_metrics_config
+        harness_config[:metrics] || default_metrics_config
       end
 
       # Get session configuration
       def session_config
-        harness_config[:session] || get_default_session_config
+        harness_config[:session] || default_session_config
       end
 
       # Get work loop configuration
       def work_loop_config
-        harness_config[:work_loop] || get_default_work_loop_config
+        harness_config[:work_loop] || default_work_loop_config
       end
 
       # Check if work loops are enabled
@@ -217,12 +217,12 @@ module Aidp
 
       # Get logging configuration
       def logging_config
-        harness_config[:logging] || get_default_logging_config
+        harness_config[:logging] || default_logging_config
       end
 
       # Get fallback configuration
       def fallback_config
-        harness_config[:fallback] || get_default_fallback_config
+        harness_config[:fallback] || default_fallback_config
       end
 
       # Check if configuration file exists
@@ -341,7 +341,7 @@ module Aidp
       end
 
       # Default configuration methods
-      def get_default_models_for_provider(provider_name)
+      def default_models_for_provider(provider_name)
         case provider_name
         when "anthropic"
           ["anthropic-3-5-sonnet-20241022", "anthropic-3-5-haiku-20241022", "anthropic-3-opus-20240229"]
@@ -352,7 +352,7 @@ module Aidp
         end
       end
 
-      def get_default_model_for_provider(provider_name)
+      def default_model_for_provider(provider_name)
         case provider_name
         when "anthropic"
           "anthropic-3-5-sonnet-20241022"
@@ -363,11 +363,11 @@ module Aidp
         end
       end
 
-      def get_default_timeout_for_provider(provider_name)
+      def default_timeout_for_provider(provider_name)
         300 # 5 minutes - default timeout for all providers
       end
 
-      def get_default_circuit_breaker_config
+      def default_circuit_breaker_config
         {
           enabled: true,
           failure_threshold: 5,
@@ -376,7 +376,7 @@ module Aidp
         }
       end
 
-      def get_default_retry_config
+      def default_retry_config
         {
           enabled: true,
           max_attempts: 3,
@@ -387,7 +387,7 @@ module Aidp
         }
       end
 
-      def get_default_rate_limit_config
+      def default_rate_limit_config
         {
           enabled: true,
           default_reset_time: 3600, # 1 hour
@@ -396,7 +396,7 @@ module Aidp
         }
       end
 
-      def get_default_load_balancing_config
+      def default_load_balancing_config
         {
           enabled: true,
           strategy: "weighted_round_robin", # weighted_round_robin, least_connections, random
@@ -405,7 +405,7 @@ module Aidp
         }
       end
 
-      def get_default_model_switching_config
+      def default_model_switching_config
         {
           enabled: true,
           auto_switch_on_error: true,
@@ -414,7 +414,7 @@ module Aidp
         }
       end
 
-      def get_default_health_check_config
+      def default_health_check_config
         {
           enabled: true,
           interval: 60, # 1 minute
@@ -424,7 +424,7 @@ module Aidp
         }
       end
 
-      def get_default_metrics_config
+      def default_metrics_config
         {
           enabled: true,
           retention_days: 30,
@@ -433,7 +433,7 @@ module Aidp
         }
       end
 
-      def get_default_session_config
+      def default_session_config
         {
           enabled: true,
           timeout: 1800, # 30 minutes
@@ -442,7 +442,7 @@ module Aidp
         }
       end
 
-      def get_default_work_loop_config
+      def default_work_loop_config
         {
           enabled: true,
           max_iterations: 50,
@@ -451,7 +451,7 @@ module Aidp
         }
       end
 
-      def get_default_logging_config
+      def default_logging_config
         {
           log_level: :info,
           retention_days: 30,
@@ -463,7 +463,7 @@ module Aidp
         }
       end
 
-      def get_default_fallback_config
+      def default_fallback_config
         {
           strategies: {
             rate_limit: {

data/lib/aidp/harness/error_handler.rb

@@ -53,7 +53,7 @@ module Aidp
         @error_history << error_info
 
         # Get retry strategy for this error type
-        strategy = get_retry_strategy(error_info[:error_type])
+        strategy = retry_strategy(error_info[:error_type])
 
         # Check if we should retry
         if should_retry?(error_info, strategy)
@@ -97,17 +97,17 @@ module Aidp
             attempt += 1
             return yield
           rescue => error
-            current_provider = get_current_provider_safely
+            current_provider = current_provider_safely
 
             if attempt < max_attempts
               error_info = {
                 error: error,
                 provider: current_provider,
-                model: get_current_model_safely,
+                model: current_model_safely,
                 error_type: @error_classifier.classify_error(error)
               }
 
-              strategy = get_retry_strategy(error_info[:error_type])
+              strategy = retry_strategy(error_info[:error_type])
               if should_retry?(error_info, strategy)
                 delay = @backoff_calculator.calculate_delay(attempt, strategy[:backoff_strategy] || :exponential, 1, 10)
                 debug_log("🔁 Retry attempt #{attempt} for #{current_provider}", level: :info, data: {delay: delay, error_type: error_info[:error_type]})
@@ -120,11 +120,11 @@ module Aidp
             debug_log("🚫 Exhausted retries for provider, attempting recovery", level: :warn, data: {provider: current_provider, attempt: attempt, max_attempts: max_attempts})
             handle_error(error, {
               provider: current_provider,
-              model: get_current_model_safely,
+              model: current_model_safely,
               exhausted_retries: true
             })
 
-            new_provider = get_current_provider_safely
+            new_provider = current_provider_safely
             if new_provider != current_provider && !providers_tried.include?(new_provider)
               providers_tried << current_provider
               # Reset retry counts for the new provider
@@ -233,7 +233,7 @@ module Aidp
       end
 
       # Get retry strategy for error type
-      def get_retry_strategy(error_type)
+      def retry_strategy(error_type)
         @retry_strategies[error_type] || @retry_strategies[:default]
       end
 
@@ -270,7 +270,7 @@ module Aidp
       end
 
       # Get retry status for a provider/model
-      def get_retry_status(provider, model = nil)
+      def retry_status(provider, model = nil)
         keys = if model
           @retry_counts.keys.select { |k| k.start_with?("#{provider}:#{model}:") }
         else
@@ -282,7 +282,7 @@ module Aidp
           error_type = key.split(":").last
           status[error_type] = {
             retry_count: @retry_counts[key],
-            max_retries: get_retry_strategy(error_type.to_sym)[:max_retries]
+            max_retries: retry_strategy(error_type.to_sym)[:max_retries]
           }
         end
 
@@ -290,7 +290,7 @@ module Aidp
       end
 
       # Get error history
-      def get_error_history(time_range = nil)
+      def error_history(time_range = nil)
         if time_range
           @error_history.select { |e| time_range.include?(e[:timestamp]) }
         else
@@ -304,7 +304,7 @@ module Aidp
       end
 
       # Get circuit breaker status
-      def get_circuit_breaker_status
+      def circuit_breaker_status
         @circuit_breakers.transform_values do |cb|
           {
             open: cb[:open],
@@ -667,7 +667,7 @@ module Aidp
       end
 
       # Safe access to provider manager methods that may not exist
-      def get_current_provider_safely
+      def current_provider_safely
         return "unknown" unless @provider_manager
         return "unknown" unless @provider_manager.respond_to?(:current_provider)
 
@@ -677,7 +677,7 @@ module Aidp
         "unknown"
       end
 
-      def get_current_model_safely
+      def current_model_safely
         return "unknown" unless @provider_manager
         return "unknown" unless @provider_manager.respond_to?(:current_model)