aidp 0.12.1 → 0.14.0

data/lib/aidp/harness/configuration.rb

@@ -65,13 +65,13 @@ module Aidp
 
       # Get provider models configuration
       def provider_models(provider_name)
-        provider_config(provider_name)[:models] || get_default_models_for_provider(provider_name)
+        provider_config(provider_name)[:models] || default_models_for_provider(provider_name)
       end
 
       # Get default model for provider
       def default_model(provider_name)
         models = provider_models(provider_name)
-        models.first || get_default_model_for_provider(provider_name)
+        models.first || default_model_for_provider(provider_name)
       end
 
       # Get model configuration for provider
@@ -92,7 +92,7 @@ module Aidp
 
       # Get model-specific timeout
       def model_timeout(provider_name, model_name)
-        model_config(provider_name, model_name)[:timeout] || get_default_timeout_for_provider(provider_name)
+        model_config(provider_name, model_name)[:timeout] || default_timeout_for_provider(provider_name)
       end
 
       # Get provider weights for load balancing
@@ -107,47 +107,47 @@ module Aidp
 
       # Get circuit breaker configuration
       def circuit_breaker_config
-        harness_config[:circuit_breaker] || get_default_circuit_breaker_config
+        harness_config[:circuit_breaker] || default_circuit_breaker_config
       end
 
       # Get retry configuration
       def retry_config
-        harness_config[:retry] || get_default_retry_config
+        harness_config[:retry] || default_retry_config
       end
 
       # Get rate limit configuration
       def rate_limit_config
-        harness_config[:rate_limit] || get_default_rate_limit_config
+        harness_config[:rate_limit] || default_rate_limit_config
       end
 
       # Get load balancing configuration
       def load_balancing_config
-        harness_config[:load_balancing] || get_default_load_balancing_config
+        harness_config[:load_balancing] || default_load_balancing_config
       end
 
       # Get model switching configuration
       def model_switching_config
-        harness_config[:model_switching] || get_default_model_switching_config
+        harness_config[:model_switching] || default_model_switching_config
       end
 
       # Get provider health check configuration
       def health_check_config
-        harness_config[:health_check] || get_default_health_check_config
+        harness_config[:health_check] || default_health_check_config
       end
 
       # Get metrics configuration
       def metrics_config
-        harness_config[:metrics] || get_default_metrics_config
+        harness_config[:metrics] || default_metrics_config
       end
 
       # Get session configuration
       def session_config
-        harness_config[:session] || get_default_session_config
+        harness_config[:session] || default_session_config
       end
 
       # Get work loop configuration
       def work_loop_config
-        harness_config[:work_loop] || get_default_work_loop_config
+        harness_config[:work_loop] || default_work_loop_config
       end
 
       # Check if work loops are enabled
@@ -170,6 +170,41 @@ module Aidp
         work_loop_config[:lint_commands] || []
       end
 
+      # Get guards configuration
+      def guards_config
+        work_loop_config[:guards] || default_guards_config
+      end
+
+      # Check if guards are enabled
+      def guards_enabled?
+        guards_config[:enabled] == true
+      end
+
+      # Get include file patterns for guards
+      def guards_include_files
+        guards_config[:include_files] || []
+      end
+
+      # Get exclude file patterns for guards
+      def guards_exclude_files
+        guards_config[:exclude_files] || []
+      end
+
+      # Get files requiring confirmation for guards
+      def guards_confirm_files
+        guards_config[:confirm_files] || []
+      end
+
+      # Get max lines per commit for guards
+      def guards_max_lines_per_commit
+        guards_config[:max_lines_per_commit]
+      end
+
+      # Check if guards are bypassed
+      def guards_bypass?
+        guards_config[:bypass] == true
+      end
+
       # Get provider priority
       def provider_priority(provider_name)
         provider_config(provider_name)[:priority] || 0
@@ -217,12 +252,12 @@ module Aidp
 
       # Get logging configuration
       def logging_config
-        harness_config[:logging] || get_default_logging_config
+        harness_config[:logging] || default_logging_config
       end
 
       # Get fallback configuration
       def fallback_config
-        harness_config[:fallback] || get_default_fallback_config
+        harness_config[:fallback] || default_fallback_config
       end
 
       # Check if configuration file exists
@@ -341,7 +376,7 @@ module Aidp
       end
 
       # Default configuration methods
-      def get_default_models_for_provider(provider_name)
+      def default_models_for_provider(provider_name)
         case provider_name
         when "anthropic"
           ["anthropic-3-5-sonnet-20241022", "anthropic-3-5-haiku-20241022", "anthropic-3-opus-20240229"]
@@ -352,7 +387,7 @@ module Aidp
         end
       end
 
-      def get_default_model_for_provider(provider_name)
+      def default_model_for_provider(provider_name)
         case provider_name
         when "anthropic"
           "anthropic-3-5-sonnet-20241022"
@@ -363,11 +398,11 @@ module Aidp
         end
       end
 
-      def get_default_timeout_for_provider(provider_name)
+      def default_timeout_for_provider(provider_name)
         300 # 5 minutes - default timeout for all providers
       end
 
-      def get_default_circuit_breaker_config
+      def default_circuit_breaker_config
         {
           enabled: true,
           failure_threshold: 5,
@@ -376,7 +411,7 @@ module Aidp
         }
       end
 
-      def get_default_retry_config
+      def default_retry_config
         {
           enabled: true,
           max_attempts: 3,
@@ -387,7 +422,7 @@ module Aidp
         }
       end
 
-      def get_default_rate_limit_config
+      def default_rate_limit_config
         {
           enabled: true,
           default_reset_time: 3600, # 1 hour
@@ -396,7 +431,7 @@ module Aidp
         }
       end
 
-      def get_default_load_balancing_config
+      def default_load_balancing_config
         {
           enabled: true,
           strategy: "weighted_round_robin", # weighted_round_robin, least_connections, random
@@ -405,7 +440,7 @@ module Aidp
         }
       end
 
-      def get_default_model_switching_config
+      def default_model_switching_config
         {
           enabled: true,
           auto_switch_on_error: true,
@@ -414,7 +449,7 @@ module Aidp
         }
       end
 
-      def get_default_health_check_config
+      def default_health_check_config
         {
           enabled: true,
           interval: 60, # 1 minute
@@ -424,7 +459,7 @@ module Aidp
         }
       end
 
-      def get_default_metrics_config
+      def default_metrics_config
         {
           enabled: true,
           retention_days: 30,
@@ -433,7 +468,7 @@ module Aidp
         }
       end
 
-      def get_default_session_config
+      def default_session_config
         {
           enabled: true,
           timeout: 1800, # 30 minutes
@@ -442,16 +477,28 @@ module Aidp
         }
       end
 
-      def get_default_work_loop_config
+      def default_work_loop_config
         {
           enabled: true,
           max_iterations: 50,
           test_commands: [],
-          lint_commands: []
+          lint_commands: [],
+          guards: default_guards_config
+        }
+      end
+
+      def default_guards_config
+        {
+          enabled: false,
+          include_files: [],
+          exclude_files: [],
+          confirm_files: [],
+          max_lines_per_commit: nil,
+          bypass: false
         }
       end
 
-      def get_default_logging_config
+      def default_logging_config
         {
           log_level: :info,
           retention_days: 30,
@@ -463,7 +510,7 @@ module Aidp
         }
       end
 
-      def get_default_fallback_config
+      def default_fallback_config
         {
           strategies: {
             rate_limit: {

data/lib/aidp/harness/error_handler.rb

@@ -53,7 +53,7 @@ module Aidp
         @error_history << error_info
 
         # Get retry strategy for this error type
-        strategy = get_retry_strategy(error_info[:error_type])
+        strategy = retry_strategy(error_info[:error_type])
 
         # Check if we should retry
         if should_retry?(error_info, strategy)
@@ -97,17 +97,17 @@ module Aidp
             attempt += 1
             return yield
           rescue => error
-            current_provider = get_current_provider_safely
+            current_provider = current_provider_safely
 
             if attempt < max_attempts
               error_info = {
                 error: error,
                 provider: current_provider,
-                model: get_current_model_safely,
+                model: current_model_safely,
                 error_type: @error_classifier.classify_error(error)
               }
 
-              strategy = get_retry_strategy(error_info[:error_type])
+              strategy = retry_strategy(error_info[:error_type])
               if should_retry?(error_info, strategy)
                 delay = @backoff_calculator.calculate_delay(attempt, strategy[:backoff_strategy] || :exponential, 1, 10)
                 debug_log("🔁 Retry attempt #{attempt} for #{current_provider}", level: :info, data: {delay: delay, error_type: error_info[:error_type]})
@@ -120,11 +120,11 @@ module Aidp
             debug_log("🚫 Exhausted retries for provider, attempting recovery", level: :warn, data: {provider: current_provider, attempt: attempt, max_attempts: max_attempts})
             handle_error(error, {
               provider: current_provider,
-              model: get_current_model_safely,
+              model: current_model_safely,
               exhausted_retries: true
             })
 
-            new_provider = get_current_provider_safely
+            new_provider = current_provider_safely
             if new_provider != current_provider && !providers_tried.include?(new_provider)
               providers_tried << current_provider
               # Reset retry counts for the new provider
@@ -233,7 +233,7 @@ module Aidp
       end
 
       # Get retry strategy for error type
-      def get_retry_strategy(error_type)
+      def retry_strategy(error_type)
         @retry_strategies[error_type] || @retry_strategies[:default]
       end
 
@@ -270,7 +270,7 @@ module Aidp
       end
 
       # Get retry status for a provider/model
-      def get_retry_status(provider, model = nil)
+      def retry_status(provider, model = nil)
         keys = if model
           @retry_counts.keys.select { |k| k.start_with?("#{provider}:#{model}:") }
         else
@@ -282,7 +282,7 @@ module Aidp
           error_type = key.split(":").last
           status[error_type] = {
             retry_count: @retry_counts[key],
-            max_retries: get_retry_strategy(error_type.to_sym)[:max_retries]
+            max_retries: retry_strategy(error_type.to_sym)[:max_retries]
           }
         end
 
@@ -290,7 +290,7 @@ module Aidp
       end
 
       # Get error history
-      def get_error_history(time_range = nil)
+      def error_history(time_range = nil)
         if time_range
           @error_history.select { |e| time_range.include?(e[:timestamp]) }
         else
@@ -304,7 +304,7 @@ module Aidp
       end
 
       # Get circuit breaker status
-      def get_circuit_breaker_status
+      def circuit_breaker_status
         @circuit_breakers.transform_values do |cb|
           {
             open: cb[:open],
@@ -667,7 +667,7 @@ module Aidp
       end
 
       # Safe access to provider manager methods that may not exist
-      def get_current_provider_safely
+      def current_provider_safely
         return "unknown" unless @provider_manager
         return "unknown" unless @provider_manager.respond_to?(:current_provider)
 
@@ -677,7 +677,7 @@ module Aidp
         "unknown"
       end
 
-      def get_current_model_safely
+      def current_model_safely
         return "unknown" unless @provider_manager
         return "unknown" unless @provider_manager.respond_to?(:current_model)