Class: Aidp::Harness::Configuration

Inherits:
Object
  • Object
show all
Defined in:
lib/aidp/harness/configuration.rb

Overview

Handles loading and validation of harness configuration from aidp.yml

Defined Under Namespace

Classes: ConfigurationError

Instance Method Summary collapse

Constructor Details

#initialize(project_dir) ⇒ Configuration

Returns a new instance of Configuration.



9
10
11
12
13
 
# File 'lib/aidp/harness/configuration.rb', line 9

def initialize(project_dir)
  @project_dir = project_dir
  @config = Aidp::Config.load_harness_config(project_dir)
  validate_configuration!
end

Instance Method Details

#circuit_breaker_config ⇒ Object

Get circuit breaker configuration



108
109
110
 
# File 'lib/aidp/harness/configuration.rb', line 108

def circuit_breaker_config
  harness_config[:circuit_breaker] || get_default_circuit_breaker_config
end

#config_exists? ⇒ Boolean

Check if configuration file exists

Returns:

  • (Boolean) 


203
204
205
 
# File 'lib/aidp/harness/configuration.rb', line 203

def config_exists?
  Aidp::Config.config_exists?(@project_dir)
end

#config_path ⇒ Object

Get configuration path



188
189
190
 
# File 'lib/aidp/harness/configuration.rb', line 188

def config_path
  File.join(@project_dir, "aidp.yml")
end

#configuration_summary ⇒ Object

Get configuration summary



234
235
236
237
238
239
240
241
242
243
244
245
246
247
 
# File 'lib/aidp/harness/configuration.rb', line 234

def configuration_summary
  {
    providers: configured_providers.size,
    default_provider: default_provider,
    fallback_providers: fallback_providers.size,
    max_retries: max_retries,
    no_api_keys_required: no_api_keys_required?,
    load_balancing_enabled: load_balancing_config[:enabled],
    model_switching_enabled: model_switching_config[:enabled],
    circuit_breaker_enabled: circuit_breaker_config[:enabled],
    health_check_enabled: health_check_config[:enabled],
    metrics_enabled: metrics_config[:enabled]
  }
end

#configured_providers ⇒ Object

Get all configured providers



26
27
28
 
# File 'lib/aidp/harness/configuration.rb', line 26

def configured_providers
  @config[:providers]&.keys&.map(&:to_s) || []
end

#create_example_config ⇒ Object

Create example configuration



208
209
210
 
# File 'lib/aidp/harness/configuration.rb', line 208

def create_example_config
  Aidp::Config.create_example_config(@project_dir)
end

#default_flags(provider_name) ⇒ Object

Get default flags for a provider



61
62
63
 
# File 'lib/aidp/harness/configuration.rb', line 61

def default_flags(provider_name)
  provider_config(provider_name)[:default_flags] || []
end

#default_model(provider_name) ⇒ Object

Get default model for provider



71
72
73
74
 
# File 'lib/aidp/harness/configuration.rb', line 71

def default_model(provider_name)
  models = provider_models(provider_name)
  models.first || get_default_model_for_provider(provider_name)
end

#default_provider ⇒ Object

Get default provider



31
32
33
 
# File 'lib/aidp/harness/configuration.rb', line 31

def default_provider
  harness_config[:default_provider]
end

#fallback_config ⇒ Object

Get fallback configuration



198
199
200
 
# File 'lib/aidp/harness/configuration.rb', line 198

def fallback_config
  harness_config[:fallback] || get_default_fallback_config
end

#fallback_providers ⇒ Object

Get fallback providers



36
37
38
 
# File 'lib/aidp/harness/configuration.rb', line 36

def fallback_providers
  harness_config[:fallback_providers]
end

#harness_config ⇒ Object

Get harness-specific configuration



16
17
18
 
# File 'lib/aidp/harness/configuration.rb', line 16

def harness_config
  @config[:harness]
end

#health_check_config ⇒ Object

Get provider health check configuration



133
134
135
 
# File 'lib/aidp/harness/configuration.rb', line 133

def health_check_config
  harness_config[:health_check] || get_default_health_check_config
end

#load_balancing_config ⇒ Object

Get load balancing configuration



123
124
125
 
# File 'lib/aidp/harness/configuration.rb', line 123

def load_balancing_config
  harness_config[:load_balancing] || get_default_load_balancing_config
end

#logging_config ⇒ Object

Get logging configuration



193
194
195
 
# File 'lib/aidp/harness/configuration.rb', line 193

def logging_config
  harness_config[:logging] || get_default_logging_config
end

#max_retries ⇒ Object

Get maximum retries



41
42
43
 
# File 'lib/aidp/harness/configuration.rb', line 41

def max_retries
  harness_config[:max_retries]
end

#max_tokens(provider_name) ⇒ Object

Get maximum tokens for API providers



56
57
58
 
# File 'lib/aidp/harness/configuration.rb', line 56

def max_tokens(provider_name)
  provider_config(provider_name)[:max_tokens]
end

#metrics_config ⇒ Object

Get metrics configuration



138
139
140
 
# File 'lib/aidp/harness/configuration.rb', line 138

def metrics_config
  harness_config[:metrics] || get_default_metrics_config
end

#model_config(provider_name, model_name) ⇒ Object

Get model configuration for provider



77
78
79
80
 
# File 'lib/aidp/harness/configuration.rb', line 77

def model_config(provider_name, model_name)
  models_config = provider_config(provider_name)[:models_config] || {}
  models_config[model_name] || {}
end

#model_flags(provider_name, model_name) ⇒ Object

Get model-specific flags



83
84
85
 
# File 'lib/aidp/harness/configuration.rb', line 83

def model_flags(provider_name, model_name)
  model_config(provider_name, model_name)[:flags] || []
end

#model_max_tokens(provider_name, model_name) ⇒ Object

Get model-specific max tokens



88
89
90
 
# File 'lib/aidp/harness/configuration.rb', line 88

def model_max_tokens(provider_name, model_name)
  model_config(provider_name, model_name)[:max_tokens] || max_tokens(provider_name)
end

#model_switching_config ⇒ Object

Get model switching configuration



128
129
130
 
# File 'lib/aidp/harness/configuration.rb', line 128

def model_switching_config
  harness_config[:model_switching] || get_default_model_switching_config
end

#model_timeout(provider_name, model_name) ⇒ Object

Get model-specific timeout



93
94
95
 
# File 'lib/aidp/harness/configuration.rb', line 93

def model_timeout(provider_name, model_name)
  model_config(provider_name, model_name)[:timeout] || get_default_timeout_for_provider(provider_name)
end

#model_weights(provider_name) ⇒ Object

Get model weights for load balancing



103
104
105
 
# File 'lib/aidp/harness/configuration.rb', line 103

def model_weights(provider_name)
  provider_config(provider_name)[:model_weights] || {}
end

#no_api_keys_required? ⇒ Boolean

Check if restricted to providers that don’t require API keys

Returns:

  • (Boolean) 


46
47
48
 
# File 'lib/aidp/harness/configuration.rb', line 46

def no_api_keys_required?
  harness_config[:no_api_keys_required]
end

#provider_auth_config(provider_name) ⇒ Object

Get provider authentication configuration



163
164
165
 
# File 'lib/aidp/harness/configuration.rb', line 163

def provider_auth_config(provider_name)
  provider_config(provider_name)[:auth] || {}
end

#provider_config(provider_name) ⇒ Object

Get provider configuration



21
22
23
 
# File 'lib/aidp/harness/configuration.rb', line 21

def provider_config(provider_name)
  @config.dig(:providers, provider_name.to_sym) || {}
end

#provider_configured?(provider_name) ⇒ Boolean

Check if provider is configured

Returns:

  • (Boolean) 


183
184
185
 
# File 'lib/aidp/harness/configuration.rb', line 183

def provider_configured?(provider_name)
  configured_providers.include?(provider_name.to_s)
end

#provider_cost_config(provider_name) ⇒ Object

Get provider cost configuration



153
154
155
 
# File 'lib/aidp/harness/configuration.rb', line 153

def provider_cost_config(provider_name)
  provider_config(provider_name)[:cost] || {}
end

#provider_endpoints(provider_name) ⇒ Object

Get provider endpoint configuration



168
169
170
 
# File 'lib/aidp/harness/configuration.rb', line 168

def provider_endpoints(provider_name)
  provider_config(provider_name)[:endpoints] || {}
end

#provider_features(provider_name) ⇒ Object

Get provider feature flags



173
174
175
 
# File 'lib/aidp/harness/configuration.rb', line 173

def provider_features(provider_name)
  provider_config(provider_name)[:features] || {}
end

#provider_models(provider_name) ⇒ Object

Get provider models configuration



66
67
68
 
# File 'lib/aidp/harness/configuration.rb', line 66

def provider_models(provider_name)
  provider_config(provider_name)[:models] || get_default_models_for_provider(provider_name)
end

#provider_monitoring_config(provider_name) ⇒ Object

Get provider monitoring configuration



178
179
180
 
# File 'lib/aidp/harness/configuration.rb', line 178

def provider_monitoring_config(provider_name)
  provider_config(provider_name)[:monitoring] || {}
end

#provider_priority(provider_name) ⇒ Object

Get provider priority



148
149
150
 
# File 'lib/aidp/harness/configuration.rb', line 148

def provider_priority(provider_name)
  provider_config(provider_name)[:priority] || 0
end

#provider_regions(provider_name) ⇒ Object

Get provider region configuration



158
159
160
 
# File 'lib/aidp/harness/configuration.rb', line 158

def provider_regions(provider_name)
  provider_config(provider_name)[:regions] || []
end

#provider_type(provider_name) ⇒ Object

Get provider type (api, package, etc.)



51
52
53
 
# File 'lib/aidp/harness/configuration.rb', line 51

def provider_type(provider_name)
  provider_config(provider_name)[:type] || "unknown"
end

#provider_weights ⇒ Object

Get provider weights for load balancing



98
99
100
 
# File 'lib/aidp/harness/configuration.rb', line 98

def provider_weights
  harness_config[:provider_weights] || {}
end

#rate_limit_config ⇒ Object

Get rate limit configuration



118
119
120
 
# File 'lib/aidp/harness/configuration.rb', line 118

def rate_limit_config
  harness_config[:rate_limit] || get_default_rate_limit_config
end

#raw_config ⇒ Object

Get raw configuration



213
214
215
 
# File 'lib/aidp/harness/configuration.rb', line 213

def raw_config
  @config.dup
end

#retry_config ⇒ Object

Get retry configuration



113
114
115
 
# File 'lib/aidp/harness/configuration.rb', line 113

def retry_config
  harness_config[:retry] || get_default_retry_config
end

#session_config ⇒ Object

Get session configuration



143
144
145
 
# File 'lib/aidp/harness/configuration.rb', line 143

def session_config
  harness_config[:session] || get_default_session_config
end

#validate_model_config(provider_name, model_name, model_config, errors) ⇒ Object

Validate model configuration



218
219
220
221
222
223
224
225
226
227
228
229
230
231
 
# File 'lib/aidp/harness/configuration.rb', line 218

def validate_model_config(provider_name, model_name, model_config, errors)
  # Validate model-specific fields
  if model_config[:max_tokens] && !model_config[:max_tokens].is_a?(Integer)
    errors << "Model '#{provider_name}:#{model_name}' max_tokens must be integer"
  end

  if model_config[:timeout] && !model_config[:timeout].is_a?(Integer)
    errors << "Model '#{provider_name}:#{model_name}' timeout must be integer"
  end

  if model_config[:flags] && !model_config[:flags].is_a?(Array)
    errors << "Model '#{provider_name}:#{model_name}' flags must be array"
  end
end

#validate_provider_config(provider_name) ⇒ Object

Validate provider configuration



250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
 
# File 'lib/aidp/harness/configuration.rb', line 250

def validate_provider_config(provider_name)
  errors = []

  unless provider_configured?(provider_name)
    errors << "Provider '#{provider_name}' not configured"
    return errors
  end

  # Validate provider type
  provider_type = provider_type(provider_name)
  unless %w[usage_based subscription passthrough].include?(provider_type)
    errors << "Provider '#{provider_name}' has invalid type: #{provider_type}"
  end

  # Validate required fields based on type
  case provider_type
  when "usage_based"
    unless max_tokens(provider_name)
      errors << "Provider '#{provider_name}' missing max_tokens for usage_based type"
    end
  when "passthrough"
    unless provider_config(provider_name)[:underlying_service]
      errors << "Provider '#{provider_name}' missing underlying_service for passthrough type"
    end
  end

  errors
end