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 Attribute Summary collapse

Instance Method Summary collapse

Methods included from ProviderTypeChecker

#get_provider_type, #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.



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

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

Instance Attribute Details

#project_dir ⇒ Object (readonly)

Returns the value of attribute project_dir.



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

def project_dir
  @project_dir
end

Instance Method Details

#all_providers(options = {}) ⇒ Object

Get all provider configurations



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

def all_providers(options = {})
  config = config(options)
  return {} unless config

  config[:providers] || {}
end

#circuit_breaker_config(options = {}) ⇒ Object

Get circuit breaker configuration



112
113
114
115
116
117
118
119
120
121
122
 
# File 'lib/aidp/harness/config_manager.rb', line 112

def circuit_breaker_config(options = {})
  harness_config = 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

#config(options = {}) ⇒ Object

Get complete configuration



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

def 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

#config_summary ⇒ Object

Get configuration summary



353
354
355
 
# File 'lib/aidp/harness/config_manager.rb', line 353

def config_summary
  @loader.config_summary
end

#config_valid? ⇒ Boolean

Check if configuration is valid

Returns:

  • (Boolean) 


331
332
333
 
# File 'lib/aidp/harness/config_manager.rb', line 331

def config_valid?
  @loader.config_valid?
end

#default_provider(options = {}) ⇒ Object

Get default provider



67
68
69
70
 
# File 'lib/aidp/harness/config_manager.rb', line 67

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

#fallback_providers(options = {}) ⇒ Object

Get fallback providers



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

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 = provider_names(options)
  fallback_providers.select { |provider| configured_providers.include?(provider) }
end

#harness_config(options = {}) ⇒ Object

Get harness configuration



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

def harness_config(options = {})
  config = config(options)
  return nil unless config

  config[:harness] || {}
end

#health_check_config(options = {}) ⇒ Object

Get health check configuration



164
165
166
167
168
169
170
171
172
173
174
175
 
# File 'lib/aidp/harness/config_manager.rb', line 164

def health_check_config(options = {})
  harness_config = 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

#load_balancing_config(options = {}) ⇒ Object

Get load balancing configuration



138
139
140
141
142
143
144
145
146
147
148
 
# File 'lib/aidp/harness/config_manager.rb', line 138

def load_balancing_config(options = {})
  harness_config = 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

#max_retries(options = {}) ⇒ Object

Get max retries (alias for backward compatibility with ErrorHandler)



107
108
109
 
# File 'lib/aidp/harness/config_manager.rb', line 107

def max_retries(options = {})
  retry_config(options)[:max_attempts]
end

#metrics_config(options = {}) ⇒ Object

Get metrics configuration



178
179
180
181
182
183
184
185
186
187
188
 
# File 'lib/aidp/harness/config_manager.rb', line 178

def metrics_config(options = {})
  harness_config = 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

#model_switching_config(options = {}) ⇒ Object

Get model switching configuration



151
152
153
154
155
156
157
158
159
160
161
 
# File 'lib/aidp/harness/config_manager.rb', line 151

def model_switching_config(options = {})
  harness_config = 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

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

Get provider auth configuration



306
307
308
309
310
311
312
313
314
315
316
 
# File 'lib/aidp/harness/config_manager.rb', line 306

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"] || {}

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

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

Get provider configuration



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

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

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

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

Get provider default flags



297
298
299
300
301
302
303
 
# File 'lib/aidp/harness/config_manager.rb', line 297

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"] || []
  flags.map(&:to_s)
end

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

Get provider endpoints



319
320
321
322
323
324
325
326
327
328
 
# File 'lib/aidp/harness/config_manager.rb', line 319

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

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

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

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

Get provider features



237
238
239
240
241
242
243
244
245
246
247
248
249
 
# File 'lib/aidp/harness/config_manager.rb', line 237

def provider_features(provider_name, options = {})
  provider_config = 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

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

Get provider max tokens



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

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

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

Get provider model configuration



222
223
224
225
226
227
228
229
230
231
232
233
234
 
# File 'lib/aidp/harness/config_manager.rb', line 222

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"] || {}
  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

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

Get provider model weights



213
214
215
216
217
218
219
 
# File 'lib/aidp/harness/config_manager.rb', line 213

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"] || {}
  weights.transform_values { |weight| [weight.to_i, 1].max }
end

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

Get provider models



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

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

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

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

Get provider monitoring configuration



252
253
254
255
256
257
258
259
260
261
262
 
# File 'lib/aidp/harness/config_manager.rb', line 252

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"] || {}

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

#provider_names(options = {}) ⇒ Object

Get configured provider names



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

def provider_names(options = {})
  providers = all_providers(options)
  providers.keys.map(&:to_s)
end

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

Get provider priority



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

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

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

Check if provider supports feature

Returns:

  • (Boolean) 


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

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

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

Get provider type



279
280
281
282
283
284
 
# File 'lib/aidp/harness/config_manager.rb', line 279

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

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

#provider_weights(options = {}) ⇒ Object

Get provider weights



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

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
  weights.transform_values { |weight| [weight.to_i, 1].max }
end

#rate_limit_config(options = {}) ⇒ Object

Get rate limit configuration



125
126
127
128
129
130
131
132
133
134
135
 
# File 'lib/aidp/harness/config_manager.rb', line 125

def rate_limit_config(options = {})
  harness_config = 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

#reload_config ⇒ Object

Reload configuration



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

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

#retry_config(options = {}) ⇒ Object

Get retry configuration



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

def retry_config(options = {})
  harness_config = 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

#session_config(options = {}) ⇒ Object

Get session configuration



191
192
193
194
195
196
197
198
199
200
201
 
# File 'lib/aidp/harness/config_manager.rb', line 191

def session_config(options = {})
  harness_config = 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

#validation_errors ⇒ Object

Get validation errors



336
337
338
 
# File 'lib/aidp/harness/config_manager.rb', line 336

def validation_errors
  @loader.validation_errors
end

#validation_warnings ⇒ Object

Get validation warnings



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

def validation_warnings
  @loader.validation_warnings
end