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

Constant Summary collapse

DEFAULT_PRD_GENERATION = 
{
  interaction_style: "balanced",
  default_style: "balanced",
  max_question_rounds: {
    detailed: 30,
    balanced: 10,
    quick_sketch: 3
  }
}.freeze

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.



25
26
27
28
29
30
 
# File 'lib/aidp/harness/config_manager.rb', line 25

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.



23
24
25
 
# File 'lib/aidp/harness/config_manager.rb', line 23

def project_dir
  @project_dir
end

Instance Method Details

#all_providers(options = {}) ⇒ Object

Get all provider configurations



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

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

  config[:providers] || {}
end

#circuit_breaker_config(options = {}) ⇒ Object

Get circuit breaker configuration



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

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



33
34
35
36
37
38
39
40
41
42
43
 
# File 'lib/aidp/harness/config_manager.rb', line 33

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



376
377
378
 
# File 'lib/aidp/harness/config_manager.rb', line 376

def config_summary
  @loader.config_summary
end

#config_valid? ⇒ Boolean

Check if configuration is valid

Returns:

  • (Boolean) 


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

def config_valid?
  @loader.config_valid?
end

#default_provider(options = {}) ⇒ Object

Get default provider



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

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



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

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



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

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

  config[:harness] || {}
end

#health_check_config(options = {}) ⇒ Object

Get health check configuration



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

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



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

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

#metrics_config(options = {}) ⇒ Object

Get metrics configuration



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

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



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

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

#prd_generation_config(options = {}) ⇒ Object 



208
209
210
211
212
213
214
215
216
217
218
219
220
 
# File 'lib/aidp/harness/config_manager.rb', line 208

def prd_generation_config(options = {})
  config = config(options)
  raw_config = config&.dig(:prd_generation) || config&.dig("prd_generation") || {}
  raw_rounds = raw_config[:max_question_rounds] || raw_config["max_question_rounds"] || {}

  {
    interaction_style: raw_config[:interaction_style] || raw_config["interaction_style"] || DEFAULT_PRD_GENERATION[:interaction_style],
    default_style: raw_config[:default_style] || raw_config["default_style"] || DEFAULT_PRD_GENERATION[:default_style],
    max_question_rounds: DEFAULT_PRD_GENERATION[:max_question_rounds].merge(
      symbolize_keys(raw_rounds)
    )
  }
end

#prd_interaction_style(options = {}) ⇒ Object 



222
223
224
 
# File 'lib/aidp/harness/config_manager.rb', line 222

def prd_interaction_style(options = {})
  prd_generation_config(options)[:interaction_style]
end

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

Get provider auth configuration



329
330
331
332
333
334
335
336
337
338
339
 
# File 'lib/aidp/harness/config_manager.rb', line 329

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



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

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



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

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



342
343
344
345
346
347
348
349
350
351
 
# File 'lib/aidp/harness/config_manager.rb', line 342

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



260
261
262
263
264
265
266
267
268
269
270
271
272
 
# File 'lib/aidp/harness/config_manager.rb', line 260

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



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

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



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

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



236
237
238
239
240
241
242
 
# File 'lib/aidp/harness/config_manager.rb', line 236

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



227
228
229
230
231
232
233
 
# File 'lib/aidp/harness/config_manager.rb', line 227

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



275
276
277
278
279
280
281
282
283
284
285
 
# File 'lib/aidp/harness/config_manager.rb', line 275

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



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

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

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

Get provider priority



294
295
296
297
298
299
 
# File 'lib/aidp/harness/config_manager.rb', line 294

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) 


288
289
290
291
 
# File 'lib/aidp/harness/config_manager.rb', line 288

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



302
303
304
305
306
307
 
# File 'lib/aidp/harness/config_manager.rb', line 302

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



93
94
95
96
97
98
99
 
# File 'lib/aidp/harness/config_manager.rb', line 93

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



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

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



369
370
371
372
373
 
# File 'lib/aidp/harness/config_manager.rb', line 369

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

#retry_config(options = {}) ⇒ Object

Get retry configuration



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

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



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

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



359
360
361
 
# File 'lib/aidp/harness/config_manager.rb', line 359

def validation_errors
  @loader.validation_errors
end

#validation_warnings ⇒ Object

Get validation warnings



364
365
366
 
# File 'lib/aidp/harness/config_manager.rb', line 364

def validation_warnings
  @loader.validation_warnings
end