aireview 0.2.1 → 0.3.0

data/lib/aireview/review_pipeline.rb

@@ -2,14 +2,17 @@
 require 'json'
 require_relative 'errors'
 require_relative 'context_builder'
+require_relative 'candidate_checker'
+require_relative 'result_validation'
 require_relative 'review_renderer'
 require_relative 'review_schemas'
 require_relative 'reviewer'
 
 module Aireview
   class ReviewPipeline
-    class SchemaError < StandardError
-    end
+    include ResultValidation
+
+    SchemaError = ResultValidation::SchemaError
 
     REPAIR_SYSTEM_PROMPT = <<~PROMPT.strip.freeze
       You fix invalid JSON produced by another LLM call.
@@ -47,19 +50,18 @@ module Aireview
       summary = generate_result['summary']
       candidates = Array(generate_result['candidates'])
       @logger.info("Pipeline generate pass completed with #{candidates.size} candidate(s)")
+      candidates = check_candidates(context: context, changes: changes, candidates: candidates)
 
-      accepted = if critique
-                   @logger.info("Pipeline critique pass started (model=#{@config.critique_model})")
-                   critique_candidates(context: context, candidates: candidates)
-                 else
-                   @logger.info('Pipeline critique pass skipped')
-                   candidates
-                 end
+      accepted = critique ? maybe_critique(context: context, candidates: candidates) : skip_critique(candidates)
 
       @logger.info("Pipeline finished with #{accepted.size} accepted finding(s)")
 
-      renderer = ReviewRenderer.new(language: @config.review_language)
-      renderer.render(accepted, summary: summary, coverage: context.coverage)
+      ReviewRenderer.new(language: @config.review_language).render(
+        accepted,
+        summary: summary,
+        coverage: context.coverage,
+        fallback_models: @reviewer.fallback_models
+      )
     end
 
     def dry_run_prompts(merge_request:, changes:, jira_issue: nil, critique: true)
@@ -83,6 +85,10 @@ module Aireview
         generate_temperature: @config.generate_temperature,
         critique_model: @config.critique_model,
         critique_temperature: @config.critique_temperature,
+        generate_fallbacks: @config.fallback_names(:generate),
+        critique_fallbacks: critique ? @config.fallback_names(:critique) : [],
+        api_keys: @config.api_key_counts(critique ? %i[generate critique] : [:generate]),
+        time_budget: @config.llm_time_budget,
         coverage: context.coverage,
         sizes: context.sizes
       }
@@ -90,6 +96,31 @@ module Aireview
 
     private
 
+    # Привязка к коду проверяется по диффу, который видела модель, до критика:
+    # ему уходят пометки, в отчёт — сброшенная строка и знак ненайденной цитаты.
+    def check_candidates(context:, changes:, candidates:)
+      CandidateChecker.new(
+        changes: changes,
+        diff_text: context.diff_text,
+        coverage: context.coverage,
+        logger: @logger
+      ).check(candidates)
+    end
+
+    def skip_critique(candidates, reason = nil)
+      @logger.info(['Pipeline critique pass skipped', reason].compact.join(': '))
+      candidates
+    end
+
+    # Критику нечего фильтровать без кандидатов: запрос к LLM был бы пустой
+    # тратой квоты и времени.
+    def maybe_critique(context:, candidates:)
+      return skip_critique(candidates, 'no candidates') if candidates.empty?
+
+      @logger.info("Pipeline critique pass started (model=#{@config.critique_model})")
+      critique_candidates(context: context, candidates: candidates)
+    end
+
     def critique_candidates(context:, candidates:)
       candidates_json = JSON.pretty_generate(candidates)
       candidates_by_id = index_candidates_by_id(candidates)
@@ -209,53 +240,6 @@ module Aireview
       parsed
     end
 
-    def validate_generate_result_shape!(parsed)
-      valid_shape = parsed.is_a?(Hash) && parsed['candidates'].is_a?(Array)
-      raise SchemaError, 'expected an object with summary and candidates array' unless valid_shape
-      raise SchemaError, 'each generate candidate must be an object' unless parsed['candidates'].all?(Hash)
-    end
-
-    def validate_critique_result_shape!(parsed)
-      valid_shape = parsed.is_a?(Hash) && parsed['verdicts'].is_a?(Array)
-      raise SchemaError, 'expected an object with verdicts array' unless valid_shape
-      raise SchemaError, 'each critique verdict must be an object' unless parsed['verdicts'].all?(Hash)
-    end
-
-    def validate_identifiers!(identifiers, missing_message:, duplicate_prefix:)
-      raise SchemaError, missing_message unless identifiers.all?
-
-      duplicate_ids = identifiers.group_by(&:itself).select { |_, ids| ids.size > 1 }.keys
-      return if duplicate_ids.empty?
-
-      raise SchemaError, "#{duplicate_prefix}: #{duplicate_ids.join(', ')}"
-    end
-
-    def validate_expected_verdict_ids!(verdict_ids, expected_ids)
-      return unless expected_ids
-
-      unknown_ids = verdict_ids - expected_ids
-      missing_ids = expected_ids - verdict_ids
-      raise SchemaError, "unknown verdict ids: #{unknown_ids.join(', ')}" unless unknown_ids.empty?
-      raise SchemaError, "missing verdict ids: #{missing_ids.join(', ')}" unless missing_ids.empty?
-    end
-
-    def validate_verdict!(verdict)
-      id = normalize_id(value(verdict, 'id'))
-      decision = normalize_decision(value(verdict, 'decision'))
-      raise SchemaError, "invalid verdict decision for #{id}" unless %w[keep reject].include?(decision)
-
-      refinement = value(verdict, 'refinement')
-      raise SchemaError, "reject verdict cannot include refinement for #{id}" if invalid_refinement?(verdict, decision)
-      return if refinement.nil?
-      return if refinement.is_a?(Hash)
-
-      raise SchemaError, "refinement must be an object for #{id}"
-    end
-
-    def invalid_refinement?(verdict, decision)
-      refinement_key?(verdict) && decision != 'keep'
-    end
-
     def repair_json(raw:, kind:, expected:, stage:, critique_candidate_ids: nil)
       schema = expected == :critique ? ReviewSchemas.critique : ReviewSchemas.generate
       user_prompt = <<~PROMPT
@@ -345,21 +329,14 @@ module Aireview
       hash[key] || hash[key.to_sym]
     end
 
-    def normalize_id(value)
-      presence(value)
-    end
-
     def normalize_decision(value)
       value.to_s.strip.downcase
     end
 
-    def refinement_key?(verdict)
-      verdict.key?('refinement') || verdict.key?(:refinement)
-    end
-
     def presence(value)
       string = value.to_s.strip
       string.empty? ? nil : string
     end
+    alias normalize_id presence
   end
 end

data/lib/aireview/review_renderer.rb

@@ -44,7 +44,9 @@ module Aireview
         sections_truncated: 'sections truncated',
         hunks_of: 'hunks shown',
         diff_unavailable: 'diff not available',
-        section_list: 'Truncated sections'
+        section_list: 'Truncated sections',
+        fallback_used: 'Fallback model used',
+        quote_missing: 'quote not found in the diff'
       },
       'ru' => {
         summary: 'Сводка',
@@ -68,7 +70,9 @@ module Aireview
         sections_truncated: 'секций усечено',
         hunks_of: 'хунков показано',
         diff_unavailable: 'дифф недоступен',
-        section_list: 'Усечённые секции'
+        section_list: 'Усечённые секции',
+        fallback_used: 'Использована резервная модель',
+        quote_missing: 'цитата не найдена в диффе'
       }
     }.freeze
 
@@ -80,10 +84,8 @@ module Aireview
     # result по-прежнему про найденные проблемы; неполнота покрытия
     # дописывается рядом с ним, чтобы строка результата не читалась как
     # «проверено всё».
-    def render(accepted, summary:, coverage: nil)
-      findings = sorted_findings(Array(accepted)).first(TOTAL_FINDINGS_LIMIT)
-      mismatches = findings.select { |finding| category(finding) == 'task_mismatch' }.first(MISMATCH_LIMIT)
-      important = findings.select { |finding| important_finding?(finding) }.first(IMPORTANT_LIMIT)
+    def render(accepted, summary:, coverage: nil, fallback_models: {})
+      mismatches, important = select_findings(Array(accepted))
       result = mismatches.empty? && important.empty? ? 'ok' : 'needs attention'
 
       <<~MARKDOWN.rstrip
@@ -102,13 +104,25 @@ module Aireview
         ## #{label(:result)}
 
         #{result}#{partial_note(coverage)}
-        #{coverage_block(coverage)}
+        #{coverage_block(coverage)}#{fallback_note(fallback_models)}
         #{label(:disclaimer)}
       MARKDOWN
     end
 
     private
 
+    # Сначала отбор того, что вообще показывается, потом лимиты разделов и
+    # только затем общий лимит: находка, которую не показать из-за категории
+    # или лимита раздела, не должна занимать общий слот.
+    def select_findings(accepted)
+      sorted = sorted_findings(accepted)
+      mismatches = sorted.select { |finding| category(finding) == 'task_mismatch' }.first(MISMATCH_LIMIT)
+      important = sorted.select { |finding| important_finding?(finding) }.first(IMPORTANT_LIMIT)
+      shown = sorted.select { |finding| mismatches.include?(finding) || important.include?(finding) }
+        .first(TOTAL_FINDINGS_LIMIT)
+      [mismatches & shown, important & shown]
+    end
+
     def sorted_findings(findings)
       findings
         .grep(Hash)
@@ -167,13 +181,22 @@ module Aireview
       "\n## #{label(:not_reviewed)}\n\n#{lines.join("\n")}\n"
     end
 
+    # Смена ключа остаётся в логах; смена модели видна читателю, потому что
+    # запасная модель может ревьюить слабее основной.
+    def fallback_note(fallback_models)
+      return '' if fallback_models.nil? || fallback_models.empty?
+
+      used = fallback_models.map { |stage, model| "#{stage} — #{model}" }.join(', ')
+      "\n#{label(:fallback_used)}: #{used}.\n"
+    end
+
     def location(finding)
       file = presence(value(finding, 'file'))
       line = value(finding, 'line')
       return label(:not_specified) unless file
-      return file if line.nil? || line.to_s.empty?
 
-      "#{file}:#{line}"
+      location = line.to_s.empty? ? file : "#{file}:#{line}"
+      value(finding, 'quote_missing') ? "#{location} (#{label(:quote_missing)})" : location
     end
 
     def label(key)

data/lib/aireview/reviewer.rb

@@ -2,22 +2,17 @@
 require_relative 'errors'
 require_relative 'output_schemas'
 require_relative 'utils'
+require_relative 'llm_router'
 require 'timeout'
 
 module Aireview
   class Reviewer
-    MAX_TRANSIENT_RETRIES = 3
-    TRANSIENT_RETRY_BASE_DELAY = 2.0
-    TRANSIENT_RETRY_JITTER_RANGE = 2.0..5.0
-    PROVIDER_RETRY_DELAY_MULTIPLIER_RANGE = 2.0..2.4
-    OVERLOADED_RETRY_DELAYS = [120.0, 300.0, 300.0, 300.0].freeze
-    OVERLOADED_RETRY_JITTER_RANGE = 0.85..1.15
-    RETRY_WAIT_LOG_FORMAT = 'LLM %<stage>s request will sleep %<delay>.1fs before retry%<source>s ' \
-                            '(attempt %<next_attempt>d/%<max_attempts>d, model=%<model>s)'
+    attr_reader :router
 
-    def initialize(config:, logger: Logger.new($stderr))
+    def initialize(config:, logger: Logger.new($stderr), router: nil)
       @config = config
       @logger = logger
+      @router = router || LlmRouter.new(config: config, logger: logger)
       @llm_contexts = {}
     end
 
@@ -26,12 +21,7 @@ module Aireview
         stage: 'generate',
         system: system_prompt,
         user: user_prompt,
-        options: {
-          model: @config.generate_model,
-          temperature: @config.generate_temperature,
-          provider: @config.generate_provider,
-          schema: GenerateOutputSchema
-        }
+        options: {temperature: @config.generate_temperature, schema: GenerateOutputSchema}
       )
     end
 
@@ -40,41 +30,34 @@ module Aireview
         stage: 'critique',
         system: system_prompt,
         user: user_prompt,
-        options: {
-          model: @config.critique_model,
-          temperature: @config.critique_temperature,
-          provider: @config.critique_provider,
-          schema: CritiqueOutputSchema
-        }
+        options: {temperature: @config.critique_temperature, schema: CritiqueOutputSchema}
       )
     end
 
+    # Стадии, ответившие запасной моделью, для строки в отчёте.
+    def fallback_models
+      @router.fallback_models
+    end
+
     private
 
     def call_llm(stage:, system:, user:, options:)
       require 'ruby_llm'
 
       @config.require_llm_configuration!
-      context = llm_context(stage, options[:provider])
-      response = request_with_retries(stage: stage, model: options[:model]) do
+      response = @router.call(stage: stage, request_chars: system.length + user.length) do |route, timeout|
         perform_llm_request(
-          context: context,
+          context: llm_context(stage, route),
           stage: stage,
           system: system,
           user: user,
-          options: options
+          options: options.merge(model: route.candidate.model, provider: route.candidate.provider, timeout: timeout)
         )
       end
       response.content
     rescue LoadError => e
       @logger.error("LLM #{stage} setup failed: #{e.message}")
       raise ConfigError, "Missing dependency: #{e.message}"
-    rescue Timeout::Error
-      @logger.warn(
-        "LLM #{stage} request timed out after #{@config.llm_timeout} seconds (model=#{options[:model]})"
-      )
-      raise ApiError, "LLM request timed out after #{@config.llm_timeout} seconds. " \
-                      "Try again later or switch model via --generate-model/--critique-model."
     end
 
     def perform_llm_request(context:, stage:, system:, user:, options:)
@@ -86,9 +69,12 @@ module Aireview
         .with_temperature(temperature.to_f)
         .with_schema(options[:schema])
       chat.with_instructions(system)
-      response = Timeout.timeout(@config.llm_timeout.to_f) { chat.ask(user) }
+      response = Timeout.timeout(options[:timeout]) { chat.ask(user) }
       @logger.info("LLM #{stage} request completed (model=#{model})")
       response
+    rescue Timeout::Error
+      @logger.warn("LLM #{stage} request timed out after #{options[:timeout].round} seconds (model=#{model})")
+      raise
     end
 
     def configure_reasoning(chat:, model:, provider:)
@@ -108,160 +94,21 @@ module Aireview
       context.chat(model: model, provider: provider.to_sym, assume_model_exists: true)
     end
 
-    def request_with_retries(stage:, model:)
-      attempt = 0
-
-      begin
-        attempt += 1
-        yield
-      rescue StandardError => e
-        raise unless ruby_llm_api_error?(e)
-
-        @logger.warn("LLM #{stage} request failed (model=#{model}): #{e.class}: #{e.message}")
-        raise ApiError, llm_error_message(e) unless retry_llm_request?(e, attempt)
-
-        wait_before_retry(error: e, attempt: attempt, stage: stage, model: model)
-        retry
-      end
-    end
-
-    def retry_llm_request?(error, attempt)
-      transient_llm_error?(error) && attempt <= max_retries(error)
-    end
-
-    # Перегруженному провайдеру даётся на один повтор больше: 503 у Gemini
-    # держится дольше, чем rate limit или сетевой сбой.
-    def max_retries(error)
-      overloaded_llm_error?(error) ? OVERLOADED_RETRY_DELAYS.size : MAX_TRANSIENT_RETRIES
-    end
-
-    def wait_before_retry(error:, attempt:, stage:, model:)
-      retry_delay = transient_retry_delay(error: error, attempt: attempt)
-      @logger.warn(
-        format(
-          RETRY_WAIT_LOG_FORMAT,
-          stage: stage,
-          delay: retry_delay[:delay],
-          source: retry_delay_source(retry_delay),
-          next_attempt: attempt + 1,
-          max_attempts: max_retries(error) + 1,
-          model: model
-        )
-      )
-      sleep_started_at = monotonic_time
-      sleep(retry_delay[:delay])
-      log_retry_wait_completed(stage, model, monotonic_time - sleep_started_at)
-    end
-
-    def log_retry_wait_completed(stage, model, waited)
-      @logger.info(
-        format(
-          'LLM %<stage>s retry wait completed after %<waited>.1fs (model=%<model>s)',
-          stage: stage,
-          waited: waited,
-          model: model
-        )
-      )
-    end
-
-    def ruby_llm_api_error?(error)
-      defined?(RubyLLM::Error) && error.is_a?(RubyLLM::Error)
+    # Контекст RubyLLM на стадию, провайдера и номер ключа: смена ключа —
+    # это другой контекст, а не правка глобального конфига.
+    def llm_context(stage, route)
+      cache_key = [stage, route.candidate.provider, route.key_index]
+      @llm_contexts[cache_key] ||= build_llm_context(route.candidate.provider.to_s, route.key)
     end
 
-    def transient_llm_error?(error)
-      error.is_a?(RubyLLM::RateLimitError) ||
-        error.is_a?(RubyLLM::ServiceUnavailableError) ||
-        error.is_a?(RubyLLM::OverloadedError)
-    end
-
-    def monotonic_time
-      Process.clock_gettime(Process::CLOCK_MONOTONIC)
-    end
-
-    def transient_retry_delay(error:, attempt:)
-      provider_delay = retry_after_seconds(error.message)
-      if provider_delay
-        multiplier = rand(PROVIDER_RETRY_DELAY_MULTIPLIER_RANGE)
-        return {
-          delay: provider_delay * multiplier,
-          provider_delay: provider_delay,
-          multiplier: multiplier,
-          strategy: :provider_hint
-        }
-      end
-
-      if overloaded_llm_error?(error)
-        base_delay = OVERLOADED_RETRY_DELAYS.fetch(attempt - 1, OVERLOADED_RETRY_DELAYS.last)
-        multiplier = rand(OVERLOADED_RETRY_JITTER_RANGE)
-        return {
-          delay: base_delay * multiplier,
-          base_delay: base_delay,
-          multiplier: multiplier,
-          strategy: :overloaded
-        }
-      end
-
-      base_delay = TRANSIENT_RETRY_BASE_DELAY * (2**(attempt - 1))
-      {
-        delay: base_delay + rand(TRANSIENT_RETRY_JITTER_RANGE),
-        provider_delay: nil,
-        multiplier: nil,
-        strategy: :fallback
-      }
-    end
-
-    def retry_delay_source(retry_delay)
-      if retry_delay[:strategy] == :overloaded
-        return format(
-          ' (overloaded backoff %<base_delay>.0fs, multiplier %<multiplier>.2fx)',
-          base_delay: retry_delay[:base_delay],
-          multiplier: retry_delay[:multiplier]
-        )
-      end
-      return '' unless retry_delay[:provider_delay]
-
-      format(
-        ' (provider retry hint %<provider_delay>.1fs, multiplier %<multiplier>.2fx)',
-        provider_delay: retry_delay[:provider_delay],
-        multiplier: retry_delay[:multiplier]
-      )
-    end
-
-    def overloaded_llm_error?(error)
-      error.is_a?(RubyLLM::ServiceUnavailableError) ||
-        error.is_a?(RubyLLM::OverloadedError)
-    end
-
-    def retry_after_seconds(message)
-      match = message.to_s.match(/retry\s+(?:in|after)\s+(\d+(?:\.\d+)?)\s*(?:s|sec|secs|second|seconds)\b/i)
-      match[1].to_f if match
-    end
-
-    def llm_error_message(error)
-      case error
-      when RubyLLM::ServiceUnavailableError, RubyLLM::OverloadedError
-        "LLM service is temporarily unavailable or overloaded: #{error.message}. " \
-        "Try again later or switch model via --generate-model/--critique-model."
-      when RubyLLM::RateLimitError
-        "LLM rate limit exceeded: #{error.message}. " \
-        "Try again later or switch model via --generate-model/--critique-model."
-      when RubyLLM::ContextLengthExceededError
-        "LLM context limit exceeded: #{error.message}. Try reducing the MR diff or ignore more paths."
-      else
-        "LLM API request failed: #{error.message}"
-      end
-    end
-
-    def llm_context(stage, provider)
-      @llm_contexts[stage] ||= build_llm_context(provider.to_s)
-    end
-
-    def build_llm_context(provider)
-      api_key = @config.provider_api_key(provider) unless provider == 'ollama'
-
+    # Повторами занимается роутер: встроенные ретраи RubyLLM/Faraday (по
+    # умолчанию 3) превратили бы каждую нашу попытку в четыре HTTP-запроса и
+    # жгли бы квоту до того, как ошибка дойдёт до классификатора.
+    def build_llm_context(provider, api_key)
       RubyLLM.context do |ruby_config|
         configure_http_proxy(ruby_config)
         ruby_config.request_timeout = @config.llm_timeout.to_f
+        ruby_config.max_retries = 0
         configure_provider(ruby_config, provider, api_key)
       end
     end

data/lib/aireview/version.rb

@@ -1,4 +1,4 @@
 # frozen_string_literal: true
 module Aireview
-  VERSION = '0.2.1'
+  VERSION = '0.3.0'
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: aireview
 version: !ruby/object:Gem::Version
-  version: 0.2.1
+  version: 0.3.0
 platform: ruby
 authors:
 - Denis Levenko
@@ -69,8 +69,10 @@ files:
 - bin/aireview
 - config/.aireview.yml.example
 - lib/aireview.rb
+- lib/aireview/candidate_checker.rb
 - lib/aireview/cli.rb
 - lib/aireview/config.rb
+- lib/aireview/config_fallbacks.rb
 - lib/aireview/config_limits.rb
 - lib/aireview/context_budget.rb
 - lib/aireview/context_builder.rb
@@ -79,11 +81,14 @@ files:
 - lib/aireview/errors.rb
 - lib/aireview/gitlab_client.rb
 - lib/aireview/jira_client.rb
+- lib/aireview/llm_failure.rb
+- lib/aireview/llm_router.rb
 - lib/aireview/mr_parser.rb
 - lib/aireview/output_schemas.rb
 - lib/aireview/prompts/critique.txt
 - lib/aireview/prompts/generate.txt
 - lib/aireview/publisher.rb
+- lib/aireview/result_validation.rb
 - lib/aireview/review_marker.rb
 - lib/aireview/review_pipeline.rb
 - lib/aireview/review_renderer.rb