Class: Aidp::Setup::InMemoryConfigAdapter

Inherits:
Object
  • Object
show all
Defined in:
lib/aidp/setup/in_memory_config_adapter.rb

Overview

Adapter that wraps in-memory configuration from the wizard to provide the same interface as Harness::Configuration.

This enables AGD (AI-Generated Determinism) to work during the interactive configuration wizard before the config file is written to disk.

Examples:

Usage in wizard

adapter = InMemoryConfigAdapter.new(@config, project_dir)
factory = AIFilterFactory.new(adapter)

Instance Attribute Summary collapse

Instance Method Summary collapse

Constructor Details

#initialize(config, project_dir) ⇒ InMemoryConfigAdapter

Initialize with wizard's in-memory config hash

Parameters:

  • config (Hash) —

    The wizard's @config hash (symbolized keys)

  • project_dir (String) —

    Project directory path



23
24
25
26
27
28
29
30
 
# File 'lib/aidp/setup/in_memory_config_adapter.rb', line 23

def initialize(config, project_dir)
  @config = config || {}
  @project_dir = project_dir

  Aidp.log_debug("in_memory_config_adapter", "initialized",
    providers: configured_providers,
    default_provider: default_provider)
end

Instance Attribute Details

#project_dir ⇒ Object (readonly)

Returns the value of attribute project_dir.



17
18
19
 
# File 'lib/aidp/setup/in_memory_config_adapter.rb', line 17

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) 


110
111
112
 
# File 'lib/aidp/setup/in_memory_config_adapter.rb', line 110

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

#autonomous_escalation_config ⇒ Object

Issue #375: Get escalation configuration for autonomous contexts



166
167
168
 
# File 'lib/aidp/setup/in_memory_config_adapter.rb', line 166

def autonomous_escalation_config
  thinking_config[:autonomous_escalation] || default_autonomous_escalation_config
end

#autonomous_max_tier ⇒ Object

Issue #375: Get maximum tier for autonomous contexts (watch mode, work loops)



161
162
163
 
# File 'lib/aidp/setup/in_memory_config_adapter.rb', line 161

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

#configured_providers ⇒ Object

Get all configured providers



50
51
52
53
 
# File 'lib/aidp/setup/in_memory_config_adapter.rb', line 50

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

#configured_tiers(provider_name) ⇒ Object

Get all configured tiers for a provider



105
106
107
 
# File 'lib/aidp/setup/in_memory_config_adapter.rb', line 105

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

#default_flags(provider_name) ⇒ Object

Get default flags for a provider



191
192
193
 
# File 'lib/aidp/setup/in_memory_config_adapter.rb', line 191

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

#default_provider ⇒ Object

Get default provider



56
57
58
 
# File 'lib/aidp/setup/in_memory_config_adapter.rb', line 56

def default_provider
  harness_config[:default_provider]
end

#default_tier ⇒ Object

Get default thinking tier



115
116
117
 
# File 'lib/aidp/setup/in_memory_config_adapter.rb', line 115

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

#escalation_complexity_threshold ⇒ Object

Get complexity threshold configuration for escalation



156
157
158
 
# File 'lib/aidp/setup/in_memory_config_adapter.rb', line 156

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

#escalation_config ⇒ Object

Get escalation configuration



146
147
148
 
# File 'lib/aidp/setup/in_memory_config_adapter.rb', line 146

def escalation_config
  thinking_config[:escalation] || default_escalation_config
end

#escalation_fail_attempts ⇒ Object

Get fail attempts threshold for escalation



151
152
153
 
# File 'lib/aidp/setup/in_memory_config_adapter.rb', line 151

def escalation_fail_attempts
  escalation_config[:on_fail_attempts] || 2
end

#fallback_providers ⇒ Object

Get fallback providers



61
62
63
 
# File 'lib/aidp/setup/in_memory_config_adapter.rb', line 61

def fallback_providers
  Array(harness_config[:fallback_providers])
end

#filter_definitions ⇒ Object

Get filter definitions



219
220
221
 
# File 'lib/aidp/setup/in_memory_config_adapter.rb', line 219

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

#harness_config ⇒ Object

Get harness-specific configuration



33
34
35
36
37
38
 
# File 'lib/aidp/setup/in_memory_config_adapter.rb', line 33

def harness_config
  config = @config[:harness] || {}
  Aidp.log_debug("in_memory_config_adapter", "harness_config_retrieved",
    keys: config.keys)
  config
end

#max_tier ⇒ Object

Get maximum thinking tier



120
121
122
 
# File 'lib/aidp/setup/in_memory_config_adapter.rb', line 120

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

#max_tokens(provider_name) ⇒ Object

Get maximum tokens for a provider



196
197
198
 
# File 'lib/aidp/setup/in_memory_config_adapter.rb', line 196

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

#min_attempts_per_model ⇒ Object

Issue #375: Minimum attempts per model before trying next model in tier



171
172
173
 
# File 'lib/aidp/setup/in_memory_config_adapter.rb', line 171

def min_attempts_per_model
  autonomous_escalation_config[:min_attempts_per_model] || 2
end

#min_total_attempts_before_escalation ⇒ Object

Issue #375: Minimum total attempts across all models before tier escalation



176
177
178
 
# File 'lib/aidp/setup/in_memory_config_adapter.rb', line 176

def min_total_attempts_before_escalation
  autonomous_escalation_config[:min_total_attempts] || 10
end

#model_family(provider_name) ⇒ Object

Get model family for a provider



71
72
73
 
# File 'lib/aidp/setup/in_memory_config_adapter.rb', line 71

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

#models_for_tier(tier, provider_name) ⇒ Object

Get models configured for a specific tier and provider



82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
 
# File 'lib/aidp/setup/in_memory_config_adapter.rb', line 82

def models_for_tier(tier, provider_name)
  unless provider_name
    Aidp.log_debug("in_memory_config_adapter", "models_for_tier_skipped",
      reason: "no_provider_name")
    return []
  end

  tier_config = provider_thinking_tiers(provider_name)[tier] ||
    provider_thinking_tiers(provider_name)[tier.to_sym]
  unless tier_config
    Aidp.log_debug("in_memory_config_adapter", "models_for_tier_not_found",
      tier: tier, provider: provider_name)
    return []
  end

  models = tier_config[:models] || tier_config["models"]
  result = models ? Array(models).map(&:to_s).compact : []
  Aidp.log_debug("in_memory_config_adapter", "models_for_tier_retrieved",
    tier: tier, provider: provider_name, count: result.size)
  result
end

#output_filtering_config ⇒ Object

Get output filtering configuration



214
215
216
 
# File 'lib/aidp/setup/in_memory_config_adapter.rb', line 214

def output_filtering_config
  work_loop_config[:output_filtering] || {}
end

#permission_for_tier(tier) ⇒ Object

Get permission level for a tier



140
141
142
143
 
# File 'lib/aidp/setup/in_memory_config_adapter.rb', line 140

def permission_for_tier(tier)
  permissions = thinking_config[:permissions_by_tier] || {}
  permissions[tier] || permissions[tier.to_sym] || "tools"
end

#provider_config(provider_name) ⇒ Object

Get provider configuration



41
42
43
44
45
46
47
 
# File 'lib/aidp/setup/in_memory_config_adapter.rb', line 41

def provider_config(provider_name)
  providers = @config[:providers] || {}
  config = providers[provider_name.to_sym] || providers[provider_name.to_s] || {}
  Aidp.log_debug("in_memory_config_adapter", "provider_config_retrieved",
    provider: provider_name, found: !config.empty?)
  config
end

#provider_configured?(provider_name) ⇒ Boolean

Check if provider is configured

Returns:

  • (Boolean) 


201
202
203
204
205
206
 
# File 'lib/aidp/setup/in_memory_config_adapter.rb', line 201

def provider_configured?(provider_name)
  result = configured_providers.include?(provider_name.to_s)
  Aidp.log_debug("in_memory_config_adapter", "provider_configured_check",
    provider: provider_name, configured: result)
  result
end

#provider_models(provider_name) ⇒ Object

Get provider models configuration



186
187
188
 
# File 'lib/aidp/setup/in_memory_config_adapter.rb', line 186

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

#provider_thinking_tiers(provider_name) ⇒ Object

Get thinking tiers configuration for a provider



76
77
78
79
 
# File 'lib/aidp/setup/in_memory_config_adapter.rb', line 76

def provider_thinking_tiers(provider_name)
  cfg = provider_config(provider_name)
  cfg[:thinking_tiers] || cfg["thinking_tiers"] || {}
end

#provider_type(provider_name) ⇒ Object

Get provider type (usage_based, subscription, passthrough)



66
67
68
 
# File 'lib/aidp/setup/in_memory_config_adapter.rb', line 66

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

#raw_config ⇒ Object

Get raw configuration



224
225
226
 
# File 'lib/aidp/setup/in_memory_config_adapter.rb', line 224

def raw_config
  @config.dup
end

#retry_failed_models? ⇒ Boolean

Issue #375: Whether to retry failed models after exhausting untested models

Returns:

  • (Boolean) 


181
182
183
 
# File 'lib/aidp/setup/in_memory_config_adapter.rb', line 181

def retry_failed_models?
  autonomous_escalation_config[:retry_failed_models] != false
end

#thinking_config ⇒ Object

Get thinking configuration



125
126
127
 
# File 'lib/aidp/setup/in_memory_config_adapter.rb', line 125

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

#thinking_overrides ⇒ Object

Get thinking tier overrides



135
136
137
 
# File 'lib/aidp/setup/in_memory_config_adapter.rb', line 135

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

#tier_override_for(key) ⇒ Object

Get tier override for a skill or template



130
131
132
 
# File 'lib/aidp/setup/in_memory_config_adapter.rb', line 130

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

#work_loop_config ⇒ Object

Get work loop configuration



209
210
211
 
# File 'lib/aidp/setup/in_memory_config_adapter.rb', line 209

def work_loop_config
  harness_config[:work_loop] || {}
end