Class: Aidp::Harness::ConfigManager

Inherits:
Object
  • Object
show all
Includes:
ProviderTypeChecker
Defined in:
lib/aidp/harness/config_manager.rb

Overview

Unified configuration manager for harness

Instance Method Summary collapse

Methods included from ProviderTypeChecker

#get_underlying_service, #has_underlying_service?, #passthrough_provider?, #requires_api_key?, #subscription_provider?, #usage_based_provider?

Constructor Details

#initialize(project_dir = Dir.pwd) ⇒ ConfigManager

Returns a new instance of ConfigManager.



13
14
15
16
17
18
 
# File 'lib/aidp/harness/config_manager.rb', line 13

def initialize(project_dir = Dir.pwd)
  @project_dir = project_dir
  @loader = ConfigLoader.new(project_dir)
  @cache = {}
  @cache_timestamp = nil
end

Instance Method Details

#config_valid? ⇒ Boolean

Check if configuration is valid

Returns:

  • (Boolean) 


324
325
326
 
# File 'lib/aidp/harness/config_manager.rb', line 324

def config_valid?
  @loader.config_valid?
end

#get_all_providers(options = {}) ⇒ Object

Get all provider configurations



51
52
53
54
55
56
 
# File 'lib/aidp/harness/config_manager.rb', line 51

def get_all_providers(options = {})
  config = get_config(options)
  return {} unless config

  config[:providers] || {}
end

#get_circuit_breaker_config(options = {}) ⇒ Object

Get circuit breaker configuration



105
106
107
108
109
110
111
112
113
114
115
 
# File 'lib/aidp/harness/config_manager.rb', line 105

def get_circuit_breaker_config(options = {})
  harness_config = get_harness_config(options)
  cb_config = harness_config[:circuit_breaker] || harness_config["circuit_breaker"] || {}

  {
    enabled: cb_config[:enabled] != false,
    failure_threshold: cb_config[:failure_threshold] || 5,
    timeout: cb_config[:timeout] || 300,
    half_open_max_calls: cb_config[:half_open_max_calls] || 3
  }
end

#get_config(options = {}) ⇒ Object

Get complete configuration



21
22
23
24
25
26
27
28
29
30
31
 
# File 'lib/aidp/harness/config_manager.rb', line 21

def get_config(options = {})
  cache_key = "config_#{options.hash}"

  if cache_valid?(cache_key)
    return @cache[cache_key]
  end

  config = load_config_with_options(options)
  @cache[cache_key] = config if config
  config
end

#get_config_summary ⇒ Object

Get configuration summary



346
347
348
 
# File 'lib/aidp/harness/config_manager.rb', line 346

def get_config_summary
  @loader.get_config_summary
end

#get_default_provider(options = {}) ⇒ Object

Get default provider



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

def get_default_provider(options = {})
  harness_config = get_harness_config(options)
  harness_config[:default_provider] || harness_config["default_provider"]
end

#get_fallback_providers(options = {}) ⇒ Object

Get fallback providers



71
72
73
74
75
76
77
78
 
# File 'lib/aidp/harness/config_manager.rb', line 71

def get_fallback_providers(options = {})
  harness_config = get_harness_config(options)
  fallback_providers = harness_config[:fallback_providers] || harness_config["fallback_providers"] || []

  # Ensure fallback providers are configured
  configured_providers = get_provider_names(options)
  fallback_providers.select { |provider| configured_providers.include?(provider) }
end

#get_harness_config(options = {}) ⇒ Object

Get harness configuration



34
35
36
37
38
39
 
# File 'lib/aidp/harness/config_manager.rb', line 34

def get_harness_config(options = {})
  config = get_config(options)
  return nil unless config

  config[:harness] || {}
end

#get_health_check_config(options = {}) ⇒ Object

Get health check configuration



157
158
159
160
161
162
163
164
165
166
167
168
 
# File 'lib/aidp/harness/config_manager.rb', line 157

def get_health_check_config(options = {})
  harness_config = get_harness_config(options)
  hc_config = harness_config[:health_check] || harness_config["health_check"] || {}

  {
    enabled: hc_config[:enabled] != false,
    interval: hc_config[:interval] || 60,
    timeout: hc_config[:timeout] || 10,
    failure_threshold: hc_config[:failure_threshold] || 3,
    success_threshold: hc_config[:success_threshold] || 2
  }
end

#get_load_balancing_config(options = {}) ⇒ Object

Get load balancing configuration



131
132
133
134
135
136
137
138
139
140
141
 
# File 'lib/aidp/harness/config_manager.rb', line 131

def get_load_balancing_config(options = {})
  harness_config = get_harness_config(options)
  lb_config = harness_config[:load_balancing] || harness_config["load_balancing"] || {}

  {
    enabled: lb_config[:enabled] != false,
    strategy: lb_config[:strategy] || "weighted_round_robin",
    health_check_interval: lb_config[:health_check_interval] || 30,
    unhealthy_threshold: lb_config[:unhealthy_threshold] || 3
  }
end

#get_metrics_config(options = {}) ⇒ Object

Get metrics configuration



171
172
173
174
175
176
177
178
179
180
181
 
# File 'lib/aidp/harness/config_manager.rb', line 171

def get_metrics_config(options = {})
  harness_config = get_harness_config(options)
  metrics_config = harness_config[:metrics] || harness_config["metrics"] || {}

  {
    enabled: metrics_config[:enabled] != false,
    retention_days: metrics_config[:retention_days] || 30,
    aggregation_interval: metrics_config[:aggregation_interval] || 300,
    export_interval: metrics_config[:export_interval] || 3600
  }
end

#get_model_switching_config(options = {}) ⇒ Object

Get model switching configuration



144
145
146
147
148
149
150
151
152
153
154
 
# File 'lib/aidp/harness/config_manager.rb', line 144

def get_model_switching_config(options = {})
  harness_config = get_harness_config(options)
  ms_config = harness_config[:model_switching] || harness_config["model_switching"] || {}

  {
    enabled: ms_config[:enabled] != false,
    auto_switch_on_error: ms_config[:auto_switch_on_error] != false,
    auto_switch_on_rate_limit: ms_config[:auto_switch_on_rate_limit] != false,
    fallback_strategy: ms_config[:fallback_strategy] || "sequential"
  }
end

#get_provider_auth_config(provider_name, options = {}) ⇒ Object

Get provider auth configuration



299
300
301
302
303
304
305
306
307
308
309
 
# File 'lib/aidp/harness/config_manager.rb', line 299

def get_provider_auth_config(provider_name, options = {})
  provider_config = get_provider_config(provider_name, options)
  return {} unless provider_config

  auth = provider_config[:auth] || provider_config["auth"] || {}

  {
    api_key_env: auth[:api_key_env] || auth["api_key_env"],
    api_key: auth[:api_key] || auth["api_key"]
  }
end

#get_provider_config(provider_name, options = {}) ⇒ Object

Get provider configuration



42
43
44
45
46
47
48
 
# File 'lib/aidp/harness/config_manager.rb', line 42

def get_provider_config(provider_name, options = {})
  config = get_config(options)
  return nil unless config

  providers = config[:providers] || {}
  providers[provider_name.to_sym] || providers[provider_name.to_s]
end

#get_provider_default_flags(provider_name, options = {}) ⇒ Object

Get provider default flags



290
291
292
293
294
295
296
 
# File 'lib/aidp/harness/config_manager.rb', line 290

def get_provider_default_flags(provider_name, options = {})
  provider_config = get_provider_config(provider_name, options)
  return [] unless provider_config

  flags = provider_config[:default_flags] || provider_config["default_flags"] || []
  flags.map(&:to_s)
end

#get_provider_endpoints(provider_name, options = {}) ⇒ Object

Get provider endpoints



312
313
314
315
316
317
318
319
320
321
 
# File 'lib/aidp/harness/config_manager.rb', line 312

def get_provider_endpoints(provider_name, options = {})
  provider_config = get_provider_config(provider_name, options)
  return {} unless provider_config

  endpoints = provider_config[:endpoints] || provider_config["endpoints"] || {}

  {
    default: endpoints[:default] || endpoints["default"]
  }
end

#get_provider_features(provider_name, options = {}) ⇒ Object

Get provider features



230
231
232
233
234
235
236
237
238
239
240
241
242
 
# File 'lib/aidp/harness/config_manager.rb', line 230

def get_provider_features(provider_name, options = {})
  provider_config = get_provider_config(provider_name, options)
  return {} unless provider_config

  features = provider_config[:features] || provider_config["features"] || {}

  {
    file_upload: features[:file_upload] == true,
    code_generation: features[:code_generation] != false,
    analysis: features[:analysis] != false,
    vision: features[:vision] == true
  }
end

#get_provider_max_tokens(provider_name, options = {}) ⇒ Object

Get provider max tokens



282
283
284
285
286
287
 
# File 'lib/aidp/harness/config_manager.rb', line 282

def get_provider_max_tokens(provider_name, options = {})
  provider_config = get_provider_config(provider_name, options)
  return nil unless provider_config

  provider_config[:max_tokens] || provider_config["max_tokens"]
end

#get_provider_model_config(provider_name, model_name, options = {}) ⇒ Object

Get provider model configuration



215
216
217
218
219
220
221
222
223
224
225
226
227
 
# File 'lib/aidp/harness/config_manager.rb', line 215

def get_provider_model_config(provider_name, model_name, options = {})
  provider_config = get_provider_config(provider_name, options)
  return {} unless provider_config

  models_config = provider_config[:models_config] || provider_config["models_config"] || {}
  model_config = models_config[model_name.to_sym] || models_config[model_name.to_s] || {}

  {
    flags: model_config[:flags] || model_config["flags"] || [],
    max_tokens: model_config[:max_tokens] || model_config["max_tokens"],
    timeout: model_config[:timeout] || model_config["timeout"]
  }
end

#get_provider_model_weights(provider_name, options = {}) ⇒ Object

Get provider model weights



206
207
208
209
210
211
212
 
# File 'lib/aidp/harness/config_manager.rb', line 206

def get_provider_model_weights(provider_name, options = {})
  provider_config = get_provider_config(provider_name, options)
  return {} unless provider_config

  weights = provider_config[:model_weights] || provider_config["model_weights"] || {}
  weights.transform_values { |weight| [weight.to_i, 1].max }
end

#get_provider_models(provider_name, options = {}) ⇒ Object

Get provider models



197
198
199
200
201
202
203
 
# File 'lib/aidp/harness/config_manager.rb', line 197

def get_provider_models(provider_name, options = {})
  provider_config = get_provider_config(provider_name, options)
  return [] unless provider_config

  models = provider_config[:models] || provider_config["models"] || []
  models.map(&:to_s)
end

#get_provider_monitoring_config(provider_name, options = {}) ⇒ Object

Get provider monitoring configuration



245
246
247
248
249
250
251
252
253
254
255
 
# File 'lib/aidp/harness/config_manager.rb', line 245

def get_provider_monitoring_config(provider_name, options = {})
  provider_config = get_provider_config(provider_name, options)
  return {} unless provider_config

  monitoring = provider_config[:monitoring] || provider_config["monitoring"] || {}

  {
    enabled: monitoring[:enabled] != false,
    metrics_interval: monitoring[:metrics_interval] || 60
  }
end

#get_provider_names(options = {}) ⇒ Object

Get configured provider names



59
60
61
62
 
# File 'lib/aidp/harness/config_manager.rb', line 59

def get_provider_names(options = {})
  providers = get_all_providers(options)
  providers.keys.map(&:to_s)
end

#get_provider_priority(provider_name, options = {}) ⇒ Object

Get provider priority



264
265
266
267
268
269
 
# File 'lib/aidp/harness/config_manager.rb', line 264

def get_provider_priority(provider_name, options = {})
  provider_config = get_provider_config(provider_name, options)
  return 1 unless provider_config

  provider_config[:priority] || provider_config["priority"] || 1
end

#get_provider_type(provider_name, options = {}) ⇒ Object

Get provider type



272
273
274
275
276
277
 
# File 'lib/aidp/harness/config_manager.rb', line 272

def get_provider_type(provider_name, options = {})
  provider_config = get_provider_config(provider_name, options)
  return nil unless provider_config

  provider_config[:type] || provider_config["type"]
end

#get_provider_weights(options = {}) ⇒ Object

Get provider weights



81
82
83
84
85
86
87
 
# File 'lib/aidp/harness/config_manager.rb', line 81

def get_provider_weights(options = {})
  harness_config = get_harness_config(options)
  weights = harness_config[:provider_weights] || harness_config["provider_weights"] || {}

  # Normalize weights to ensure they're positive integers
  weights.transform_values { |weight| [weight.to_i, 1].max }
end

#get_rate_limit_config(options = {}) ⇒ Object

Get rate limit configuration



118
119
120
121
122
123
124
125
126
127
128
 
# File 'lib/aidp/harness/config_manager.rb', line 118

def get_rate_limit_config(options = {})
  harness_config = get_harness_config(options)
  rate_limit_config = harness_config[:rate_limit] || harness_config["rate_limit"] || {}

  {
    enabled: rate_limit_config[:enabled] != false,
    default_reset_time: rate_limit_config[:default_reset_time] || 3600,
    burst_limit: rate_limit_config[:burst_limit] || 10,
    sustained_limit: rate_limit_config[:sustained_limit] || 5
  }
end

#get_retry_config(options = {}) ⇒ Object

Get retry configuration



90
91
92
93
94
95
96
97
98
99
100
101
102
 
# File 'lib/aidp/harness/config_manager.rb', line 90

def get_retry_config(options = {})
  harness_config = get_harness_config(options)
  retry_config = harness_config[:retry] || harness_config["retry"] || {}

  {
    enabled: retry_config[:enabled] != false,
    max_attempts: retry_config[:max_attempts] || 3,
    base_delay: retry_config[:base_delay] || 1.0,
    max_delay: retry_config[:max_delay] || 60.0,
    exponential_base: retry_config[:exponential_base] || 2.0,
    jitter: retry_config[:jitter] != false
  }
end

#get_session_config(options = {}) ⇒ Object

Get session configuration



184
185
186
187
188
189
190
191
192
193
194
 
# File 'lib/aidp/harness/config_manager.rb', line 184

def get_session_config(options = {})
  harness_config = get_harness_config(options)
  session_config = harness_config[:session] || harness_config["session"] || {}

  {
    enabled: session_config[:enabled] != false,
    timeout: session_config[:timeout] || 1800,
    sticky_sessions: session_config[:sticky_sessions] != false,
    session_affinity: session_config[:session_affinity] || "provider_model"
  }
end

#get_validation_errors ⇒ Object

Get validation errors



329
330
331
 
# File 'lib/aidp/harness/config_manager.rb', line 329

def get_validation_errors
  @loader.get_validation_errors
end

#get_validation_warnings ⇒ Object

Get validation warnings



334
335
336
 
# File 'lib/aidp/harness/config_manager.rb', line 334

def get_validation_warnings
  @loader.get_validation_warnings
end

#provider_supports_feature?(provider_name, feature, options = {}) ⇒ Boolean

Check if provider supports feature

Returns:

  • (Boolean) 


258
259
260
261
 
# File 'lib/aidp/harness/config_manager.rb', line 258

def provider_supports_feature?(provider_name, feature, options = {})
  features = get_provider_features(provider_name, options)
  features[feature.to_sym] == true
end

#reload_config ⇒ Object

Reload configuration



339
340
341
342
343
 
# File 'lib/aidp/harness/config_manager.rb', line 339

def reload_config
  @cache.clear
  @cache_timestamp = nil
  @loader.reload_config
end