aidp 0.17.0 → 0.18.0

data/lib/aidp/harness/configuration.rb

@@ -209,6 +209,86 @@ module Aidp
         guards_config[:bypass] == true
       end
 
+      # Get version control configuration
+      def version_control_config
+        work_loop_config[:version_control] || default_version_control_config
+      end
+
+      # Get VCS tool
+      def vcs_tool
+        version_control_config[:tool]
+      end
+
+      # Get VCS behavior (stage/commit/nothing)
+      def vcs_behavior
+        version_control_config[:behavior]
+      end
+
+      # Check if conventional commits are enabled
+      def conventional_commits?
+        version_control_config[:conventional_commits] == true
+      end
+
+      # Get coverage configuration
+      def coverage_config
+        work_loop_config[:coverage] || default_coverage_config
+      end
+
+      # Check if coverage is enabled
+      def coverage_enabled?
+        coverage_config[:enabled] == true
+      end
+
+      # Get coverage tool
+      def coverage_tool
+        coverage_config[:tool]
+      end
+
+      # Get coverage run command
+      def coverage_run_command
+        coverage_config[:run_command]
+      end
+
+      # Get coverage report paths
+      def coverage_report_paths
+        coverage_config[:report_paths] || []
+      end
+
+      # Check if should fail on coverage drop
+      def coverage_fail_on_drop?
+        coverage_config[:fail_on_drop] == true
+      end
+
+      # Get minimum coverage threshold
+      def coverage_minimum
+        coverage_config[:minimum_coverage]
+      end
+
+      # Get interactive testing configuration
+      def interactive_testing_config
+        work_loop_config[:interactive_testing] || default_interactive_testing_config
+      end
+
+      # Check if interactive testing is enabled
+      def interactive_testing_enabled?
+        interactive_testing_config[:enabled] == true
+      end
+
+      # Get interactive testing app type
+      def interactive_testing_app_type
+        interactive_testing_config[:app_type]
+      end
+
+      # Get interactive testing tools configuration
+      def interactive_testing_tools
+        interactive_testing_config[:tools] || {}
+      end
+
+      # Get model family for a provider
+      def model_family(provider_name)
+        provider_config(provider_name)[:model_family] || "auto"
+      end
+
       # Get provider priority
       def provider_priority(provider_name)
         provider_config(provider_name)[:priority] || 0
@@ -259,6 +339,62 @@ module Aidp
         harness_config[:logging] || default_logging_config
       end
 
+      # Get thinking depth configuration
+      def thinking_config
+        @config[:thinking] || default_thinking_config
+      end
+
+      # Get default thinking tier
+      def default_tier
+        thinking_config[:default_tier] || "standard"
+      end
+
+      # Get maximum thinking tier
+      def max_tier
+        thinking_config[:max_tier] || "standard"
+      end
+
+      # Check if provider switching for tier is allowed
+      def allow_provider_switch_for_tier?
+        thinking_config[:allow_provider_switch] != false
+      end
+
+      # Get escalation configuration
+      def escalation_config
+        thinking_config[:escalation] || default_escalation_config
+      end
+
+      # Get fail attempts threshold for escalation
+      def escalation_fail_attempts
+        escalation_config[:on_fail_attempts] || 2
+      end
+
+      # Get complexity threshold configuration for escalation
+      def escalation_complexity_threshold
+        escalation_config[:on_complexity_threshold] || {}
+      end
+
+      # Get permissions by tier configuration
+      def permissions_by_tier
+        thinking_config[:permissions_by_tier] || {}
+      end
+
+      # Get permission level for a tier
+      def permission_for_tier(tier)
+        permissions_by_tier[tier] || permissions_by_tier[tier.to_sym] || "tools"
+      end
+
+      # Get thinking tier overrides
+      def thinking_overrides
+        thinking_config[:overrides] || {}
+      end
+
+      # Get tier override for a skill or template
+      # @param key [String] skill or template key (e.g., "skill.generate_tests", "template.large_refactor")
+      def tier_override_for(key)
+        thinking_overrides[key] || thinking_overrides[key.to_sym]
+      end
+
       # Get fallback configuration
       def fallback_config
         harness_config[:fallback] || default_fallback_config
@@ -341,6 +477,209 @@ module Aidp
         errors
       end
 
+      # Check if auto-escalation is enabled
+      def auto_escalate?
+        thinking_config[:auto_escalate] != false
+      end
+
+      # Get escalation threshold
+      def escalation_threshold
+        thinking_config[:escalation_threshold] || 2
+      end
+
+      # Get tier overrides
+      def tier_overrides
+        thinking_config[:overrides] || {}
+      end
+
+      # Get ZFC configuration
+      def zfc_config
+        @config[:zfc] || default_zfc_config
+      end
+
+      # Check if ZFC is enabled
+      def zfc_enabled?
+        zfc_config[:enabled] == true
+      end
+
+      # Check if ZFC should fallback to legacy on failure
+      def zfc_fallback_to_legacy?
+        zfc_config[:fallback_to_legacy] != false
+      end
+
+      # Get ZFC decision configuration
+      def zfc_decision_config(decision_type)
+        zfc_config.dig(:decisions, decision_type.to_sym) || {}
+      end
+
+      # Check if specific ZFC decision type is enabled
+      def zfc_decision_enabled?(decision_type)
+        return false unless zfc_enabled?
+        decision_config = zfc_decision_config(decision_type)
+        decision_config[:enabled] == true
+      end
+
+      # Get ZFC decision tier
+      def zfc_decision_tier(decision_type)
+        zfc_decision_config(decision_type)[:tier] || "mini"
+      end
+
+      # Get ZFC decision cache TTL
+      def zfc_decision_cache_ttl(decision_type)
+        zfc_decision_config(decision_type)[:cache_ttl]
+      end
+
+      # Get ZFC decision confidence threshold
+      def zfc_decision_confidence_threshold(decision_type)
+        zfc_decision_config(decision_type)[:confidence_threshold] || 0.7
+      end
+
+      # Get ZFC cost limits
+      def zfc_cost_limits
+        zfc_config[:cost_limits] || default_zfc_cost_limits
+      end
+
+      # Get ZFC A/B testing configuration
+      def zfc_ab_testing_config
+        zfc_config[:ab_testing] || default_zfc_ab_testing_config
+      end
+
+      # Check if ZFC A/B testing is enabled
+      def zfc_ab_testing_enabled?
+        zfc_ab_testing_config[:enabled] == true
+      end
+
+      # Prompt optimization configuration methods
+
+      # Get prompt optimization configuration
+      def prompt_optimization_config
+        @config[:prompt_optimization] || default_prompt_optimization_config
+      end
+
+      # Check if prompt optimization is enabled
+      def prompt_optimization_enabled?
+        prompt_optimization_config[:enabled] == true
+      end
+
+      # Get maximum tokens for prompt
+      def prompt_max_tokens
+        prompt_optimization_config[:max_tokens] || 16000
+      end
+
+      # Get include threshold configuration
+      def prompt_include_thresholds
+        prompt_optimization_config[:include_threshold] || default_include_thresholds
+      end
+
+      # Get style guide include threshold
+      def prompt_style_guide_threshold
+        prompt_include_thresholds[:style_guide] || 0.75
+      end
+
+      # Get templates include threshold
+      def prompt_templates_threshold
+        prompt_include_thresholds[:templates] || 0.8
+      end
+
+      # Get source code include threshold
+      def prompt_source_threshold
+        prompt_include_thresholds[:source] || 0.7
+      end
+
+      # Check if dynamic adjustment is enabled
+      def prompt_dynamic_adjustment?
+        prompt_optimization_config[:dynamic_adjustment] != false
+      end
+
+      # Check if fragment logging is enabled
+      def prompt_log_fragments?
+        prompt_optimization_config[:log_selected_fragments] == true
+      end
+
+      # Devcontainer configuration methods
+
+      # Get devcontainer configuration
+      def devcontainer_config
+        @config[:devcontainer] || default_devcontainer_config
+      end
+
+      # Check if devcontainer features are enabled
+      def devcontainer_enabled?
+        devcontainer_config[:enabled] != false
+      end
+
+      # Check if full permissions should be granted in devcontainer
+      def full_permissions_in_devcontainer?
+        devcontainer_config[:full_permissions_when_in_devcontainer] == true
+      end
+
+      # Get forced detection value (nil for auto-detection)
+      def devcontainer_force_detection
+        devcontainer_config[:force_detection]
+      end
+
+      # Check if currently in devcontainer (with optional force override)
+      def in_devcontainer?
+        forced = devcontainer_force_detection
+        return forced unless forced.nil?
+
+        require_relative "../utils/devcontainer_detector"
+        Aidp::Utils::DevcontainerDetector.in_devcontainer?
+      end
+
+      # Get devcontainer permissions config
+      def devcontainer_permissions
+        devcontainer_config[:permissions] || {}
+      end
+
+      # Check if dangerous filesystem operations are allowed in devcontainer
+      def devcontainer_dangerous_ops_allowed?
+        devcontainer_permissions[:dangerous_filesystem_ops] == true
+      end
+
+      # Get list of providers that should skip permission checks in devcontainer
+      def devcontainer_skip_permission_checks
+        devcontainer_permissions[:skip_permission_checks] || []
+      end
+
+      # Check if a specific provider should skip permission checks in devcontainer
+      def devcontainer_skip_permissions_for?(provider_name)
+        devcontainer_skip_permission_checks.include?(provider_name.to_s)
+      end
+
+      # Get devcontainer settings
+      def devcontainer_settings
+        devcontainer_config[:settings] || {}
+      end
+
+      # Get timeout multiplier for devcontainer
+      def devcontainer_timeout_multiplier
+        devcontainer_settings[:timeout_multiplier] || 1.0
+      end
+
+      # Check if verbose logging is enabled in devcontainer
+      def devcontainer_verbose_logging?
+        devcontainer_settings[:verbose_logging] == true
+      end
+
+      # Get allowed domains for devcontainer firewall
+      def devcontainer_allowed_domains
+        devcontainer_settings[:allowed_domains] || []
+      end
+
+      # Check if provider should run with full permissions
+      # Combines devcontainer detection with configuration
+      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
+
       private
 
       def validate_configuration!
@@ -557,6 +896,53 @@ module Aidp
         }
       end
 
+      def default_version_control_config
+        {
+          tool: "git",
+          behavior: "nothing",
+          conventional_commits: false
+        }
+      end
+
+      def default_coverage_config
+        {
+          enabled: false,
+          tool: nil,
+          run_command: nil,
+          report_paths: [],
+          fail_on_drop: false,
+          minimum_coverage: nil
+        }
+      end
+
+      def default_interactive_testing_config
+        {
+          enabled: false,
+          app_type: "web",
+          tools: {}
+        }
+      end
+
+      def default_thinking_config
+        {
+          default_tier: "mini",  # Use mini tier by default for cost optimization
+          max_tier: "max",
+          allow_provider_switch: true,
+          auto_escalate: true,
+          escalation_threshold: 2,
+          escalation: default_escalation_config,
+          permissions_by_tier: {},
+          overrides: {}
+        }
+      end
+
+      def default_escalation_config
+        {
+          on_fail_attempts: 2,
+          on_complexity_threshold: {}
+        }
+      end
+
       def default_logging_config
         {
           log_level: :info,
@@ -613,6 +999,72 @@ module Aidp
         }
       end
 
+      # Default ZFC configuration
+      def default_zfc_config
+        {
+          enabled: false,  # Experimental feature - disabled by default
+          fallback_to_legacy: true,
+          decisions: {},
+          cost_limits: default_zfc_cost_limits,
+          ab_testing: default_zfc_ab_testing_config
+        }
+      end
+
+      # Default ZFC cost limits
+      def default_zfc_cost_limits
+        {
+          max_daily_cost: 5.00,
+          max_cost_per_decision: 0.01,
+          alert_threshold: 0.8
+        }
+      end
+
+      # Default ZFC A/B testing configuration
+      def default_zfc_ab_testing_config
+        {
+          enabled: false,
+          sample_rate: 0.1,
+          log_comparisons: true
+        }
+      end
+
+      # Default prompt optimization configuration
+      def default_prompt_optimization_config
+        {
+          enabled: false,  # Experimental feature - disabled by default
+          max_tokens: 16000,
+          include_threshold: default_include_thresholds,
+          dynamic_adjustment: true,
+          log_selected_fragments: false
+        }
+      end
+
+      # Default include thresholds for prompt optimization
+      def default_include_thresholds
+        {
+          style_guide: 0.75,
+          templates: 0.8,
+          source: 0.7
+        }
+      end
+
+      def default_devcontainer_config
+        {
+          enabled: true,
+          full_permissions_when_in_devcontainer: false,
+          force_detection: nil,
+          permissions: {
+            dangerous_filesystem_ops: false,
+            skip_permission_checks: []
+          },
+          settings: {
+            timeout_multiplier: 1.0,
+            verbose_logging: false,
+            allowed_domains: []
+          }
+        }
+      end
+
       # Custom error class for configuration issues
       class ConfigurationError < StandardError; end
     end

data/lib/aidp/harness/enhanced_runner.rb

@@ -22,10 +22,19 @@ module Aidp
         error: "error"
       }.freeze
 
-      def initialize(project_dir, mode = :analyze, options = {})
+      # Simple sleeper abstraction for test control
+      class Sleeper
+        def sleep(duration)
+          Kernel.sleep(duration)
+        end
+      end
+
+      def initialize(project_dir, mode = :analyze, options = {}, prompt: TTY::Prompt.new, sleeper: Sleeper.new)
         @project_dir = project_dir
         @mode = mode.to_sym
         @options = options
+        @prompt = prompt
+        @sleeper = sleeper
         @state = STATES[:idle]
         @start_time = nil
         @current_step = nil
@@ -49,8 +58,14 @@ module Aidp
         # Initialize other components
         @configuration = Configuration.new(project_dir)
         @state_manager = StateManager.new(project_dir, @mode)
-        @condition_detector = ConditionDetector.new
-        @provider_manager = ProviderManager.new(@configuration, prompt: TTY::Prompt.new)
+        @provider_manager = ProviderManager.new(@configuration, prompt: @prompt)
+
+        # Use ZFC-enabled condition detector
+        # ZfcConditionDetector will create its own ProviderFactory if needed
+        # Falls back to legacy pattern matching when ZFC is disabled
+        require_relative "zfc_condition_detector"
+        @condition_detector = ZfcConditionDetector.new(@configuration)
+
         @error_handler = ErrorHandler.new(@provider_manager, @configuration)
         @completion_checker = CompletionChecker.new(@project_dir, @workflow_type)
       end
@@ -240,7 +255,7 @@ module Aidp
         # Remove job after a delay to show completion
         # UI delay to let user see completion status before removal
         Thread.new do
-          sleep 2  # Acceptable for UI timing
+          @sleeper.sleep(2) # UI timing delay
           @tui.remove_job(step_job_id)
         end
 
@@ -349,9 +364,9 @@ module Aidp
       def get_mode_runner
         case @mode
         when :analyze
-          Aidp::Analyze::Runner.new(@project_dir, self, prompt: TTY::Prompt.new)
+          Aidp::Analyze::Runner.new(@project_dir, self, prompt: @prompt)
         when :execute
-          Aidp::Execute::Runner.new(@project_dir, self, prompt: TTY::Prompt.new)
+          Aidp::Execute::Runner.new(@project_dir, self, prompt: @prompt)
         else
           raise ArgumentError, "Unsupported mode: #{@mode}"
         end
@@ -376,7 +391,7 @@ module Aidp
       def handle_pause_condition
         case @state
         when STATES[:paused]
-          sleep(1)
+          @sleeper.sleep(1)
         when STATES[:waiting_for_user]
           # User interface handles this
           nil
@@ -503,7 +518,7 @@ module Aidp
         while Time.now < reset_time && @state == STATES[:waiting_for_rate_limit]
           remaining = reset_time - Time.now
           @tui.show_message("⏳ Rate limit reset in #{remaining.to_i} seconds", :info)
-          sleep(1)
+          @sleeper.sleep(1)
         end
       end
 

data/lib/aidp/harness/error_handler.rb

@@ -10,10 +10,19 @@ module Aidp
     class ErrorHandler
       include Aidp::DebugMixin
 
-      def initialize(provider_manager, configuration, metrics_manager = nil)
+      # Simple wrapper to allow dependency injection of sleep behavior in tests
+      class Sleeper
+        def sleep(seconds)
+          Kernel.sleep(seconds)
+        end
+      end
+
+      # @param sleeper [#sleep] object responding to sleep(seconds); injectable for tests
+      def initialize(provider_manager, configuration, metrics_manager = nil, sleeper: nil)
         @provider_manager = provider_manager
         @configuration = configuration
         @metrics_manager = metrics_manager
+        @sleeper = sleeper || Sleeper.new
         @retry_strategies = {}
         @retry_counts = {}
         @error_history = []
@@ -112,7 +121,7 @@ module Aidp
               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]})
-                sleep(delay) if delay > 0
+                @sleeper.sleep(delay) if delay > 0
                 retry
               end
             end
@@ -191,9 +200,7 @@ module Aidp
         )
 
         # Wait for backoff delay
-        if delay > 0
-          sleep(delay)
-        end
+        @sleeper.sleep(delay) if delay > 0
 
         # Execute the retry
         retry_result = execute_retry_attempt(error_info, strategy, context)

data/lib/aidp/harness/provider_factory.rb

@@ -5,7 +5,6 @@ require_relative "../providers/base"
 require_relative "../providers/cursor"
 require_relative "../providers/anthropic"
 require_relative "../providers/gemini"
-require_relative "../providers/macos_ui"
 require_relative "../providers/opencode"
 require_relative "../providers/github_copilot"
 require_relative "../providers/codex"
@@ -19,7 +18,6 @@ module Aidp
         "anthropic" => Aidp::Providers::Anthropic,
         "claude" => Aidp::Providers::Anthropic,
         "gemini" => Aidp::Providers::Gemini,
-        "macos" => Aidp::Providers::MacOSUI,
         "opencode" => Aidp::Providers::Opencode,
         "github_copilot" => Aidp::Providers::GithubCopilot,
         "codex" => Aidp::Providers::Codex

data/lib/aidp/harness/provider_manager.rb

@@ -12,9 +12,10 @@ module Aidp
       include Aidp::MessageDisplay
       include Aidp::RescueLogging
 
-      def initialize(configuration, prompt: TTY::Prompt.new)
+      def initialize(configuration, prompt: TTY::Prompt.new, binary_checker: Aidp::Util)
         @configuration = configuration
         @prompt = prompt
+        @binary_checker = binary_checker
         @current_provider = nil
         @current_model = nil
         @provider_history = []
@@ -1069,18 +1070,6 @@ module Aidp
       def provider_cli_available?(provider_name)
         normalized = normalize_provider_name(provider_name)
 
-        # Handle test environment overrides
-        if defined?(RSpec) || ENV["RSPEC_RUNNING"]
-          # Force claude to be missing for testing
-          if ENV["AIDP_FORCE_CLAUDE_MISSING"] == "1" && normalized == "claude"
-            return [false, "binary_missing"]
-          end
-          # Force claude to be available for testing
-          if ENV["AIDP_FORCE_CLAUDE_AVAILABLE"] == "1" && normalized == "claude"
-            return [true, "available"]
-          end
-        end
-
         cache_key = "#{provider_name}:#{normalized}"
         cached = @binary_check_cache[cache_key]
         if cached && (Time.now - cached[:checked_at] < @binary_check_ttl)
@@ -1098,7 +1087,7 @@ module Aidp
           return [true, nil]
         end
         path = begin
-          Aidp::Util.which(binary)
+          @binary_checker.which(binary)
         rescue => e
           log_rescue(e, component: "provider_manager", action: "locate_binary", fallback: nil, binary: binary)
           nil
@@ -1164,10 +1153,6 @@ module Aidp
         statuses = provider_health_status
         metrics = all_metrics
         configured = configured_providers
-        # Ensure fresh binary probe results in test mode so stubs of Aidp::Util.which take effect
-        if defined?(RSpec) || ENV["RSPEC_RUNNING"]
-          @binary_check_cache.clear
-        end
         rows_by_normalized = {}
         configured.each do |prov|
           # Temporarily hide macos provider until it's user-configurable
@@ -1384,7 +1369,7 @@ module Aidp
         @current_provider = provider_type
 
         # Execute the prompt with the provider
-        result = provider.send(prompt: prompt, session: nil)
+        result = provider.send_message(prompt: prompt, session: nil)
 
         # Return structured result
         {

data/lib/aidp/harness/runner.rb

@@ -52,8 +52,14 @@ module Aidp
         # Initialize components
         @config_manager = ConfigManager.new(project_dir)
         @state_manager = StateManager.new(project_dir, @mode)
-        @condition_detector = ConditionDetector.new
         @provider_manager = ProviderManager.new(@config_manager, prompt: @prompt)
+
+        # Use ZFC-enabled condition detector
+        # ZfcConditionDetector will create its own ProviderFactory if needed
+        # Falls back to legacy pattern matching when ZFC is disabled
+        require_relative "zfc_condition_detector"
+        @condition_detector = ZfcConditionDetector.new(@config_manager)
+
         @user_interface = SimpleUserInterface.new
         @error_handler = ErrorHandler.new(@provider_manager, @config_manager)
         @status_display = StatusDisplay.new
@@ -188,9 +194,9 @@ module Aidp
       def get_mode_runner
         case @mode
         when :analyze
-          Aidp::Analyze::Runner.new(@project_dir, self, prompt: TTY::Prompt.new)
+          Aidp::Analyze::Runner.new(@project_dir, self, prompt: @prompt)
         when :execute
-          Aidp::Execute::Runner.new(@project_dir, self, prompt: TTY::Prompt.new)
+          Aidp::Execute::Runner.new(@project_dir, self, prompt: @prompt)
         else
           raise ArgumentError, "Unsupported mode: #{@mode}"
         end