aidp 0.12.1 → 0.13.0

data/lib/aidp/harness/provider_config.rb

@@ -18,53 +18,53 @@ module Aidp
       end
 
       # Get complete provider configuration
-      def get_config(options = {})
+      def config(options = {})
         return @provider_config if @provider_config && !options[:force_reload] && cache_valid?
 
-        @provider_config = @config_manager.get_provider_config(@provider_name, options)
-        @harness_config = @config_manager.get_harness_config(options)
+        @provider_config = @config_manager.provider_config(@provider_name, options)
+        @harness_config = @config_manager.harness_config(options)
         @cache_timestamp = Time.now
 
         @provider_config || {}
       end
 
       # Get provider type (usage_based, subscription)
-      def get_type(options = {})
-        config = get_config(options)
+      def type(options = {})
+        config = config(options)
         config[:type] || config["type"] || "subscription"
       end
 
       # Provider type checking methods are now provided by ProviderTypeChecker module
 
       # Get provider priority
-      def get_priority(options = {})
-        config = get_config(options)
+      def priority(options = {})
+        config = config(options)
         config[:priority] || config["priority"] || 1
       end
 
       # Get provider models
-      def get_models(options = {})
-        config = get_config(options)
+      def models(options = {})
+        config = config(options)
         models = config[:models] || config["models"] || []
         models.map(&:to_s)
       end
 
       # Get default model
-      def get_default_model(options = {})
-        models = get_models(options)
-        models.first
+      def default_model(options = {})
+        model_list = models(options)
+        model_list.first
       end
 
       # Get model weights
-      def get_model_weights(options = {})
-        config = get_config(options)
+      def model_weights(options = {})
+        config = config(options)
         weights = config[:model_weights] || config["model_weights"] || {}
         weights.transform_values { |weight| [weight.to_i, 1].max }
       end
 
       # Get model configuration
-      def get_model_config(model_name, options = {})
-        config = get_config(options)
+      def model_config(model_name, options = {})
+        config = config(options)
         models_config = config[:models_config] || config["models_config"] || {}
         model_config = models_config[model_name.to_sym] || models_config[model_name.to_s] || {}
 
@@ -78,8 +78,8 @@ module Aidp
       end
 
       # Get provider features
-      def get_features(options = {})
-        config = get_config(options)
+      def features(options = {})
+        config = config(options)
         features = config[:features] || config["features"] || {}
 
         {
@@ -95,13 +95,13 @@ module Aidp
 
       # Check if provider supports feature
       def supports_feature?(feature, options = {})
-        features = get_features(options)
+        features = features(options)
         features[feature.to_sym] == true
       end
 
       # Get provider capabilities
-      def get_capabilities(options = {})
-        features = get_features(options)
+      def capabilities(options = {})
+        features = features(options)
         capabilities = []
 
         capabilities << "file_upload" if features[:file_upload]
@@ -116,41 +116,41 @@ module Aidp
       end
 
       # Get provider max tokens
-      def get_max_tokens(options = {})
-        config = get_config(options)
+      def max_tokens(options = {})
+        config = config(options)
         config[:max_tokens] || config["max_tokens"]
       end
 
       # Get provider timeout
-      def get_timeout(options = {})
-        config = get_config(options)
+      def timeout(options = {})
+        config = config(options)
         config[:timeout] || config["timeout"] || 300
       end
 
       # Get provider default flags
-      def get_default_flags(options = {})
-        config = get_config(options)
+      def default_flags(options = {})
+        config = config(options)
         flags = config[:default_flags] || config["default_flags"] || []
         flags.map(&:to_s)
       end
 
       # Get model-specific flags
-      def get_model_flags(model_name, options = {})
-        model_config = get_model_config(model_name, options)
+      def model_flags(model_name, options = {})
+        model_config = model_config(model_name, options)
         model_config[:flags] || []
       end
 
       # Get combined flags (default + model-specific)
-      def get_combined_flags(model_name = nil, options = {})
-        default_flags = get_default_flags(options)
-        model_flags = model_name ? get_model_flags(model_name, options) : []
+      def combined_flags(model_name = nil, options = {})
+        base_default_flags = default_flags(options)
+        model_flags_list = model_name ? model_flags(model_name, options) : []
 
-        (default_flags + model_flags).uniq
+        (base_default_flags + model_flags_list).uniq
       end
 
       # Get authentication configuration
-      def get_auth_config(options = {})
-        config = get_config(options)
+      def auth_config(options = {})
+        config = config(options)
         auth = config[:auth] || config["auth"] || {}
 
         {
@@ -165,8 +165,8 @@ module Aidp
       end
 
       # Get API key from environment or config
-      def get_api_key(options = {})
-        auth_config = get_auth_config(options)
+      def api_key(options = {})
+        auth_config = auth_config(options)
 
         # Try environment variable first
         if auth_config[:api_key_env]
@@ -179,8 +179,8 @@ module Aidp
       end
 
       # Get endpoints configuration
-      def get_endpoints(options = {})
-        config = get_config(options)
+      def endpoints(options = {})
+        config = config(options)
         endpoints = config[:endpoints] || config["endpoints"] || {}
 
         {
@@ -193,14 +193,14 @@ module Aidp
       end
 
       # Get default endpoint
-      def get_default_endpoint(options = {})
-        endpoints = get_endpoints(options)
-        endpoints[:default]
+      def default_endpoint(options = {})
+        endpoints_list = endpoints(options)
+        endpoints_list[:default]
       end
 
       # Get monitoring configuration
-      def get_monitoring_config(options = {})
-        config = get_config(options)
+      def monitoring_config(options = {})
+        config = config(options)
         monitoring = config[:monitoring] || config["monitoring"] || {}
 
         {
@@ -214,8 +214,8 @@ module Aidp
       end
 
       # Get rate limiting configuration
-      def get_rate_limit_config(options = {})
-        config = get_config(options)
+      def rate_limit_config(options = {})
+        config = config(options)
         rate_limit = config[:rate_limit] || config["rate_limit"] || {}
 
         {
@@ -230,8 +230,8 @@ module Aidp
       end
 
       # Get retry configuration
-      def get_retry_config(options = {})
-        config = get_config(options)
+      def retry_config(options = {})
+        config = config(options)
         retry_config = config[:retry] || config["retry"] || {}
 
         {
@@ -246,8 +246,8 @@ module Aidp
       end
 
       # Get circuit breaker configuration
-      def get_circuit_breaker_config(options = {})
-        config = get_config(options)
+      def circuit_breaker_config(options = {})
+        config = config(options)
         cb_config = config[:circuit_breaker] || config["circuit_breaker"] || {}
 
         {
@@ -260,8 +260,8 @@ module Aidp
       end
 
       # Get cost configuration
-      def get_cost_config(options = {})
-        config = get_config(options)
+      def cost_config(options = {})
+        config = config(options)
         cost = config[:cost] || config["cost"] || {}
 
         {
@@ -273,23 +273,23 @@ module Aidp
       end
 
       # Get provider-specific harness configuration
-      def get_harness_config(options = {})
-        config = get_config(options)
+      def harness_config(options = {})
+        config = config(options)
         harness_config = config[:harness] || config["harness"] || {}
 
         {
           enabled: harness_config[:enabled] != false,
           auto_switch_on_error: harness_config[:auto_switch_on_error] != false,
           auto_switch_on_rate_limit: harness_config[:auto_switch_on_rate_limit] != false,
-          priority: harness_config[:priority] || get_priority(options),
+          priority: harness_config[:priority] || priority(options),
           weight: harness_config[:weight] || 1,
           max_concurrent_requests: harness_config[:max_concurrent_requests] || 5
         }
       end
 
       # Get provider health check configuration
-      def get_health_check_config(options = {})
-        config = get_config(options)
+      def health_check_config(options = {})
+        config = config(options)
         health_check = config[:health_check] || config["health_check"] || {}
 
         {
@@ -304,8 +304,8 @@ module Aidp
       end
 
       # Get provider-specific environment variables
-      def get_env_vars(options = {})
-        config = get_config(options)
+      def env_vars(options = {})
+        config = config(options)
         env_vars = config[:env_vars] || config["env_vars"] || {}
 
         # Convert to string keys for environment variable access
@@ -313,21 +313,21 @@ module Aidp
       end
 
       # Get provider-specific command line arguments
-      def get_cmd_args(options = {})
-        config = get_config(options)
+      def cmd_args(options = {})
+        config = config(options)
         cmd_args = config[:cmd_args] || config["cmd_args"] || []
         cmd_args.map(&:to_s)
       end
 
       # Get provider-specific working directory
-      def get_working_directory(options = {})
-        config = get_config(options)
+      def working_directory(options = {})
+        config = config(options)
         config[:working_directory] || config["working_directory"] || Dir.pwd
       end
 
       # Get provider-specific log configuration
-      def get_log_config(options = {})
-        config = get_config(options)
+      def log_config(options = {})
+        config = config(options)
         log_config = config[:log] || config["log"] || {}
 
         {
@@ -341,8 +341,8 @@ module Aidp
       end
 
       # Get provider-specific cache configuration
-      def get_cache_config(options = {})
-        config = get_config(options)
+      def cache_config(options = {})
+        config = config(options)
         cache_config = config[:cache] || config["cache"] || {}
 
         {
@@ -354,8 +354,8 @@ module Aidp
       end
 
       # Get provider-specific security configuration
-      def get_security_config(options = {})
-        config = get_config(options)
+      def security_config(options = {})
+        config = config(options)
         security = config[:security] || config["security"] || {}
 
         {
@@ -369,18 +369,18 @@ module Aidp
 
       # Check if provider is configured
       def configured?(options = {})
-        config = get_config(options)
+        config = config(options)
         !config.empty?
       end
 
       # Check if provider is enabled
       def enabled?(options = {})
-        harness_config = get_harness_config(options)
+        harness_config = harness_config(options)
         harness_config[:enabled] != false
       end
 
       # Get provider status
-      def get_status(options = {})
+      def status(options = {})
         return :not_configured unless configured?(options)
         return :disabled unless enabled?(options)
 
@@ -388,17 +388,17 @@ module Aidp
       end
 
       # Get provider summary
-      def get_summary(options = {})
-        config = get_config(options)
+      def summary(options = {})
+        config = config(options)
         return {} if config.empty?
 
         {
           name: @provider_name,
-          type: get_type(options),
-          priority: get_priority(options),
-          models: get_models(options),
-          features: get_capabilities(options),
-          status: get_status(options),
+          type: type(options),
+          priority: priority(options),
+          models: models(options),
+          features: capabilities(options),
+          status: status(options),
           configured: configured?(options),
           enabled: enabled?(options)
         }

data/lib/aidp/harness/provider_factory.rb

@@ -42,7 +42,7 @@ module Aidp
         end
 
         # Get provider configuration
-        provider_config = get_provider_config(provider_name)
+        provider_config = provider_config(provider_name)
 
         # Check if provider is configured and enabled
         unless provider_config.configured?(options)
@@ -54,7 +54,7 @@ module Aidp
         end
 
         # Get provider class
-        provider_class = get_provider_class(provider_name)
+        provider_class = provider_class(provider_name)
         raise "Unknown provider: #{provider_name}" unless provider_class
 
         # Create provider instance
@@ -78,13 +78,13 @@ module Aidp
 
       # Create all configured providers
       def create_all_providers(options = {})
-        configured_providers = @config_manager.get_provider_names(options)
+        configured_providers = @config_manager.provider_names(options)
         create_providers(configured_providers, options)
       end
 
       # Create providers by priority
       def create_providers_by_priority(options = {})
-        all_providers = @config_manager.get_all_providers(options)
+        all_providers = @config_manager.all_providers(options)
 
         # Sort by priority (lower number = higher priority)
         sorted_providers = all_providers.sort_by do |name, config|
@@ -99,7 +99,7 @@ module Aidp
 
       # Create providers by weight (for load balancing)
       def create_providers_by_weight(options = {})
-        all_providers = @config_manager.get_all_providers(options)
+        all_providers = @config_manager.all_providers(options)
         weighted_providers = []
 
         all_providers.each do |name, config|
@@ -113,12 +113,12 @@ module Aidp
       end
 
       # Get provider configuration
-      def get_provider_config(provider_name)
+      def provider_config(provider_name)
         @provider_configs[provider_name.to_s] ||= ProviderConfig.new(provider_name, @config_manager)
       end
 
       # Get provider class
-      def get_provider_class(provider_name)
+      def provider_class(provider_name)
         PROVIDER_CLASSES[provider_name.to_s]
       end
 
@@ -128,59 +128,59 @@ module Aidp
       end
 
       # Get supported provider names
-      def get_supported_providers
+      def supported_providers
         PROVIDER_CLASSES.keys
       end
 
       # Get configured provider names
-      def get_configured_providers(options = {})
-        @config_manager.get_provider_names(options)
+      def configured_providers(options = {})
+        @config_manager.provider_names(options)
       end
 
       # Get enabled provider names
-      def get_enabled_providers(options = {})
-        configured_providers = get_configured_providers(options)
+      def enabled_providers(options = {})
+        configured_providers = configured_providers(options)
         configured_providers.select do |provider_name|
-          provider_config = get_provider_config(provider_name)
+          provider_config = provider_config(provider_name)
           provider_config.enabled?(options)
         end
       end
 
       # Get provider capabilities
-      def get_provider_capabilities(provider_name, options = {})
-        provider_config = get_provider_config(provider_name)
-        provider_config.get_capabilities(options)
+      def provider_capabilities(provider_name, options = {})
+        provider_config = provider_config(provider_name)
+        provider_config.capabilities(options)
       end
 
       # Check if provider supports feature
       def provider_supports_feature?(provider_name, feature, options = {})
-        provider_config = get_provider_config(provider_name)
+        provider_config = provider_config(provider_name)
         provider_config.supports_feature?(feature, options)
       end
 
       # Get provider models
-      def get_provider_models(provider_name, options = {})
-        provider_config = get_provider_config(provider_name)
-        provider_config.get_models(options)
+      def provider_models(provider_name, options = {})
+        provider_config = provider_config(provider_name)
+        provider_config.models(options)
       end
 
       # Get provider summary
-      def get_provider_summary(provider_name, options = {})
-        provider_config = get_provider_config(provider_name)
-        provider_config.get_summary(options)
+      def provider_summary(provider_name, options = {})
+        provider_config = provider_config(provider_name)
+        provider_config.summary(options)
       end
 
       # Get all provider summaries
-      def get_all_provider_summaries(options = {})
-        configured_providers = get_configured_providers(options)
+      def all_provider_summaries(options = {})
+        configured_providers = configured_providers(options)
         configured_providers.map do |provider_name|
-          get_provider_summary(provider_name, options)
+          provider_summary(provider_name, options)
         end
       end
 
       # Validate provider configuration
       def validate_provider_config(provider_name, options = {})
-        provider_config = get_provider_config(provider_name)
+        provider_config = provider_config(provider_name)
         errors = []
 
         # Check if provider is configured
@@ -196,14 +196,14 @@ module Aidp
 
         # Check required configuration
         if provider_config.usage_based_provider?(options)
-          api_key = provider_config.get_api_key(options)
+          api_key = provider_config.api_key(options)
           unless api_key && !api_key.empty?
             errors << "API key not configured for provider '#{provider_name}'"
           end
         end
 
         # Check models configuration
-        models = provider_config.get_models(options)
+        models = provider_config.models(options)
         if models.empty?
           errors << "No models configured for provider '#{provider_name}'"
         end
@@ -213,7 +213,7 @@ module Aidp
 
       # Validate all provider configurations
       def validate_all_provider_configs(options = {})
-        configured_providers = get_configured_providers(options)
+        configured_providers = configured_providers(options)
         all_errors = {}
 
         configured_providers.each do |provider_name|
@@ -241,7 +241,7 @@ module Aidp
       def configure_provider(provider_instance, provider_config, options)
         # Set basic configuration
         if provider_instance.respond_to?(:configure)
-          provider_instance.configure(provider_config.get_config(options))
+          provider_instance.configure(provider_config.config(options))
         end
 
         # Set harness context if available
@@ -251,55 +251,55 @@ module Aidp
         end
 
         # Set monitoring configuration
-        monitoring_config = provider_config.get_monitoring_config(options)
+        monitoring_config = provider_config.monitoring_config(options)
         if provider_instance.respond_to?(:set_monitoring_config)
           provider_instance.set_monitoring_config(monitoring_config)
         end
 
         # Set rate limiting configuration
-        rate_limit_config = provider_config.get_rate_limit_config(options)
+        rate_limit_config = provider_config.rate_limit_config(options)
         if provider_instance.respond_to?(:set_rate_limit_config)
           provider_instance.set_rate_limit_config(rate_limit_config)
         end
 
         # Set retry configuration
-        retry_config = provider_config.get_retry_config(options)
+        retry_config = provider_config.retry_config(options)
         if provider_instance.respond_to?(:set_retry_config)
           provider_instance.set_retry_config(retry_config)
         end
 
         # Set circuit breaker configuration
-        circuit_breaker_config = provider_config.get_circuit_breaker_config(options)
+        circuit_breaker_config = provider_config.circuit_breaker_config(options)
         if provider_instance.respond_to?(:set_circuit_breaker_config)
           provider_instance.set_circuit_breaker_config(circuit_breaker_config)
         end
 
         # Set cost configuration
-        cost_config = provider_config.get_cost_config(options)
+        cost_config = provider_config.cost_config(options)
         if provider_instance.respond_to?(:set_cost_config)
           provider_instance.set_cost_config(cost_config)
         end
 
         # Set health check configuration
-        health_check_config = provider_config.get_health_check_config(options)
+        health_check_config = provider_config.health_check_config(options)
         if provider_instance.respond_to?(:set_health_check_config)
           provider_instance.set_health_check_config(health_check_config)
         end
 
         # Set log configuration
-        log_config = provider_config.get_log_config(options)
+        log_config = provider_config.log_config(options)
         if provider_instance.respond_to?(:set_log_config)
           provider_instance.set_log_config(log_config)
         end
 
         # Set cache configuration
-        cache_config = provider_config.get_cache_config(options)
+        cache_config = provider_config.cache_config(options)
         if provider_instance.respond_to?(:set_cache_config)
           provider_instance.set_cache_config(cache_config)
         end
 
         # Set security configuration
-        security_config = provider_config.get_security_config(options)
+        security_config = provider_config.security_config(options)
         if provider_instance.respond_to?(:set_security_config)
           provider_instance.set_security_config(security_config)
         end