ace-review 0.53.5 → 0.53.6

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: c50e105e74afc8802976a5c869debdd9514996f8c5c48c1ff0cc2266f1a2622f
-  data.tar.gz: 18512f481aa7315c446b7bfb93d7844dde492f1369b3a33cc34c3edb590bb1d0
+  metadata.gz: 647741c9f1b7814b5471a9a07c4f1693ac649f953d3f530bae67516a81cd7f0d
+  data.tar.gz: 520c59a0dda292b28d383215606fb7463d64d35f3b3ef0c024428243f2dc0870
 SHA512:
-  metadata.gz: 1869bc1bcbe622b59b88189ccbaf09192b183b44aac2a10d926b38befbb58f6e01a54601c218234d0e681532d590a4bf2d531d3ca5f027dda17957f19a046270
-  data.tar.gz: 68f5a18ae201735fb0577235d1a9bc53e703ea2e44c89e927b053e1048fa1bcfb2782facfed324a612b42cc8a07956fd96a99cc18599ebdd3538c86bcccb7105
+  metadata.gz: cb3239ee728103949252327de0a7b97de54ea1747ca3a8c2c2fd1e930281091bcb57ce14de3ca44041bf2d95d14608883b753f4af2b85f2d4d019fd4829bfb32
+  data.tar.gz: 892722919f96459f188ddd278f8d42f0538f81297fd9c87729302ca2072f9c62901f58396a7a17a72bb6c677394eb1f341927c2b3a0d53b199450a8dd845d0a1

data/CHANGELOG.md

@@ -7,6 +7,11 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+## [0.53.6] - 2026-04-24
+
+### Fixed
+- Sized review prompts and adaptive review execution against the resolved concrete model target so role and alias-based reviews no longer rely on provider-wide context assumptions.
+
 ## [0.53.5] - 2026-04-19
 
 ### Technical

data/lib/ace/review/atoms/context_limit_resolver.rb

@@ -1,161 +1,34 @@
 # frozen_string_literal: true
 
+require "ace/llm"
+
 module Ace
   module Review
     module Atoms
-      # Pure function for resolving model context limits
-      #
-      # Maps model names to their context window sizes. Handles provider prefixes
-      # (google:, anthropic:, openai:) and uses pattern matching for model families.
-      #
-      # Resolution order:
-      # 1. ace-llm provider config (context_limit in providers/*.yml)
-      # 2. Hardcoded pattern matching (MODEL_LIMITS)
-      # 3. Conservative default for unknown models
-      #
-      # @example Basic usage
-      #   ContextLimitResolver.resolve("google:gemini-2.5-pro")
-      #   #=> 1_000_000
-      #
-      # @example Without provider prefix
-      #   ContextLimitResolver.resolve("claude-3-sonnet")
-      #   #=> 200_000
+      # Review-local wrapper around ace-llm's resolved model limit lookup.
       module ContextLimitResolver
-        # Conservative default for unknown models
-        DEFAULT_LIMIT = 200_000
-
-        # Model patterns and their context limits (fallback when ace-llm config unavailable)
-        # Order matters - first match wins
-        # Patterns use regex for flexible matching
-        MODEL_LIMITS = [
-          # Gemini models
-          {pattern: /gemini-1\.5-pro/i, limit: 2_000_000},
-          {pattern: /gemini-1\.5-flash/i, limit: 1_000_000},
-          {pattern: /gemini-2\.5-pro/i, limit: 1_000_000},
-          {pattern: /gemini-2\.5-flash/i, limit: 1_000_000},
-          {pattern: /gemini-2\.0/i, limit: 1_000_000},
-          # Fallback for any other gemini model
-          {pattern: /gemini/i, limit: 1_000_000},
-
-          # Claude models (all variants: opus, sonnet, haiku)
-          {pattern: /claude.*opus/i, limit: 1_000_000},
-          {pattern: /claude.*sonnet/i, limit: 1_000_000},
-          {pattern: /claude.*haiku/i, limit: 1_000_000},
-          # Fallback for any other claude model
-          {pattern: /claude/i, limit: 1_000_000},
+        DEFAULT_LIMIT = Ace::LLM::Molecules::ModelLimitResolver::DEFAULT_CONTEXT_LIMIT
 
-          # OpenAI models
-          {pattern: /gpt-5\.\d/i, limit: 1_050_000},
-          {pattern: /o4-/i, limit: 1_050_000},
-          {pattern: /gpt-4o/i, limit: 128_000},
-          {pattern: /gpt-4-turbo/i, limit: 128_000},
-          {pattern: /gpt-4-32k/i, limit: 32_768},
-          {pattern: /gpt-4-\d+-preview/i, limit: 128_000}, # gpt-4-1106-preview, gpt-4-0125-preview
-          {pattern: /gpt-4-\d+$/i, limit: 8_192}, # legacy gpt-4-0613, etc.
-          {pattern: /gpt-4$/i, limit: 8_192}, # base gpt-4 model
-          {pattern: /o1-/i, limit: 200_000},
-          {pattern: /o3-/i, limit: 200_000}
-        ].freeze
-
-        # Resolve context limit for a model
-        #
-        # Resolution order:
-        # 1. ace-llm provider config (if available and provider specified)
-        # 2. Hardcoded pattern matching
-        # 3. Default limit
-        #
-        # @param model_name [String, nil] Model identifier, optionally with provider prefix
-        # @return [Integer] Context limit in tokens
-        #
-        # @example With provider prefix
-        #   ContextLimitResolver.resolve("google:gemini-2.5-pro")
-        #   #=> 1_000_000
-        #
-        # @example Without provider prefix
-        #   ContextLimitResolver.resolve("claude-3-opus")
-        #   #=> 200_000
-        #
-        # @example Unknown model
-        #   ContextLimitResolver.resolve("unknown-model")
-        #   #=> 128_000
         def self.resolve(model_name)
-          return DEFAULT_LIMIT if model_name.nil? || model_name.empty?
-
-          # Try to get limit from ace-llm provider config first
-          limit = load_from_ace_llm(model_name)
-          return limit if limit
-
-          # Fall back to hardcoded pattern matching
-          normalized = strip_provider_prefix(model_name)
-          match = MODEL_LIMITS.find { |entry| normalized.match?(entry[:pattern]) }
-          match ? match[:limit] : DEFAULT_LIMIT
+          resolve_details(model_name).context_limit
         end
 
-        # Get the default limit for unknown models
-        #
-        # @return [Integer] Default context limit
-        def self.default_limit
-          DEFAULT_LIMIT
-        end
-
-        # Load context limit from ace-llm provider configuration
-        #
-        # @param model_name [String] Model identifier with provider prefix
-        # @return [Integer, nil] Context limit from config, or nil if not found
-        def self.load_from_ace_llm(model_name)
-          # Extract provider prefix (e.g., "google" from "google:gemini-2.5-pro")
-          return nil unless model_name.include?(":")
-
-          provider = model_name.split(":").first
-          return nil if provider.nil? || provider.empty?
-
-          # Try to load provider config via ace-llm
-          config = load_provider_config(provider)
-          return nil unless config
-
-          # Get context_limit from provider config
-          limit = config["context_limit"]
-          limit.is_a?(Integer) ? limit : nil
+        def self.resolve_details(model_name)
+          Ace::LLM::Molecules::ModelLimitResolver.resolve(model_name)
         rescue
-          nil # Fall back to hardcoded on any error
-        end
-        private_class_method :load_from_ace_llm
-
-        # Load provider configuration from ace-llm
-        #
-        # @param provider [String] Provider name (e.g., "google", "anthropic")
-        # @return [Hash, nil] Provider config hash or nil
-        def self.load_provider_config(provider)
-          # Try to use ace-llm's config loader if available
-          return nil unless defined?(Ace::LLM::Molecules::ConfigLoader)
-
-          resolver = Ace::Support::Config.create(
-            config_dir: ".ace",
-            defaults_dir: ".ace-defaults",
-            gem_path: Ace::LLM::Molecules::ConfigLoader.gem_root
+          Ace::LLM::Molecules::ModelLimitResolver::ResolveResult.new(
+            provider: nil,
+            model: nil,
+            context_limit: DEFAULT_LIMIT,
+            output_limit: nil,
+            source: :fallback,
+            original_target: model_name.to_s
           )
-
-          config = resolver.resolve_namespace("llm", filename: "providers/#{provider}")
-          config.to_h
-        rescue
-          nil
         end
-        private_class_method :load_provider_config
 
-        # Strip provider prefix from model name
-        #
-        # @param model_name [String] Model identifier
-        # @return [String] Model name without provider prefix
-        #
-        # @example
-        #   strip_provider_prefix("google:gemini-2.5-pro")
-        #   #=> "gemini-2.5-pro"
-        def self.strip_provider_prefix(model_name)
-          # Common provider prefixes
-          model_name.sub(/\A(google|anthropic|openai|codex|cli):/, "")
+        def self.default_limit
+          DEFAULT_LIMIT
         end
-
-        private_class_method :strip_provider_prefix
       end
     end
   end

data/lib/ace/review/molecules/llm_executor.rb

@@ -67,12 +67,19 @@ module Ace
           total_chars = (system_prompt&.length || 0) + (user_prompt&.length || 0)
           estimated_tokens = total_chars / 4  # Rough estimate: 4 chars per token
 
-          context_limit = Ace::Review::Atoms::ContextLimitResolver.resolve(model)
+          limit_details = Ace::Review::Atoms::ContextLimitResolver.resolve_details(model)
+          context_limit = limit_details.context_limit
           threshold = (context_limit * PROMPT_SIZE_WARNING_RATIO).to_i
           return unless estimated_tokens > threshold
 
+          display_model = if limit_details.full_model && limit_details.full_model != model
+            "#{model} -> #{limit_details.full_model}"
+          else
+            model
+          end
+
           warn "Warning: Prompt size (~#{estimated_tokens.to_s.gsub(/(\d)(?=(\d{3})+(?!\d))/, '\\1,')} tokens) " \
-               "may exceed #{model} context limit (#{context_limit.to_s.gsub(/(\d)(?=(\d{3})+(?!\d))/, '\\1,')} tokens)"
+               "may exceed #{display_model} context limit (#{context_limit.to_s.gsub(/(\d)(?=(\d{3})+(?!\d))/, '\\1,')} tokens)"
         end
 
         # Check if Ruby API is available

data/lib/ace/review/molecules/multi_model_executor.rb

@@ -14,8 +14,8 @@ module Ace
         # Default timeout for LLM queries (5 minutes)
         DEFAULT_LLM_TIMEOUT = 300
 
-        # Warning threshold: 80% of typical 1M context window
-        PROMPT_SIZE_WARNING_THRESHOLD = 800_000
+        # Warning threshold: 80% of the smallest resolved context window in the batch
+        PROMPT_SIZE_WARNING_RATIO = LlmExecutor::PROMPT_SIZE_WARNING_RATIO
 
         def initialize(max_concurrent: nil, llm_timeout: nil)
           # Read from config, fallback to default of 3, clamp to minimum 1
@@ -266,7 +266,14 @@ module Ace
           total_chars = (system_prompt&.length || 0) + (user_prompt&.length || 0)
           estimated_tokens = total_chars / 4  # Rough estimate: 4 chars per token
 
-          return unless estimated_tokens > PROMPT_SIZE_WARNING_THRESHOLD
+          resolved_limits = models.map do |model|
+            Atoms::ContextLimitResolver.resolve_details(model)
+          end
+          min_context_limit = resolved_limits.map(&:context_limit).compact.min
+          return if min_context_limit.nil?
+
+          threshold = (min_context_limit * PROMPT_SIZE_WARNING_RATIO).to_i
+          return unless estimated_tokens > threshold
 
           model_list = models.join(", ")
           warn "Warning: Prompt size (~#{estimated_tokens.to_s.gsub(/(\d)(?=(\d{3})+(?!\d))/, '\\1,')} tokens) " \

data/lib/ace/review/molecules/strategies/adaptive_strategy.rb

@@ -70,7 +70,7 @@ module Ace
             explicit_limit = context[:model_context_limit] || context["model_context_limit"]
 
             # Resolve model context limit
-            model_limit = explicit_limit || Atoms::ContextLimitResolver.resolve(model)
+            model_limit = explicit_limit || Atoms::ContextLimitResolver.resolve_details(model).context_limit
 
             # Select and delegate to appropriate strategy
             selected = select_strategy(subject, model_limit, model)

data/lib/ace/review/version.rb

@@ -2,6 +2,6 @@
 
 module Ace
   module Review
-    VERSION = '0.53.5'
+    VERSION = '0.53.6'
   end
 end

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification
 name: ace-review
 version: !ruby/object:Gem::Version
-  version: 0.53.5
+  version: 0.53.6
 platform: ruby
 authors:
 - Michal Czyz
 bindir: exe
 cert_chain: []
-date: 2026-04-20 00:00:00.000000000 Z
+date: 2026-04-27 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: ace-support-cli