aidp 0.30.0 → 0.32.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: dcf4f30f93195b349c527dd5531e056ad566a34be1ed079ced4b5002f07a93f5
-  data.tar.gz: 22a7ef871ab691e0072a1bc8f1254784e1605f46d3edfc9585e91c3a21c5180f
+  metadata.gz: c7a02d5fb9cd901a6a74a2b402c5b9d70ea07f47727ddbd388993e9ede64c96b
+  data.tar.gz: fc92260f2b244295b98b5e2e2cdedf4872a18f94f5c3b8bf0031b6a4fc1f6554
 SHA512:
-  metadata.gz: c5630eb8255464816006bb091b02666b29ac58b4a1e3e9136c17f79dff54762d6ebe16a4ec45df3f26c22047959121db04ef4e94904be5a4fb2e03320c6a6113
-  data.tar.gz: 5bdae7edfb7aad8ef03dd2274c4a8095bd927097cbd882a28856f0f753b46c4f1f0d8f756801c6df239bd13540355cbf9e53805b3bc815e5ac1cfc407d61c1c9
+  metadata.gz: 673505d4036ad47cff7ff1b534e1798e893dcf7fc77f086ee1b6f46ba90b48de4b72333cf63b15db1fd0b16b2b0060c324fe6a1bdf371ae7ec796ce606b454e7
+  data.tar.gz: f99df6bea4120ec723a907e4f4a1cc15dc1c5c52abf3c4753bc5cdd24e6288a5207dca6ae6dc85a6afab442dc2b845de7d7794731f1bd27caeaf22c9e46f656f

data/lib/aidp/config.rb

@@ -111,11 +111,10 @@ module Aidp
           model_family: "claude",
           max_tokens: 100_000,
           default_flags: ["--dangerously-skip-permissions"],
-          models: ["claude-3-5-sonnet-20241022", "claude-3-5-haiku-20241022", "claude-3-opus-20240229"],
+          models: ["claude-3-5-sonnet-20241022", "claude-3-5-haiku-20241022"],
           model_weights: {
             "claude-3-5-sonnet-20241022" => 3,
-            "claude-3-5-haiku-20241022" => 2,
-            "claude-3-opus-20240229" => 1
+            "claude-3-5-haiku-20241022" => 2
           },
           models_config: {
             "claude-3-5-sonnet-20241022" => {
@@ -127,11 +126,6 @@ module Aidp
               flags: ["--dangerously-skip-permissions"],
               max_tokens: 200_000,
               timeout: 180
-            },
-            "claude-3-opus-20240229" => {
-              flags: ["--dangerously-skip-permissions"],
-              max_tokens: 200_000,
-              timeout: 600
             }
           },
           auth: {

data/lib/aidp/execute/work_loop_runner.rb

@@ -7,6 +7,7 @@ require_relative "guard_policy"
 require_relative "work_loop_unit_scheduler"
 require_relative "deterministic_unit"
 require_relative "agent_signal_parser"
+require_relative "steps"
 require_relative "../harness/test_runner"
 require_relative "../errors"
 
@@ -81,6 +82,7 @@ module Aidp
 
         display_message("🔄 Starting hybrid work loop for step: #{step_name}", type: :info)
         display_message("  Flow: Deterministic ↔ Agentic with fix-forward core", type: :info)
+        display_work_context(step_name, context)
 
         display_guard_policy_status
         display_pending_tasks
@@ -1286,6 +1288,74 @@ module Aidp
         display_message("")
       end
 
+      # Show watch-mode context (issue/PR, step position) to improve situational awareness
+      def display_work_context(step_name, context)
+        parts = work_context_parts(step_name, context)
+        return if parts.empty?
+
+        Aidp.log_debug("work_loop", "work_context", step: step_name, parts: parts)
+        display_message("  📡 Context: #{parts.join(" | ")}", type: :info)
+      end
+
+      def work_context_parts(step_name, context)
+        ctx = (@options || {}).merge(context || {})
+        parts = []
+
+        if (step_label = step_position_label(step_name, ctx))
+          parts << step_label
+        end
+
+        if (issue_label = issue_context_label(ctx))
+          parts << issue_label
+        end
+
+        if (pr_label = pr_context_label(ctx))
+          parts << pr_label
+        end
+
+        parts << "Watch mode" if ctx[:workflow_type].to_s == "watch_mode"
+
+        parts.compact
+      end
+
+      def step_position_label(step_name, context)
+        steps = Array(context[:selected_steps]).map(&:to_s)
+        steps = Aidp::Execute::Steps::SPEC.keys if steps.empty?
+        steps = [step_name] if steps.empty?
+        steps << step_name unless steps.include?(step_name)
+
+        index = steps.index(step_name)
+        return nil unless index
+
+        "Step #{index + 1}/#{steps.size} (#{step_name})"
+      end
+
+      def issue_context_label(context)
+        issue_number = context[:issue_number] ||
+          context.dig(:issue, :number) ||
+          extract_number_from_url(context[:issue_url] || context.dig(:issue, :url) || context.dig(:user_input, "Issue URL"), /issues\/(\d+)/)
+
+        return nil unless issue_number
+
+        "Issue ##{issue_number}"
+      end
+
+      def pr_context_label(context)
+        pr_number = context[:pr_number] ||
+          context.dig(:pull_request, :number) ||
+          extract_number_from_url(context[:pr_url] || context.dig(:pull_request, :url) || context.dig(:user_input, "PR URL") || context.dig(:user_input, "Pull Request URL"), /pull\/(\d+)/)
+
+        return nil unless pr_number
+
+        "PR ##{pr_number}"
+      end
+
+      def extract_number_from_url(url, pattern)
+        return nil unless url
+        match = url.to_s.match(pattern)
+        match && match[1]
+      end
+
       # Append task completion requirement to PROMPT.md
       def append_task_requirement_to_prompt(message)
         task_requirement = []

data/lib/aidp/harness/configuration.rb

@@ -1057,7 +1057,7 @@ module Aidp
       def default_thinking_config
         {
           default_tier: "mini",  # Use mini tier by default for cost optimization
-          max_tier: "max",
+          max_tier: "pro",       # Max tier rarely needed; pro is sufficient for most tasks
           allow_provider_switch: true,
           auto_escalate: true,
           escalation_threshold: 2,

data/lib/aidp/harness/provider_manager.rb

@@ -38,6 +38,7 @@ module Aidp
         @model_fallback_chains = {}
         @model_switching_enabled = true
         @model_weights = {}
+        @model_denylist = Hash.new { |h, k| h[k] = [] }
         @unavailable_cache = {}
         @binary_check_cache = {}
         @binary_check_ttl = 300 # seconds
@@ -387,10 +388,30 @@ module Aidp
         # Check if model is configured for provider
         return false unless model_configured?(provider_name, model_name)
 
+        # Skip models that were explicitly denied (e.g., unsupported by provider)
+        return false if model_denied?(provider_name, model_name)
+
         # Check if model is not rate limited
         !is_model_rate_limited?(provider_name, model_name)
       end
 
+      # Check if a model has been denylisted for a provider
+      def model_denied?(provider_name, model_name)
+        @model_denylist[provider_name]&.include?(model_name)
+      end
+
+      # Add a model to the denylist for a provider (e.g., unsupported model errors)
+      def deny_model(provider_name, model_name, error: nil)
+        return if provider_name.nil? || model_name.nil?
+        return if model_denied?(provider_name, model_name)
+
+        @model_denylist[provider_name] << model_name
+        Aidp.log_debug("provider_manager", "model_denylisted",
+          provider: provider_name,
+          model: model_name,
+          error: error&.message)
+      end
+
       # Check if model is configured for provider
       def model_configured?(provider_name, model_name)
         models = provider_models(provider_name)
@@ -1279,6 +1300,7 @@ module Aidp
         @model_health.clear
         @model_metrics.clear
         @model_fallback_chains.clear
+        @model_denylist.clear
         @model_rate_limit_info&.clear
         @model_history&.clear
         initialize_fallback_chains
@@ -1394,9 +1416,9 @@ module Aidp
 
       # Execute a prompt with a specific provider
       def execute_with_provider(provider_type, prompt, options = {})
-        # Extract model and tier from options if provided
+        # Extract model from options if provided
         model_name = options.delete(:model)
-        tier = options[:tier] # Keep tier in options for provider
+        retry_on_rate_limit = options.delete(:retry_on_rate_limit) != false # Default true
 
         # Create provider factory instance
         provider_factory = ProviderFactory.new
@@ -1415,11 +1437,10 @@ module Aidp
         Aidp.logger.debug("provider_manager", "Executing with provider",
           provider: provider_type,
           model: model_name,
-          tier: tier,
           prompt_length: prompt.length)
 
-        # Execute the prompt with the provider (pass options including tier)
-        result = provider.send_message(prompt: prompt, session: nil, options: options)
+        # Execute the prompt with the provider
+        result = provider.send_message(prompt: prompt, session: nil)
 
         # Return structured result
         {
@@ -1436,6 +1457,42 @@ module Aidp
         }
       rescue => e
         log_rescue(e, component: "provider_manager", action: "execute_with_provider", fallback: "error_result", provider: provider_type, model: model_name, prompt_length: prompt.length)
+
+        if unsupported_model_error?(e, model_name)
+          deny_model(provider_type, model_name, error: e)
+        end
+
+        # Detect rate limit / quota errors and attempt fallback
+        error_message = e.message.to_s.downcase
+        is_rate_limit = error_message.include?("rate limit") ||
+          error_message.include?("quota") ||
+          error_message.include?("limit reached") ||
+          error_message.include?("resource exhausted") ||
+          error_message.include?("too many requests")
+
+        if is_rate_limit && retry_on_rate_limit
+          Aidp.logger.warn("provider_manager", "Rate limit detected, attempting fallback",
+            provider: provider_type,
+            model: model_name,
+            error: e.message)
+
+          # Attempt to switch to fallback provider
+          fallback_provider = switch_provider_for_error("rate_limit", {
+            original_provider: provider_type,
+            model: model_name,
+            error_message: e.message
+          })
+
+          if fallback_provider && fallback_provider != provider_type
+            Aidp.logger.info("provider_manager", "Retrying with fallback provider",
+              original: provider_type,
+              fallback: fallback_provider)
+
+            # Retry with fallback provider (disable retry to prevent infinite loop)
+            return execute_with_provider(fallback_provider, prompt, options.merge(retry_on_rate_limit: false))
+          end
+        end
+
         # Return error result
         {
           status: "error",
@@ -1552,6 +1609,18 @@ module Aidp
         ((order[a] || 0) >= (order[b] || 0)) ? a : b
       end
 
+      # Detect unsupported/invalid model errors to avoid reusing the model
+      def unsupported_model_error?(error, model_name)
+        return false if model_name.nil?
+
+        message = error&.message.to_s.downcase
+        return false if message.empty?
+
+        (message.include?("unsupported") && message.include?("model")) ||
+          (message.include?("model") && message.include?("not supported")) ||
+          message.include?("invalid model")
+      end
+
       public
 
       # Log provider switch

data/lib/aidp/harness/provider_metrics.rb

@@ -3,6 +3,7 @@
 require "yaml"
 require "fileutils"
 require_relative "../rescue_logging"
+require_relative "../util"
 
 module Aidp
   module Harness
@@ -14,9 +15,10 @@ module Aidp
       attr_reader :project_dir, :metrics_file, :rate_limit_file
 
       def initialize(project_dir)
-        @project_dir = project_dir
-        @metrics_file = File.join(project_dir, ".aidp", "provider_metrics.yml")
-        @rate_limit_file = File.join(project_dir, ".aidp", "provider_rate_limits.yml")
+        # Store metrics at the repository root so different worktrees/modes share state
+        @project_dir = Aidp::Util.find_project_root(project_dir)
+        @metrics_file = File.join(@project_dir, ".aidp", "provider_metrics.yml")
+        @rate_limit_file = File.join(@project_dir, ".aidp", "provider_rate_limits.yml")
         ensure_directory
       end