aidp 0.17.1 → 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

@@ -58,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: @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

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/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