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

Instance Method Summary collapse

Constructor Details

#initialize(project_dir) ⇒ Configuration

Returns a new instance of Configuration.



12
13
14
15
16
 
# File 'lib/aidp/harness/configuration.rb', line 12

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

Instance Attribute Details

#project_dir ⇒ Object (readonly)

Returns the value of attribute project_dir.



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

def project_dir
  @project_dir
end

Instance Method Details

#allow_provider_switch_for_tier? ⇒ Boolean

Check if provider switching for tier is allowed

Returns:

  • (Boolean) 


395
396
397
 
# File 'lib/aidp/harness/configuration.rb', line 395

def allow_provider_switch_for_tier?
  thinking_config[:allow_provider_switch] != false
end

#auto_escalate? ⇒ Boolean

Check if auto-escalation is enabled

Returns:

  • (Boolean) 


518
519
520
 
# File 'lib/aidp/harness/configuration.rb', line 518

def auto_escalate?
  thinking_config[:auto_escalate] != false
end

#build_commands ⇒ Object

Get build commands



185
186
187
 
# File 'lib/aidp/harness/configuration.rb', line 185

def build_commands
  normalize_commands(work_loop_config[:build_commands] || [])
end

#circuit_breaker_config ⇒ Object

Get circuit breaker configuration



111
112
113
 
# File 'lib/aidp/harness/configuration.rb', line 111

def circuit_breaker_config
  harness_config[:circuit_breaker] || default_circuit_breaker_config
end

#config_exists? ⇒ Boolean

Check if configuration file exists

Returns:

  • (Boolean) 


441
442
443
 
# File 'lib/aidp/harness/configuration.rb', line 441

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

#config_path ⇒ Object

Get configuration path



370
371
372
 
# File 'lib/aidp/harness/configuration.rb', line 370

def config_path
  Aidp::ConfigPaths.config_file(@project_dir)
end

#configuration_summary ⇒ Object

Get configuration summary



472
473
474
475
476
477
478
479
480
481
482
483
484
485
 
# File 'lib/aidp/harness/configuration.rb', line 472

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



29
30
31
 
# File 'lib/aidp/harness/configuration.rb', line 29

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

#conventional_commits? ⇒ Boolean

Check if conventional commits are enabled

Returns:

  • (Boolean) 


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

def conventional_commits?
  version_control_config[:conventional_commits] == true
end

#coverage_config ⇒ Object

Get coverage configuration



270
271
272
 
# File 'lib/aidp/harness/configuration.rb', line 270

def coverage_config
  work_loop_config[:coverage] || default_coverage_config
end

#coverage_enabled? ⇒ Boolean

Check if coverage is enabled

Returns:

  • (Boolean) 


275
276
277
 
# File 'lib/aidp/harness/configuration.rb', line 275

def coverage_enabled?
  coverage_config[:enabled] == true
end

#coverage_fail_on_drop? ⇒ Boolean

Check if should fail on coverage drop

Returns:

  • (Boolean) 


295
296
297
 
# File 'lib/aidp/harness/configuration.rb', line 295

def coverage_fail_on_drop?
  coverage_config[:fail_on_drop] == true
end

#coverage_minimum ⇒ Object

Get minimum coverage threshold



300
301
302
 
# File 'lib/aidp/harness/configuration.rb', line 300

def coverage_minimum
  coverage_config[:minimum_coverage]
end

#coverage_report_paths ⇒ Object

Get coverage report paths



290
291
292
 
# File 'lib/aidp/harness/configuration.rb', line 290

def coverage_report_paths
  coverage_config[:report_paths] || []
end

#coverage_run_command ⇒ Object

Get coverage run command



285
286
287
 
# File 'lib/aidp/harness/configuration.rb', line 285

def coverage_run_command
  coverage_config[:run_command]
end

#coverage_tool ⇒ Object

Get coverage tool



280
281
282
 
# File 'lib/aidp/harness/configuration.rb', line 280

def coverage_tool
  coverage_config[:tool]
end

#create_example_config ⇒ Object

Create example configuration



446
447
448
 
# File 'lib/aidp/harness/configuration.rb', line 446

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

#default_flags(provider_name) ⇒ Object

Get default flags for a provider



64
65
66
 
# File 'lib/aidp/harness/configuration.rb', line 64

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

#default_model(provider_name) ⇒ Object

Get default model for provider



74
75
76
77
 
# File 'lib/aidp/harness/configuration.rb', line 74

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

#default_provider ⇒ Object

Get default provider



34
35
36
 
# File 'lib/aidp/harness/configuration.rb', line 34

def default_provider
  harness_config[:default_provider]
end

#default_tier ⇒ Object

Get default thinking tier



385
386
387
 
# File 'lib/aidp/harness/configuration.rb', line 385

def default_tier
  thinking_config[:default_tier] || "standard"
end

#devcontainer_allowed_domains ⇒ Object

Get allowed domains for devcontainer firewall



723
724
725
 
# File 'lib/aidp/harness/configuration.rb', line 723

def devcontainer_allowed_domains
  devcontainer_settings[:allowed_domains] || []
end

#devcontainer_config ⇒ Object

Get devcontainer configuration



639
640
641
642
643
644
645
646
647
648
649
650
 
# File 'lib/aidp/harness/configuration.rb', line 639

def devcontainer_config
  return @devcontainer_config if defined?(@devcontainer_config)

  raw_config = @config[:devcontainer] || @config["devcontainer"]
  base = deep_dup(default_devcontainer_config)

  @devcontainer_config = if raw_config.is_a?(Hash)
    deep_merge_hashes(base, deep_symbolize_keys(raw_config))
  else
    base
  end
end

#devcontainer_dangerous_ops_allowed? ⇒ Boolean

Check if dangerous filesystem operations are allowed in devcontainer

Returns:

  • (Boolean) 


685
686
687
 
# File 'lib/aidp/harness/configuration.rb', line 685

def devcontainer_dangerous_ops_allowed?
  devcontainer_permissions[:dangerous_filesystem_ops] == true
end

#devcontainer_enabled? ⇒ Boolean

Check if devcontainer features are enabled

Returns:

  • (Boolean) 


653
654
655
 
# File 'lib/aidp/harness/configuration.rb', line 653

def devcontainer_enabled?
  devcontainer_config[:enabled] != false
end

#devcontainer_force_detection ⇒ Object

Get forced detection value (nil for auto-detection)



663
664
665
 
# File 'lib/aidp/harness/configuration.rb', line 663

def devcontainer_force_detection
  devcontainer_config[:force_detection]
end

#devcontainer_permissions ⇒ Object

Get devcontainer permissions config



677
678
679
680
681
682
 
# File 'lib/aidp/harness/configuration.rb', line 677

def devcontainer_permissions
  permissions = devcontainer_config[:permissions]
  return {} unless permissions.is_a?(Hash)

  permissions.transform_keys { |key| key.to_sym }
end

#devcontainer_settings ⇒ Object

Get devcontainer settings



708
709
710
 
# File 'lib/aidp/harness/configuration.rb', line 708

def devcontainer_settings
  devcontainer_config[:settings] || {}
end

#devcontainer_skip_permission_checks ⇒ Object

Get list of providers that should skip permission checks in devcontainer



690
691
692
693
694
695
696
697
698
699
700
 
# File 'lib/aidp/harness/configuration.rb', line 690

def devcontainer_skip_permission_checks
  permissions = devcontainer_config[:permissions]
  list = nil

  if permissions.is_a?(Hash)
    list = permissions[:skip_permission_checks] || permissions["skip_permission_checks"]
  end

  list = default_skip_permission_checks if list.nil?
  Array(list).map(&:to_s)
end

#devcontainer_skip_permissions_for?(provider_name) ⇒ Boolean

Check if a specific provider should skip permission checks in devcontainer

Returns:

  • (Boolean) 


703
704
705
 
# File 'lib/aidp/harness/configuration.rb', line 703

def devcontainer_skip_permissions_for?(provider_name)
  devcontainer_skip_permission_checks.include?(provider_name.to_s)
end

#devcontainer_timeout_multiplier ⇒ Object

Get timeout multiplier for devcontainer



713
714
715
 
# File 'lib/aidp/harness/configuration.rb', line 713

def devcontainer_timeout_multiplier
  devcontainer_settings[:timeout_multiplier] || 1.0
end

#devcontainer_verbose_logging? ⇒ Boolean

Check if verbose logging is enabled in devcontainer

Returns:

  • (Boolean) 


718
719
720
 
# File 'lib/aidp/harness/configuration.rb', line 718

def devcontainer_verbose_logging?
  devcontainer_settings[:verbose_logging] == true
end

#documentation_commands ⇒ Object

Get documentation commands



190
191
192
 
# File 'lib/aidp/harness/configuration.rb', line 190

def documentation_commands
  normalize_commands(work_loop_config[:documentation_commands] || [])
end

#escalation_complexity_threshold ⇒ Object

Get complexity threshold configuration for escalation



410
411
412
 
# File 'lib/aidp/harness/configuration.rb', line 410

def escalation_complexity_threshold
  escalation_config[:on_complexity_threshold] || {}
end

#escalation_config ⇒ Object

Get escalation configuration



400
401
402
 
# File 'lib/aidp/harness/configuration.rb', line 400

def escalation_config
  thinking_config[:escalation] || default_escalation_config
end

#escalation_fail_attempts ⇒ Object

Get fail attempts threshold for escalation



405
406
407
 
# File 'lib/aidp/harness/configuration.rb', line 405

def escalation_fail_attempts
  escalation_config[:on_fail_attempts] || 2
end

#escalation_threshold ⇒ Object

Get escalation threshold



523
524
525
 
# File 'lib/aidp/harness/configuration.rb', line 523

def escalation_threshold
  thinking_config[:escalation_threshold] || 2
end

#fallback_config ⇒ Object

Get fallback configuration



436
437
438
 
# File 'lib/aidp/harness/configuration.rb', line 436

def fallback_config
  harness_config[:fallback] || default_fallback_config
end

#fallback_providers ⇒ Object

Get fallback providers



39
40
41
 
# File 'lib/aidp/harness/configuration.rb', line 39

def fallback_providers
  harness_config[:fallback_providers]
end

#formatter_commands ⇒ Object

Get formatter commands



180
181
182
 
# File 'lib/aidp/harness/configuration.rb', line 180

def formatter_commands
  normalize_commands(work_loop_config[:formatter_commands] || [])
end

#full_permissions_in_devcontainer? ⇒ Boolean

Check if full permissions should be granted in devcontainer

Returns:

  • (Boolean) 


658
659
660
 
# File 'lib/aidp/harness/configuration.rb', line 658

def full_permissions_in_devcontainer?
  devcontainer_config[:full_permissions_when_in_devcontainer] == true
end

#guards_bypass? ⇒ Boolean

Check if guards are bypassed

Returns:

  • (Boolean) 


245
246
247
 
# File 'lib/aidp/harness/configuration.rb', line 245

def guards_bypass?
  guards_config[:bypass] == true
end

#guards_config ⇒ Object

Get guards configuration



215
216
217
 
# File 'lib/aidp/harness/configuration.rb', line 215

def guards_config
  work_loop_config[:guards] || default_guards_config
end

#guards_confirm_files ⇒ Object

Get files requiring confirmation for guards



235
236
237
 
# File 'lib/aidp/harness/configuration.rb', line 235

def guards_confirm_files
  guards_config[:confirm_files] || []
end

#guards_enabled? ⇒ Boolean

Check if guards are enabled

Returns:

  • (Boolean) 


220
221
222
 
# File 'lib/aidp/harness/configuration.rb', line 220

def guards_enabled?
  guards_config[:enabled] == true
end

#guards_exclude_files ⇒ Object

Get exclude file patterns for guards



230
231
232
 
# File 'lib/aidp/harness/configuration.rb', line 230

def guards_exclude_files
  guards_config[:exclude_files] || []
end

#guards_include_files ⇒ Object

Get include file patterns for guards



225
226
227
 
# File 'lib/aidp/harness/configuration.rb', line 225

def guards_include_files
  guards_config[:include_files] || []
end

#guards_max_lines_per_commit ⇒ Object

Get max lines per commit for guards



240
241
242
 
# File 'lib/aidp/harness/configuration.rb', line 240

def guards_max_lines_per_commit
  guards_config[:max_lines_per_commit]
end

#harness_config ⇒ Object

Get harness-specific configuration



19
20
21
 
# File 'lib/aidp/harness/configuration.rb', line 19

def harness_config
  @config[:harness]
end

#health_check_config ⇒ Object

Get provider health check configuration



136
137
138
 
# File 'lib/aidp/harness/configuration.rb', line 136

def health_check_config
  harness_config[:health_check] || default_health_check_config
end

#in_devcontainer? ⇒ Boolean

Check if currently in devcontainer (with optional force override)

Returns:

  • (Boolean) 


668
669
670
671
672
673
674
 
# File 'lib/aidp/harness/configuration.rb', line 668

def in_devcontainer?
  forced = devcontainer_force_detection
  return forced unless forced.nil?

  require_relative "../utils/devcontainer_detector"
  Aidp::Utils::DevcontainerDetector.in_devcontainer?
end

#interactive_testing_app_type ⇒ Object

Get interactive testing app type



315
316
317
 
# File 'lib/aidp/harness/configuration.rb', line 315

def interactive_testing_app_type
  interactive_testing_config[:app_type]
end

#interactive_testing_config ⇒ Object

Get interactive testing configuration



305
306
307
 
# File 'lib/aidp/harness/configuration.rb', line 305

def interactive_testing_config
  work_loop_config[:interactive_testing] || default_interactive_testing_config
end

#interactive_testing_enabled? ⇒ Boolean

Check if interactive testing is enabled

Returns:

  • (Boolean) 


310
311
312
 
# File 'lib/aidp/harness/configuration.rb', line 310

def interactive_testing_enabled?
  interactive_testing_config[:enabled] == true
end

#interactive_testing_tools ⇒ Object

Get interactive testing tools configuration



320
321
322
 
# File 'lib/aidp/harness/configuration.rb', line 320

def interactive_testing_tools
  interactive_testing_config[:tools] || {}
end

#lint_commands ⇒ Object

Get lint commands



175
176
177
 
# File 'lib/aidp/harness/configuration.rb', line 175

def lint_commands
  normalize_commands(work_loop_config[:lint_commands] || [])
end

#lint_max_output_lines ⇒ Object

Get max output lines for linters



210
211
212
 
# File 'lib/aidp/harness/configuration.rb', line 210

def lint_max_output_lines
  work_loop_config.dig(:lint, :max_output_lines) || 300
end

#lint_output_mode ⇒ Object

Get lint output mode



205
206
207
 
# File 'lib/aidp/harness/configuration.rb', line 205

def lint_output_mode
  work_loop_config.dig(:lint, :output_mode) || :full
end

#load_balancing_config ⇒ Object

Get load balancing configuration



126
127
128
 
# File 'lib/aidp/harness/configuration.rb', line 126

def load_balancing_config
  harness_config[:load_balancing] || default_load_balancing_config
end

#logging_config ⇒ Object

Get logging configuration



375
376
377
 
# File 'lib/aidp/harness/configuration.rb', line 375

def logging_config
  harness_config[:logging] || default_logging_config
end

#max_retries ⇒ Object

Get maximum retries



44
45
46
 
# File 'lib/aidp/harness/configuration.rb', line 44

def max_retries
  harness_config[:max_retries]
end

#max_tier ⇒ Object

Get maximum thinking tier



390
391
392
 
# File 'lib/aidp/harness/configuration.rb', line 390

def max_tier
  thinking_config[:max_tier] || "standard"
end

#max_tokens(provider_name) ⇒ Object

Get maximum tokens for API providers



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

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

#metrics_config ⇒ Object

Get metrics configuration



141
142
143
 
# File 'lib/aidp/harness/configuration.rb', line 141

def metrics_config
  harness_config[:metrics] || default_metrics_config
end

#model_config(provider_name, model_name) ⇒ Object

Get model configuration for provider



80
81
82
83
 
# File 'lib/aidp/harness/configuration.rb', line 80

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

#model_family(provider_name) ⇒ Object

Get model family for a provider



325
326
327
 
# File 'lib/aidp/harness/configuration.rb', line 325

def model_family(provider_name)
  provider_config(provider_name)[:model_family] || "auto"
end

#model_flags(provider_name, model_name) ⇒ Object

Get model-specific flags



86
87
88
 
# File 'lib/aidp/harness/configuration.rb', line 86

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



91
92
93
 
# File 'lib/aidp/harness/configuration.rb', line 91

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



131
132
133
 
# File 'lib/aidp/harness/configuration.rb', line 131

def model_switching_config
  harness_config[:model_switching] || default_model_switching_config
end

#model_timeout(provider_name, model_name) ⇒ Object

Get model-specific timeout



96
97
98
 
# File 'lib/aidp/harness/configuration.rb', line 96

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

#model_weights(provider_name) ⇒ Object

Get model weights for load balancing



106
107
108
 
# File 'lib/aidp/harness/configuration.rb', line 106

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) 


49
50
51
 
# File 'lib/aidp/harness/configuration.rb', line 49

def no_api_keys_required?
  harness_config[:no_api_keys_required]
end

#permission_for_tier(tier) ⇒ Object

Get permission level for a tier



420
421
422
 
# File 'lib/aidp/harness/configuration.rb', line 420

def permission_for_tier(tier)
  permissions_by_tier[tier] || permissions_by_tier[tier.to_sym] || "tools"
end

#permissions_by_tier ⇒ Object

Get permissions by tier configuration



415
416
417
 
# File 'lib/aidp/harness/configuration.rb', line 415

def permissions_by_tier
  thinking_config[:permissions_by_tier] || {}
end

#prompt_dynamic_adjustment? ⇒ Boolean

Check if dynamic adjustment is enabled

Returns:

  • (Boolean) 


627
628
629
 
# File 'lib/aidp/harness/configuration.rb', line 627

def prompt_dynamic_adjustment?
  prompt_optimization_config[:dynamic_adjustment] != false
end

#prompt_include_thresholds ⇒ Object

Get include threshold configuration



607
608
609
 
# File 'lib/aidp/harness/configuration.rb', line 607

def prompt_include_thresholds
  prompt_optimization_config[:include_threshold] || default_include_thresholds
end

#prompt_log_fragments? ⇒ Boolean

Check if fragment logging is enabled

Returns:

  • (Boolean) 


632
633
634
 
# File 'lib/aidp/harness/configuration.rb', line 632

def prompt_log_fragments?
  prompt_optimization_config[:log_selected_fragments] == true
end

#prompt_max_tokens ⇒ Object

Get maximum tokens for prompt



602
603
604
 
# File 'lib/aidp/harness/configuration.rb', line 602

def prompt_max_tokens
  prompt_optimization_config[:max_tokens] || 16000
end

#prompt_optimization_config ⇒ Object

Get prompt optimization configuration



592
593
594
 
# File 'lib/aidp/harness/configuration.rb', line 592

def prompt_optimization_config
  @config[:prompt_optimization] || default_prompt_optimization_config
end

#prompt_optimization_enabled? ⇒ Boolean

Check if prompt optimization is enabled

Returns:

  • (Boolean) 


597
598
599
 
# File 'lib/aidp/harness/configuration.rb', line 597

def prompt_optimization_enabled?
  prompt_optimization_config[:enabled] == true
end

#prompt_source_threshold ⇒ Object

Get source code include threshold



622
623
624
 
# File 'lib/aidp/harness/configuration.rb', line 622

def prompt_source_threshold
  prompt_include_thresholds[:source] || 0.7
end

#prompt_style_guide_threshold ⇒ Object

Get style guide include threshold



612
613
614
 
# File 'lib/aidp/harness/configuration.rb', line 612

def prompt_style_guide_threshold
  prompt_include_thresholds[:style_guide] || 0.75
end

#prompt_templates_threshold ⇒ Object

Get templates include threshold



617
618
619
 
# File 'lib/aidp/harness/configuration.rb', line 617

def prompt_templates_threshold
  prompt_include_thresholds[:templates] || 0.8
end

#provider_auth_config(provider_name) ⇒ Object

Get provider authentication configuration



345
346
347
 
# File 'lib/aidp/harness/configuration.rb', line 345

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

#provider_config(provider_name) ⇒ Object

Get provider configuration



24
25
26
 
# File 'lib/aidp/harness/configuration.rb', line 24

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) 


365
366
367
 
# File 'lib/aidp/harness/configuration.rb', line 365

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

#provider_cost_config(provider_name) ⇒ Object

Get provider cost configuration



335
336
337
 
# File 'lib/aidp/harness/configuration.rb', line 335

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

#provider_endpoints(provider_name) ⇒ Object

Get provider endpoint configuration



350
351
352
 
# File 'lib/aidp/harness/configuration.rb', line 350

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

#provider_features(provider_name) ⇒ Object

Get provider feature flags



355
356
357
 
# File 'lib/aidp/harness/configuration.rb', line 355

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

#provider_models(provider_name) ⇒ Object

Get provider models configuration



69
70
71
 
# File 'lib/aidp/harness/configuration.rb', line 69

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

#provider_monitoring_config(provider_name) ⇒ Object

Get provider monitoring configuration



360
361
362
 
# File 'lib/aidp/harness/configuration.rb', line 360

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

#provider_priority(provider_name) ⇒ Object

Get provider priority



330
331
332
 
# File 'lib/aidp/harness/configuration.rb', line 330

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

#provider_regions(provider_name) ⇒ Object

Get provider region configuration



340
341
342
 
# File 'lib/aidp/harness/configuration.rb', line 340

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

#provider_type(provider_name) ⇒ Object

Get provider type (usage_based, subscription, etc.)



54
55
56
 
# File 'lib/aidp/harness/configuration.rb', line 54

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

#provider_weights ⇒ Object

Get provider weights for load balancing



101
102
103
 
# File 'lib/aidp/harness/configuration.rb', line 101

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

#rate_limit_config ⇒ Object

Get rate limit configuration



121
122
123
 
# File 'lib/aidp/harness/configuration.rb', line 121

def rate_limit_config
  harness_config[:rate_limit] || default_rate_limit_config
end

#raw_config ⇒ Object

Get raw configuration



451
452
453
 
# File 'lib/aidp/harness/configuration.rb', line 451

def raw_config
  @config.dup
end

#retry_config ⇒ Object

Get retry configuration



116
117
118
 
# File 'lib/aidp/harness/configuration.rb', line 116

def retry_config
  harness_config[:retry] || default_retry_config
end

#session_config ⇒ Object

Get session configuration



146
147
148
 
# File 'lib/aidp/harness/configuration.rb', line 146

def session_config
  harness_config[:session] || default_session_config
end

#should_use_full_permissions?(provider_name) ⇒ Boolean

Check if provider should run with full permissions Combines devcontainer detection with configuration

Returns:

  • (Boolean) 


729
730
731
732
733
734
735
736
737
738
 
# File 'lib/aidp/harness/configuration.rb', line 729

def should_use_full_permissions?(provider_name)
  return false unless devcontainer_enabled?
  return false unless in_devcontainer?

  # Check if full permissions are globally enabled for devcontainer
  return true if full_permissions_in_devcontainer?

  # Check if this specific provider should skip permissions
  devcontainer_skip_permissions_for?(provider_name)
end

#test_commands ⇒ Object

Get test commands



170
171
172
 
# File 'lib/aidp/harness/configuration.rb', line 170

def test_commands
  normalize_commands(work_loop_config[:test_commands] || [])
end

#test_max_output_lines ⇒ Object

Get max output lines for tests



200
201
202
 
# File 'lib/aidp/harness/configuration.rb', line 200

def test_max_output_lines
  work_loop_config.dig(:test, :max_output_lines) || 500
end

#test_output_mode ⇒ Object

Get test output mode



195
196
197
 
# File 'lib/aidp/harness/configuration.rb', line 195

def test_output_mode
  work_loop_config.dig(:test, :output_mode) || :full
end

#thinking_config ⇒ Object

Get thinking depth configuration



380
381
382
 
# File 'lib/aidp/harness/configuration.rb', line 380

def thinking_config
  @config[:thinking] || default_thinking_config
end

#thinking_overrides ⇒ Object

Get thinking tier overrides



425
426
427
 
# File 'lib/aidp/harness/configuration.rb', line 425

def thinking_overrides
  thinking_config[:overrides] || {}
end

#tier_override_for(key) ⇒ Object

Get tier override for a skill or template

Parameters:

  • key (String) —

    skill or template key (e.g., “skill.generate_tests”, “template.large_refactor”)



431
432
433
 
# File 'lib/aidp/harness/configuration.rb', line 431

def tier_override_for(key)
  thinking_overrides[key] || thinking_overrides[key.to_sym]
end

#tier_overrides ⇒ Object

Get tier overrides



528
529
530
 
# File 'lib/aidp/harness/configuration.rb', line 528

def tier_overrides
  thinking_config[:overrides] || {}
end

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

Validate model configuration



456
457
458
459
460
461
462
463
464
465
466
467
468
469
 
# File 'lib/aidp/harness/configuration.rb', line 456

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



488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
 
# File 'lib/aidp/harness/configuration.rb', line 488

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

#vcs_behavior ⇒ Object

Get VCS behavior (stage/commit/nothing)



260
261
262
 
# File 'lib/aidp/harness/configuration.rb', line 260

def vcs_behavior
  version_control_config[:behavior]
end

#vcs_tool ⇒ Object

Get VCS tool



255
256
257
 
# File 'lib/aidp/harness/configuration.rb', line 255

def vcs_tool
  version_control_config[:tool]
end

#version_control_config ⇒ Object

Get version control configuration



250
251
252
 
# File 'lib/aidp/harness/configuration.rb', line 250

def version_control_config
  work_loop_config[:version_control] || default_version_control_config
end

#work_loop_config ⇒ Object

Get work loop configuration



151
152
153
 
# File 'lib/aidp/harness/configuration.rb', line 151

def work_loop_config
  harness_config[:work_loop] || default_work_loop_config
end

#work_loop_enabled? ⇒ Boolean

Check if work loops are enabled

Returns:

  • (Boolean) 


160
161
162
 
# File 'lib/aidp/harness/configuration.rb', line 160

def work_loop_enabled?
  work_loop_config[:enabled]
end

#work_loop_max_iterations ⇒ Object

Get maximum iterations for work loops



165
166
167
 
# File 'lib/aidp/harness/configuration.rb', line 165

def work_loop_max_iterations
  work_loop_config[:max_iterations]
end

#work_loop_units_config ⇒ Object 



155
156
157
 
# File 'lib/aidp/harness/configuration.rb', line 155

def work_loop_units_config
  work_loop_config[:units] || default_units_config
end

#zfc_ab_testing_config ⇒ Object

Get ZFC A/B testing configuration



580
581
582
 
# File 'lib/aidp/harness/configuration.rb', line 580

def zfc_ab_testing_config
  zfc_config[:ab_testing] || default_zfc_ab_testing_config
end

#zfc_ab_testing_enabled? ⇒ Boolean

Check if ZFC A/B testing is enabled

Returns:

  • (Boolean) 


585
586
587
 
# File 'lib/aidp/harness/configuration.rb', line 585

def zfc_ab_testing_enabled?
  zfc_ab_testing_config[:enabled] == true
end

#zfc_config ⇒ Object

Get ZFC configuration



533
534
535
 
# File 'lib/aidp/harness/configuration.rb', line 533

def zfc_config
  @config[:zfc] || default_zfc_config
end

#zfc_cost_limits ⇒ Object

Get ZFC cost limits



575
576
577
 
# File 'lib/aidp/harness/configuration.rb', line 575

def zfc_cost_limits
  zfc_config[:cost_limits] || default_zfc_cost_limits
end

#zfc_decision_cache_ttl(decision_type) ⇒ Object

Get ZFC decision cache TTL



565
566
567
 
# File 'lib/aidp/harness/configuration.rb', line 565

def zfc_decision_cache_ttl(decision_type)
  zfc_decision_config(decision_type)[:cache_ttl]
end

#zfc_decision_confidence_threshold(decision_type) ⇒ Object

Get ZFC decision confidence threshold



570
571
572
 
# File 'lib/aidp/harness/configuration.rb', line 570

def zfc_decision_confidence_threshold(decision_type)
  zfc_decision_config(decision_type)[:confidence_threshold] || 0.7
end

#zfc_decision_config(decision_type) ⇒ Object

Get ZFC decision configuration



548
549
550
 
# File 'lib/aidp/harness/configuration.rb', line 548

def zfc_decision_config(decision_type)
  zfc_config.dig(:decisions, decision_type.to_sym) || {}
end

#zfc_decision_enabled?(decision_type) ⇒ Boolean

Check if specific ZFC decision type is enabled

Returns:

  • (Boolean) 


553
554
555
556
557
 
# File 'lib/aidp/harness/configuration.rb', line 553

def zfc_decision_enabled?(decision_type)
  return false unless zfc_enabled?
  decision_config = zfc_decision_config(decision_type)
  decision_config[:enabled] == true
end

#zfc_decision_tier(decision_type) ⇒ Object

Get ZFC decision tier



560
561
562
 
# File 'lib/aidp/harness/configuration.rb', line 560

def zfc_decision_tier(decision_type)
  zfc_decision_config(decision_type)[:tier] || "mini"
end

#zfc_enabled? ⇒ Boolean

Check if ZFC is enabled

Returns:

  • (Boolean) 


538
539
540
 
# File 'lib/aidp/harness/configuration.rb', line 538

def zfc_enabled?
  zfc_config[:enabled] == true
end

#zfc_fallback_to_legacy? ⇒ Boolean

Check if ZFC should fallback to legacy on failure

Returns:

  • (Boolean) 


543
544
545
 
# File 'lib/aidp/harness/configuration.rb', line 543

def zfc_fallback_to_legacy?
  zfc_config[:fallback_to_legacy] != false
end