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) 


493
494
495
 
# File 'lib/aidp/harness/configuration.rb', line 493

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

#auto_escalate? ⇒ Boolean

Check if auto-escalation is enabled

Returns:

  • (Boolean) 


649
650
651
 
# File 'lib/aidp/harness/configuration.rb', line 649

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

#autonomous_escalation_config ⇒ Object

Get escalation configuration for autonomous contexts Controls how models are tried before tier escalation



473
474
475
 
# File 'lib/aidp/harness/configuration.rb', line 473

def autonomous_escalation_config
  thinking_config[:autonomous_escalation] || default_autonomous_escalation_config
end

#autonomous_max_tier ⇒ Object

Get maximum tier for autonomous contexts (watch mode, work loops) Restricts escalation to standard tier by default to prevent cost explosion Issue #375: Thinking tiers escalate too quickly in autonomous operations



467
468
469
 
# File 'lib/aidp/harness/configuration.rb', line 467

def autonomous_max_tier
  thinking_config[:autonomous_max_tier] || default_thinking_config[:autonomous_max_tier]
end

#build_commands ⇒ Object

Get build commands (filtered from generic commands for backwards compatibility)



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

def build_commands
  commands_for_category(:build).map { |cmd| {command: cmd[:command], required: cmd[:required]} }
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

#commands ⇒ Object

Get all generic deterministic commands Returns array of command configs with normalized structure: [command:, required:, run_after:, category:, timeout_seconds:]



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

def commands
  @commands ||= load_commands
end

#commands_for_category(category) ⇒ Array<Hash>

Get commands filtered by category

Parameters:

  • category (Symbol) —

    :test, :lint, :formatter, :build, :documentation, etc.

Returns:

  • (Array<Hash>) —

    Commands in the specified category



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

def commands_for_category(category)
  commands.select { |cmd| cmd[:category] == category.to_sym }
end

#commands_for_phase(phase) ⇒ Array<Hash>

Get commands filtered by execution phase

Parameters:

  • phase (Symbol) —

    :each_unit, :full_loop, or :on_completion

Returns:

  • (Array<Hash>) —

    Commands configured for the specified phase



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

def commands_for_phase(phase)
  commands.select { |cmd| cmd[:run_after] == phase.to_sym }
end

#config_exists? ⇒ Boolean

Check if configuration file exists

Returns:

  • (Boolean) 


572
573
574
 
# File 'lib/aidp/harness/configuration.rb', line 572

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

#config_path ⇒ Object

Get configuration path



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

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

#configuration_summary ⇒ Object

Get configuration summary



603
604
605
606
607
608
609
610
611
612
613
614
615
616
 
# File 'lib/aidp/harness/configuration.rb', line 603

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

#configured_tiers(provider_name) ⇒ Array<String>

Get all configured tiers for a provider

Parameters:

  • provider_name (String) —

    The provider name

Returns:

  • (Array<String>) —

    Array of tier names



562
563
564
 
# File 'lib/aidp/harness/configuration.rb', line 562

def configured_tiers(provider_name)
  provider_thinking_tiers(provider_name).keys.map(&:to_s)
end

#conventional_commits? ⇒ Boolean

Check if conventional commits are enabled

Returns:

  • (Boolean) 


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

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

#coverage_config ⇒ Object

Get coverage configuration



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

def coverage_config
  work_loop_config[:coverage] || default_coverage_config
end

#coverage_enabled? ⇒ Boolean

Check if coverage is enabled

Returns:

  • (Boolean) 


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

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

#coverage_fail_on_drop? ⇒ Boolean

Check if should fail on coverage drop

Returns:

  • (Boolean) 


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

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

#coverage_minimum ⇒ Object

Get minimum coverage threshold



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

def coverage_minimum
  coverage_config[:minimum_coverage]
end

#coverage_report_paths ⇒ Object

Get coverage report paths



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

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

#coverage_run_command ⇒ Object

Get coverage run command



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

def coverage_run_command
  coverage_config[:run_command]
end

#coverage_tool ⇒ Object

Get coverage tool



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

def coverage_tool
  coverage_config[:tool]
end

#create_example_config ⇒ Object

Create example configuration



577
578
579
 
# File 'lib/aidp/harness/configuration.rb', line 577

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



455
456
457
 
# File 'lib/aidp/harness/configuration.rb', line 455

def default_tier
  thinking_config[:default_tier] || default_thinking_config[:default_tier]
end

#devcontainer_allowed_domains ⇒ Object

Get allowed domains for devcontainer firewall



854
855
856
 
# File 'lib/aidp/harness/configuration.rb', line 854

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

#devcontainer_config ⇒ Object

Get devcontainer configuration



770
771
772
773
774
775
776
777
778
779
780
781
 
# File 'lib/aidp/harness/configuration.rb', line 770

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) 


816
817
818
 
# File 'lib/aidp/harness/configuration.rb', line 816

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

#devcontainer_enabled? ⇒ Boolean

Check if devcontainer features are enabled

Returns:

  • (Boolean) 


784
785
786
 
# File 'lib/aidp/harness/configuration.rb', line 784

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

#devcontainer_force_detection ⇒ Object

Get forced detection value (nil for auto-detection)



794
795
796
 
# File 'lib/aidp/harness/configuration.rb', line 794

def devcontainer_force_detection
  devcontainer_config[:force_detection]
end

#devcontainer_permissions ⇒ Object

Get devcontainer permissions config



808
809
810
811
812
813
 
# File 'lib/aidp/harness/configuration.rb', line 808

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



839
840
841
 
# File 'lib/aidp/harness/configuration.rb', line 839

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

#devcontainer_skip_permission_checks ⇒ Object

Get list of providers that should skip permission checks in devcontainer



821
822
823
824
825
826
827
828
829
830
831
 
# File 'lib/aidp/harness/configuration.rb', line 821

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) 


834
835
836
 
# File 'lib/aidp/harness/configuration.rb', line 834

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



844
845
846
 
# File 'lib/aidp/harness/configuration.rb', line 844

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) 


849
850
851
 
# File 'lib/aidp/harness/configuration.rb', line 849

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

#documentation_commands ⇒ Object

Get documentation commands (filtered from generic commands for backwards compatibility)



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

def documentation_commands
  commands_for_category(:documentation).map { |cmd| {command: cmd[:command], required: cmd[:required]} }
end

#escalation_complexity_threshold ⇒ Object

Get complexity threshold configuration for escalation



508
509
510
 
# File 'lib/aidp/harness/configuration.rb', line 508

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

#escalation_config ⇒ Object

Get escalation configuration



498
499
500
 
# File 'lib/aidp/harness/configuration.rb', line 498

def escalation_config
  thinking_config[:escalation] || default_escalation_config
end

#escalation_fail_attempts ⇒ Object

Get fail attempts threshold for escalation



503
504
505
 
# File 'lib/aidp/harness/configuration.rb', line 503

def escalation_fail_attempts
  escalation_config[:on_fail_attempts] || 2
end

#escalation_threshold ⇒ Object

Get escalation threshold



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

def escalation_threshold
  thinking_config[:escalation_threshold] || 2
end

#fallback_config ⇒ Object

Get fallback configuration



567
568
569
 
# File 'lib/aidp/harness/configuration.rb', line 567

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

#filter_definition_for(key) ⇒ FilterDefinition?

Get filter definition for a specific tool/category

Parameters:

  • key (String, Symbol) —

    Tool key (e.g., "unit_test", "lint")

Returns:



271
272
273
274
275
276
277
278
279
280
281
282
 
# File 'lib/aidp/harness/configuration.rb', line 271

def filter_definition_for(key)
  definitions = filter_definitions
  definition_hash = definitions[key.to_s] || definitions[key.to_sym]
  return nil unless definition_hash

  require_relative "filter_definition"
  FilterDefinition.from_hash(definition_hash)
rescue => e
  Aidp.log_warn("configuration", "failed_to_load_filter_definition",
    key: key, error: e.message)
  nil
end

#filter_definitions ⇒ Hash

Get all filter definitions from config

Returns:

  • (Hash) —

    Map of tool keys to filter definition hashes



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

def filter_definitions
  output_filtering_config[:filter_definitions] || {}
end

#formatter_commands ⇒ Object

Get formatter commands (filtered from generic commands for backwards compatibility)



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

def formatter_commands
  commands_for_category(:formatter).map { |cmd| {command: cmd[:command], required: cmd[:required]} }
end

#full_permissions_in_devcontainer? ⇒ Boolean

Check if full permissions should be granted in devcontainer

Returns:

  • (Boolean) 


789
790
791
 
# File 'lib/aidp/harness/configuration.rb', line 789

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

#guards_bypass? ⇒ Boolean

Check if guards are bypassed

Returns:

  • (Boolean) 


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

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

#guards_config ⇒ Object

Get guards configuration



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

def guards_config
  work_loop_config[:guards] || default_guards_config
end

#guards_confirm_files ⇒ Object

Get files requiring confirmation for guards



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

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

#guards_enabled? ⇒ Boolean

Check if guards are enabled

Returns:

  • (Boolean) 


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

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

#guards_exclude_files ⇒ Object

Get exclude file patterns for guards



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

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

#guards_include_files ⇒ Object

Get include file patterns for guards



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

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

#guards_max_lines_per_commit ⇒ Object

Get max lines per commit for guards



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

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) 


799
800
801
802
803
804
805
 
# File 'lib/aidp/harness/configuration.rb', line 799

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



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

def interactive_testing_app_type
  interactive_testing_config[:app_type]
end

#interactive_testing_config ⇒ Object

Get interactive testing configuration



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

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) 


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

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

#interactive_testing_tools ⇒ Object

Get interactive testing tools configuration



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

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

#lint_commands ⇒ Object

Get lint commands (filtered from generic commands for backwards compatibility)



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

def lint_commands
  commands_for_category(:lint).map { |cmd| {command: cmd[:command], required: cmd[:required]} }
end

#lint_max_output_lines ⇒ Object

Get max output lines for linters



248
249
250
 
# File 'lib/aidp/harness/configuration.rb', line 248

def lint_max_output_lines
  output_filtering_config[:lint_max_lines] || 300
end

#lint_output_mode ⇒ Object

Get lint output mode



242
243
244
245
 
# File 'lib/aidp/harness/configuration.rb', line 242

def lint_output_mode
  mode = output_filtering_config[:lint_mode]
  mode ? mode.to_sym : :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



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

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



460
461
462
 
# File 'lib/aidp/harness/configuration.rb', line 460

def max_tier
  thinking_config[:max_tier] || default_thinking_config[:max_tier]
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

#min_attempts_per_model ⇒ Object

Minimum attempts per model before trying next model in tier



478
479
480
 
# File 'lib/aidp/harness/configuration.rb', line 478

def min_attempts_per_model
  autonomous_escalation_config[:min_attempts_per_model] || 2
end

#min_total_attempts_before_escalation ⇒ Object

Minimum total attempts across all models before tier escalation



483
484
485
 
# File 'lib/aidp/harness/configuration.rb', line 483

def min_total_attempts_before_escalation
  autonomous_escalation_config[:min_total_attempts] || 10
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



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

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

#models_for_tier(tier, provider_name) ⇒ Array<String>

Get models configured for a specific tier and provider

Parameters:

  • tier (String, Symbol) —

    The tier name (mini, standard, thinking, pro, max)

  • provider_name (String) —

    The provider name (required)

Returns:

  • (Array<String>) —

    Array of model names for the tier



545
546
547
548
549
550
551
552
553
554
555
556
557
 
# File 'lib/aidp/harness/configuration.rb', line 545

def models_for_tier(tier, provider_name)
  return [] unless provider_name

  tier_config = provider_thinking_tiers(provider_name)[tier] ||
    provider_thinking_tiers(provider_name)[tier.to_sym]
  return [] unless tier_config

  models = tier_config[:models] || tier_config["models"]
  return [] unless models

  # Return simple array of model name strings
  Array(models).map(&:to_s).compact
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

#output_filtering_config ⇒ Object

Get output filtering configuration



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

def output_filtering_config
  work_loop_config[:output_filtering] || default_output_filtering_config
end

#output_filtering_context_lines ⇒ Object

Get context_lines setting for output filtering



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

def output_filtering_context_lines
  output_filtering_config[:context_lines] || 3
end

#output_filtering_enabled? ⇒ Boolean

Check if output filtering is enabled

Returns:

  • (Boolean) 


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

def output_filtering_enabled?
  output_filtering_config[:enabled] != false
end

#output_filtering_include_context ⇒ Object

Get include_context setting for output filtering



253
254
255
 
# File 'lib/aidp/harness/configuration.rb', line 253

def output_filtering_include_context
  output_filtering_config.fetch(:include_context, true)
end

#permission_for_tier(tier) ⇒ Object

Get permission level for a tier



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

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



513
514
515
 
# File 'lib/aidp/harness/configuration.rb', line 513

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

#prompt_dynamic_adjustment? ⇒ Boolean

Check if dynamic adjustment is enabled

Returns:

  • (Boolean) 


758
759
760
 
# File 'lib/aidp/harness/configuration.rb', line 758

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

#prompt_include_thresholds ⇒ Object

Get include threshold configuration



738
739
740
 
# File 'lib/aidp/harness/configuration.rb', line 738

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) 


763
764
765
 
# File 'lib/aidp/harness/configuration.rb', line 763

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

#prompt_max_tokens ⇒ Object

Get maximum tokens for prompt



733
734
735
 
# File 'lib/aidp/harness/configuration.rb', line 733

def prompt_max_tokens
  prompt_optimization_config[:max_tokens] || 16000
end

#prompt_optimization_config ⇒ Object

Get prompt optimization configuration



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

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

#prompt_optimization_enabled? ⇒ Boolean

Check if prompt optimization is enabled

Returns:

  • (Boolean) 


728
729
730
 
# File 'lib/aidp/harness/configuration.rb', line 728

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

#prompt_source_threshold ⇒ Object

Get source code include threshold



753
754
755
 
# File 'lib/aidp/harness/configuration.rb', line 753

def prompt_source_threshold
  prompt_include_thresholds[:source] || 0.7
end

#prompt_style_guide_threshold ⇒ Object

Get style guide include threshold



743
744
745
 
# File 'lib/aidp/harness/configuration.rb', line 743

def prompt_style_guide_threshold
  prompt_include_thresholds[:style_guide] || 0.75
end

#prompt_templates_threshold ⇒ Object

Get templates include threshold



748
749
750
 
# File 'lib/aidp/harness/configuration.rb', line 748

def prompt_templates_threshold
  prompt_include_thresholds[:templates] || 0.8
end

#provider_auth_config(provider_name) ⇒ Object

Get provider authentication configuration



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

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) 


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

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

#provider_cost_config(provider_name) ⇒ Object

Get provider cost configuration



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

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

#provider_endpoints(provider_name) ⇒ Object

Get provider endpoint configuration



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

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

#provider_features(provider_name) ⇒ Object

Get provider feature flags



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

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



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

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

#provider_priority(provider_name) ⇒ Object

Get provider priority



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

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

#provider_regions(provider_name) ⇒ Object

Get provider region configuration



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

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

#provider_thinking_tiers(provider_name) ⇒ Hash

Get thinking tiers configuration for a specific provider

Parameters:

  • provider_name (String) —

    The provider name

Returns:

  • (Hash) —

    The thinking tiers configuration for the provider



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

def provider_thinking_tiers(provider_name)
  provider_cfg = provider_config(provider_name)
  provider_cfg[:thinking_tiers] || provider_cfg["thinking_tiers"] || {}
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



582
583
584
 
# File 'lib/aidp/harness/configuration.rb', line 582

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

#retry_failed_models? ⇒ Boolean

Whether to retry failed models after exhausting untested models

Returns:

  • (Boolean) 


488
489
490
 
# File 'lib/aidp/harness/configuration.rb', line 488

def retry_failed_models?
  autonomous_escalation_config[:retry_failed_models] != false
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) 


860
861
862
863
864
865
866
867
868
869
 
# File 'lib/aidp/harness/configuration.rb', line 860

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

#task_completion_required? ⇒ Boolean

Check if task completion is required for work loop completion

Returns:

  • (Boolean) 


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

def task_completion_required?
  work_loop_config.fetch(:task_completion_required, true)
end

#test_commands ⇒ Object

Get test commands (filtered from generic commands for backwards compatibility)



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

def test_commands
  commands_for_category(:test).map { |cmd| {command: cmd[:command], required: cmd[:required]} }
end

#test_max_output_lines ⇒ Object

Get max output lines for tests



237
238
239
 
# File 'lib/aidp/harness/configuration.rb', line 237

def test_max_output_lines
  output_filtering_config[:test_max_lines] || 500
end

#test_output_mode ⇒ Object

Get test output mode



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

def test_output_mode
  mode = output_filtering_config[:test_mode]
  mode ? mode.to_sym : :full
end

#thinking_config ⇒ Object

Get thinking depth configuration



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

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

#thinking_overrides ⇒ Object

Get thinking tier overrides



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

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")



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

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

#tier_overrides ⇒ Object

Get tier overrides



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

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

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

Validate model configuration



587
588
589
590
591
592
593
594
595
596
597
598
599
600
 
# File 'lib/aidp/harness/configuration.rb', line 587

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



619
620
621
622
623
624
625
626
627
628
629
630
631
632
633
634
635
636
637
638
639
640
641
642
643
644
645
646
 
# File 'lib/aidp/harness/configuration.rb', line 619

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)



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

def vcs_behavior
  version_control_config[:behavior]
end

#vcs_tool ⇒ Object

Get VCS tool



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

def vcs_tool
  version_control_config[:tool]
end

#version_control_config ⇒ Object

Get version control configuration



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

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



711
712
713
 
# File 'lib/aidp/harness/configuration.rb', line 711

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) 


716
717
718
 
# File 'lib/aidp/harness/configuration.rb', line 716

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

#zfc_config ⇒ Object

Get ZFC configuration



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

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

#zfc_cost_limits ⇒ Object

Get ZFC cost limits



706
707
708
 
# File 'lib/aidp/harness/configuration.rb', line 706

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



696
697
698
 
# File 'lib/aidp/harness/configuration.rb', line 696

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



701
702
703
 
# File 'lib/aidp/harness/configuration.rb', line 701

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



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

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) 


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

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



691
692
693
 
# File 'lib/aidp/harness/configuration.rb', line 691

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

#zfc_enabled? ⇒ Boolean

Check if ZFC is enabled

Returns:

  • (Boolean) 


669
670
671
 
# File 'lib/aidp/harness/configuration.rb', line 669

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

#zfc_fallback_to_legacy? ⇒ Boolean

Check if ZFC should fallback to legacy on failure

Returns:

  • (Boolean) 


674
675
676
 
# File 'lib/aidp/harness/configuration.rb', line 674

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