aireview 0.1.1 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 100adbc2d1510ad1f6c0e9b152decbfa46e71f8db30dfde36a8ba977528ae215
-  data.tar.gz: 071d392ef71d935a6b6a055e7e86fbbf06e8f4517251d460d8bbff8087cb8ecf
+  metadata.gz: b27b5c59888ddb35675082d95d7e5e79dc1935295ecde9a1e13cdcaf38f24dff
+  data.tar.gz: 6016c5aae6d57475465c707cc2d89dedf07964d402cc1f5a68a6e01dc5f553d1
 SHA512:
-  metadata.gz: 48d8222728f5bd0cdb27790c9971c316060c9efd89479e6be58ee6f41066e237e4e94cf2f864297b03a3012e1f225b92c4ece4b84ffeca3ad3ef66831a176e09
-  data.tar.gz: e4cdac4c17edc362e318b548ac5d25198eaf9c916edd670424c7d21b0cdf4baab2f9f61527bb05547e737e30f192d243ee7dfcb80062a483b08bf410466bfcef
+  metadata.gz: bc47e9e8d2c7cece68a02a92594c896f52c5b101c8a639cee9f3c702e010906e5280dbda4282465630162c90b2532debcdca05462c8a1b390987288b150850dc
+  data.tar.gz: 644ad90865170c254b3b844e606f9c0121a2b82a50d7af62ffd70f4bf838bd0a258db367e3a815d899fb8bb628f183d268eee11722d2364bf700734ba463b7a3

data/CHANGELOG.md

@@ -1,5 +1,24 @@
 # Changelog
 
+## 0.2.0
+
+- Context budget: `llm.max_prompt_chars` caps the request of each stage,
+  `context.max_*_chars` cap the MR description, the Jira description and
+  comments and the diff. The diff is cut by whole files and hunks, never in
+  the middle of a hunk, and both stages share the same context.
+- Truncation is marked in the prompt and reported in the review: the result
+  line gets a `Partial review` suffix and a `Not reviewed` section lists the
+  files and sections that were left out. `--dry-run` and `--verbose` show the
+  sizes and the coverage.
+- Renames, mode changes and empty new or deleted files are told apart from
+  diffs GitLab did not return (too large, binary, empty without a reason); the
+  latter are reported as not reviewed.
+- Unparsable limits in the environment (`MAX_DIFF_CHARS=oops`) fail with a
+  `ConfigError` instead of silently falling back to the defaults.
+- A run fails with a clear error when not even one hunk fits next to the
+  system prompt, or when the candidates push the Critique request over its
+  limit.
+
 ## 0.1.1
 
 - The prompts no longer ask the model to check whether dependency and image

data/CONTRIBUTORS.md

@@ -0,0 +1,8 @@
+# Contributors
+
+- [Denis Levenko](https://github.com/DenisDenis9331), author and maintainer.
+- [Sergey Kondrashov](https://github.com/SergoHUH): Ollama support, Jira
+  self-hosted configuration, provider cleanup, prompt refactoring.
+
+Contributions are welcome: open an issue or a pull request at
+https://github.com/DenisDenis9331/aireview.

data/README.md

@@ -204,11 +204,18 @@ review_instructions: |
 
 ollama_api_base: http://localhost:11434/v1
 
+context:
+  max_diff_chars: 120000
+  max_mr_description_chars: 8000
+  max_jira_description_chars: 8000
+  max_jira_comment_chars: 2000
+
 llm:
   provider: gemini
   temperature: 0
   timeout: 60
   http_proxy: http://127.0.0.1:8888
+  max_prompt_chars: 400000
   generate:
     provider: gemini
     model: gemini-3.7-flash
@@ -217,8 +224,46 @@ llm:
     provider: ollama
     model: qwen2.5-coder:7b
     temperature: 0
+    max_prompt_chars: 60000
 ```
 
+### Context budget
+
+The request to each stage is capped by `llm.max_prompt_chars` (or
+`LLM_MAX_PROMPT_CHARS`; per stage `llm.generate.max_prompt_chars` /
+`LLM_GENERATE_MAX_PROMPT_CHARS` and the same for `critique`). The limits are in
+characters, not tokens: there is no exact tokenizer for the providers locally,
+and the Ollama window is set on the server where the client cannot see it. As
+a rule of thumb one token is three to four characters, so for a local model
+with `OLLAMA_CONTEXT_LENGTH=8192` set the stage limit to about 20 000
+characters to leave room for the answer.
+
+The MR and Jira context is assembled once per run and shared by both stages,
+so it is sized for the tighter of the two: the Critique stage also has to fit
+its system prompt and a reserve for the candidates. The sections are cut to
+their own limits first, keeping the beginning: `context.max_diff_chars`,
+`context.max_mr_description_chars`, `context.max_jira_description_chars` and
+`context.max_jira_comment_chars` (`MAX_DIFF_CHARS`, `MAX_MR_DESCRIPTION_CHARS`,
+`MAX_JIRA_DESCRIPTION_CHARS`, `MAX_JIRA_COMMENT_CHARS`). Only then is the diff
+cut, and only by whole files and whole hunks: files in the order GitLab returns
+them, a file that does not fit is shown hunk by hunk, everything after it is
+left out, and a single hunk larger than the whole budget is skipped rather
+than cut in the middle. Renames, mode changes and other files without text
+changes are always listed; files whose diff GitLab did not return (too large,
+binary) are listed as well and reported as not reviewed.
+
+Everything that was cut is marked in the prompt, so the model knows that a
+missing requirement or missing code may simply be outside the budget. The
+review reports it too: the result line gets a `Partial review: ...` suffix
+and a `Not reviewed` section lists the files and sections concerned. The
+result itself (`ok` / `needs attention`) is still only about the findings.
+
+When even one hunk cannot fit next to the system prompt, or the candidates
+returned by Generate push the Critique request over its limit, the run stops
+with an error instead of silently reviewing less. Raise the limits or extend
+`ignore_paths`. `--dry-run` prints the sizes of every part and the coverage;
+`--verbose` logs them during a real run.
+
 ## Usage
 
 ```bash
@@ -237,7 +282,7 @@ bundle _2.3.26_ exec bin/aireview review https://gitlab.company.com/team/project
 - `--critique-temperature VALUE` overrides the temperature for the Critique pass only.
 - `--config PATH` points at a specific `.aireview.yml`.
 - `--no-jira` turns off the Jira enrichment even when the MR carries an issue key.
-- `--dry-run` prints the LLM settings and the Generate prompt, plus the Critique prompt unless `--no-critique` is given.
+- `--dry-run` prints the LLM settings, the context sizes and coverage, and the Generate prompt, plus the Critique prompt unless `--no-critique` is given.
 - `--no-critique` skips the second pass and renders the Generate candidates directly.
 - `--review-mode MODE` sets the behaviour when a review has already been published: `update` or `once`.
 - `--force` reviews again even when a review for this state of the MR is already published.
@@ -362,6 +407,7 @@ bundle _2.3.26_ exec rspec spec/secret_scrubber_spec.rb
 
 - The reviewer does not check whether the specified versions of dependencies and images exist: the model's knowledge of releases is outdated, and that is what CI is for. Syntax errors and contradictions with the MR/Jira requirements are checked as usual.
 - The CLI looks for `.aireview.yml` and `.env` walking up from the current working directory, so the project config can be kept in the repository root even when the tool is run from `aireview/`.
+- How Ollama behaves when a request is still larger than its context window is up to the server, not to `aireview`: check the `ollama serve` log for truncation messages on your setup and size `max_prompt_chars` so it does not happen.
 
 ## Releasing
 
@@ -379,12 +425,18 @@ API key is stored anywhere. To cut a release:
    ```
 
 The workflow refuses to run when the tag does not match `Aireview::VERSION`,
-runs the test suite, builds the gem and pushes it.
+runs the test suite, builds the gem, pushes it and then creates a GitHub
+release for the tag with the matching `CHANGELOG.md` section as its notes and
+the built `.gem` attached.
 
 ## Changelog
 
 See [CHANGELOG.md](CHANGELOG.md).
 
+## Contributors
+
+See [CONTRIBUTORS.md](CONTRIBUTORS.md).
+
 ## License
 
 [MIT](LICENSE)

data/lib/aireview/cli.rb

@@ -82,7 +82,7 @@ module Aireview
         parser_result: parser_result,
         gitlab_client: gitlab_client,
         merge_request: merge_request,
-        changes_text: render_changes(changes, config),
+        changes: prepare_changes(changes, config),
         jira_issue: maybe_load_jira_issue(config, merge_request, options)
       }
     end
@@ -102,18 +102,18 @@ module Aireview
       [merge_request, changes]
     end
 
-    def render_changes(changes, config)
+    # Дифф уходит дальше по файлам, а не одной строкой: бюджет контекста
+    # режет его по границам файлов и хунков.
+    def prepare_changes(changes, config)
       diff_fetcher = DiffFetcher.new(ignore_paths: config.ignore_paths, logger: @logger)
       filtered_changes = diff_fetcher.filter(changes)
       raise Error, 'No changes left after filtering ignore_paths' if filtered_changes.empty?
 
-      scrubbed_changes = SecretScrubber.new(
+      SecretScrubber.new(
         secret_patterns: config.secret_patterns,
         secret_files: config.secret_files,
         logger: @logger
       ).scrub_changes(filtered_changes)
-
-      diff_fetcher.render(scrubbed_changes)
     end
 
     def execute_review(config, context, options)
@@ -122,7 +122,7 @@ module Aireview
       if options[:dry_run]
         dry_run = pipeline.dry_run_prompts(
           merge_request: context[:merge_request],
-          changes_text: context[:changes_text],
+          changes: context[:changes],
           jira_issue: context[:jira_issue],
           critique: !options[:no_critique]
         )
@@ -135,7 +135,7 @@ module Aireview
 
       review = pipeline.run(
         merge_request: context[:merge_request],
-        changes_text: context[:changes_text],
+        changes: context[:changes],
         jira_issue: context[:jira_issue],
         critique: !options[:no_critique]
       )
@@ -157,7 +157,7 @@ module Aireview
       publisher = Publisher.new(gitlab_client: context[:gitlab_client], logger: @logger)
       prompts = pipeline.dry_run_prompts(
         merge_request: context[:merge_request],
-        changes_text: context[:changes_text],
+        changes: context[:changes],
         jira_issue: context[:jira_issue],
         critique: !options[:no_critique]
       )
@@ -321,27 +321,7 @@ module Aireview
     end
 
     def render_dry_run(dry_run)
-      @out.puts('=== LLM SETTINGS ===')
-      @out.puts("Generate: #{dry_run[:generate_model]} temperature=#{dry_run[:generate_temperature]}")
-      if dry_run[:critique_prompt]
-        @out.puts("Critique: #{dry_run[:critique_model]} temperature=#{dry_run[:critique_temperature]}")
-      else
-        @out.puts('Critique: disabled')
-      end
-      @out.puts
-      @out.puts('=== GENERATE SYSTEM PROMPT ===')
-      @out.puts(dry_run.dig(:generate_prompt, :system_prompt))
-      @out.puts
-      @out.puts('=== GENERATE USER PROMPT ===')
-      @out.puts(dry_run.dig(:generate_prompt, :user_prompt))
-      return unless dry_run[:critique_prompt]
-
-      @out.puts
-      @out.puts('=== CRITIQUE SYSTEM PROMPT ===')
-      @out.puts(dry_run.dig(:critique_prompt, :system_prompt))
-      @out.puts
-      @out.puts('=== CRITIQUE USER PROMPT ===')
-      @out.puts(dry_run.dig(:critique_prompt, :user_prompt))
+      DryRunReport.new(@out).render(dry_run)
     end
 
     def help

data/lib/aireview/config.rb

@@ -4,9 +4,13 @@ require 'pathname'
 require 'yaml'
 require_relative 'errors'
 require_relative 'utils'
+require_relative 'config_limits'
 
 module Aireview
   class Config
+    include ConfigLimits
+    extend ConfigLimits::ClassMethods
+
     DEFAULT_SECRET_FILES = [
       '.env',
       '.env.*',
@@ -21,7 +25,6 @@ module Aireview
     ].freeze
 
     REVIEW_MODES = %w[update once].freeze
-
     DEFAULTS = {
       'review_language' => 'en',
       'review_mode' => 'update',
@@ -35,8 +38,10 @@ module Aireview
       'llm' => {
         'provider' => 'gemini',
         'temperature' => 0,
-        'timeout' => 60
-      }
+        'timeout' => 60,
+        'max_prompt_chars' => ConfigLimits::DEFAULT_MAX_PROMPT_CHARS
+      },
+      'context' => ConfigLimits::CONTEXT_DEFAULTS
     }.freeze
 
     ENV_MAPPING = {
@@ -97,6 +102,7 @@ module Aireview
     def self.env_config(env)
       mapped_env_config(env)
         .merge('llm' => llm_env_config(env))
+        .merge(context_env_config(env))
         .merge(provider_key_env_config(env))
         .merge(generic_api_key_env_config(env))
     end
@@ -113,6 +119,7 @@ module Aireview
         'provider' => env['LLM_PROVIDER'],
         'temperature' => parse_float(env['LLM_TEMPERATURE']),
         'timeout' => parse_float(env['LLM_TIMEOUT']),
+        'max_prompt_chars' => parse_integer(env['LLM_MAX_PROMPT_CHARS'], 'LLM_MAX_PROMPT_CHARS'),
         'generate' => llm_stage_env_config(env, 'GENERATE'),
         'critique' => llm_stage_env_config(env, 'CRITIQUE')
       }.compact.reject { |key, value| %w[generate critique].include?(key) && value.empty? }
@@ -122,7 +129,8 @@ module Aireview
       {
         'provider' => env["LLM_#{stage}_PROVIDER"],
         'model' => env["LLM_#{stage}_MODEL"],
-        'temperature' => parse_float(env["LLM_#{stage}_TEMPERATURE"])
+        'temperature' => parse_float(env["LLM_#{stage}_TEMPERATURE"]),
+        'max_prompt_chars' => parse_integer(env["LLM_#{stage}_MAX_PROMPT_CHARS"], "LLM_#{stage}_MAX_PROMPT_CHARS")
       }.compact
     end
 

data/lib/aireview/config_limits.rb

@@ -0,0 +1,85 @@
+# frozen_string_literal: true
+
+module Aireview
+  # Лимиты контекста в символах: точного токенизатора для провайдеров локально
+  # нет, а окно Ollama задаётся на сервере и клиенту не видно. Дефолты щедрые,
+  # под конкретную модель их задают в .aireview.yml.
+  module ConfigLimits
+    LLM_STAGES = %w[generate critique].freeze
+    DEFAULT_MAX_PROMPT_CHARS = 400_000
+    CONTEXT_DEFAULTS = {
+      'max_diff_chars' => 120_000,
+      'max_mr_description_chars' => 8_000,
+      'max_jira_description_chars' => 8_000,
+      'max_jira_comment_chars' => 2_000
+    }.freeze
+    CONTEXT_ENV = {
+      'max_diff_chars' => 'MAX_DIFF_CHARS',
+      'max_mr_description_chars' => 'MAX_MR_DESCRIPTION_CHARS',
+      'max_jira_description_chars' => 'MAX_JIRA_DESCRIPTION_CHARS',
+      'max_jira_comment_chars' => 'MAX_JIRA_COMMENT_CHARS'
+    }.freeze
+
+    module ClassMethods
+      def context_env_config(env)
+        context = CONTEXT_ENV.each_with_object({}) do |(key, env_key), config|
+          value = parse_integer(env[env_key], env_key)
+          config[key] = value unless value.nil?
+        end
+        context.empty? ? {} : {'context' => context}
+      end
+
+      # Лимит, который не разобрался, нельзя молча заменять дефолтом: запрос
+      # уйдёт в модель с окном, которого у неё нет.
+      def parse_integer(value, name)
+        return nil if Aireview::Utils.blank?(value)
+
+        Integer(value.to_s, 10)
+      rescue ArgumentError
+        raise ConfigError, "#{name} must be an integer, got #{value.inspect}"
+      end
+    end
+
+    # Лимит всего запроса стадии в символах: системный промпт плюс контекст
+    # (для критика ещё и кандидаты). Наследуется из llm как model/temperature.
+    def max_prompt_chars(stage)
+      stage = stage.to_s
+      raise ArgumentError, "unknown LLM stage #{stage.inspect}" unless LLM_STAGES.include?(stage)
+
+      positive_integer!(
+        dig('llm', stage, 'max_prompt_chars') || dig('llm', 'max_prompt_chars') || DEFAULT_MAX_PROMPT_CHARS,
+        "llm.#{stage}.max_prompt_chars"
+      )
+    end
+
+    def max_diff_chars
+      context_limit('max_diff_chars')
+    end
+
+    def max_mr_description_chars
+      context_limit('max_mr_description_chars')
+    end
+
+    def max_jira_description_chars
+      context_limit('max_jira_description_chars')
+    end
+
+    def max_jira_comment_chars
+      context_limit('max_jira_comment_chars')
+    end
+
+    private
+
+    def context_limit(key)
+      positive_integer!(dig('context', key) || CONTEXT_DEFAULTS.fetch(key), "context.#{key}")
+    end
+
+    def positive_integer!(value, name)
+      integer = Integer(value, exception: false) if value.is_a?(Integer) || value.is_a?(String)
+      integer = value.to_i if value.is_a?(Float) && value == value.floor
+      return integer if integer.is_a?(Integer) && integer.positive?
+
+      raise ConfigError, "#{name} must be a positive integer, got #{value.inspect}"
+    end
+  end
+end

data/lib/aireview/context_budget.rb

@@ -0,0 +1,197 @@
+# frozen_string_literal: true
+require_relative 'errors'
+
+module Aireview
+  # Укладывает контекст ревью в бюджет символов и запоминает, что при этом не
+  # вошло. Секции MR и Jira режутся до своих лимитов с сохранением начала,
+  # дифф по целым файлам, затем по целым хункам; внутри хунка не режем.
+  module ContextBudget
+    # Пути, которые не вошли, перечисляются в конце диффа; список ограничен,
+    # чтобы сам не съел бюджет.
+    NOT_SHOWN_LIST_LIMIT = 20
+    TRAILER_RESERVE_CHARS = 400
+
+    Coverage = Struct.new(
+      :truncated_sections, :files_not_shown, :files_partial, :files_unavailable, :hunks_skipped,
+      keyword_init: true
+    ) do
+      def self.empty
+        new(truncated_sections: [], files_not_shown: [], files_partial: [], files_unavailable: [], hunks_skipped: [])
+      end
+
+      def complete?
+        to_h.values.all?(&:empty?)
+      end
+    end
+
+    Packed = Struct.new(:text, :shown_hunks, :total_hunks, keyword_init: true)
+
+    # Начало важнее конца: требования и критерии приёмки обычно там.
+    def self.truncate_section(text, limit:, label:, coverage:)
+      text = text.to_s
+      return text if text.length <= limit
+
+      coverage.truncated_sections << label
+      "#{text[0, limit]}\n[#{label} truncated: #{limit} of #{text.length} chars shown]"
+    end
+
+    def self.pack_entries(entries, budget:, coverage:)
+      Packer.new(entries, budget: budget, coverage: coverage).pack
+    end
+
+    # Файлы без хунков идут первыми: они дёшевы и всегда полезны для картины
+    # MR. Текстовые файлы идут в порядке GitLab, пока влезают; первый файл,
+    # который не влезает, показывается частично, всё после него не показывается.
+    # Хунк, который не влез бы даже в пустой бюджет, пропускается с пометкой,
+    # а не останавливает раскладку.
+    class Packer
+      def initialize(entries, budget:, coverage:)
+        @non_text, @text = entries.partition { |entry| !entry.text? }
+        @budget = budget
+        @coverage = coverage
+        @total_hunks = @text.sum { |entry| entry.hunks.size }
+      end
+
+      def pack
+        @non_text.each { |entry| @coverage.files_unavailable << entry.path if entry.unavailable? }
+        full = (@non_text + @text).map(&:render).join("\n")
+        return Packed.new(text: full, shown_hunks: @total_hunks, total_hunks: @total_hunks) if full.length <= @budget
+
+        pack_within_limit
+      end
+
+      private
+
+      # Что-то придётся опустить, значит нужен хвост со списком пропущенного.
+      # @used считает весь собранный текст, включая разделители между
+      # файлами: результат не должен выйти за бюджет ни на символ.
+      def pack_within_limit
+        @parts = @non_text.map(&:render)
+        @used = joined_length(@parts)
+        @limit = @budget - TRAILER_RESERVE_CHARS
+        raise_no_room!(:non_text) if @used > @limit
+
+        shown_hunks = pack_text_entries
+        raise_no_room!(:hunks) if shown_hunks.zero? && @total_hunks.positive?
+
+        @parts << not_shown_trailer unless @coverage.files_not_shown.empty?
+        Packed.new(text: @parts.join("\n"), shown_hunks: shown_hunks, total_hunks: @total_hunks)
+      end
+
+      def pack_text_entries
+        shown_hunks = 0
+        stopped = false
+        @text.each do |entry|
+          piece, shown, stopped = stopped ? ['', 0, true] : pack_entry(entry)
+          if shown.zero?
+            @coverage.files_not_shown << entry.path
+            next
+          end
+
+          @parts << piece
+          @used = joined_length(@parts)
+          shown_hunks += shown
+        end
+        shown_hunks
+      end
+
+      # Место под следующий кусок с учётом разделителя перед ним.
+      def remaining
+        @limit - @used - (@parts.empty? ? 0 : 1)
+      end
+
+      # Возвращает [текст, число показанных хунков, остановлена ли раскладка].
+      def pack_entry(entry)
+        full = entry.render
+        return [full, entry.hunks.size, false] if full.length <= remaining
+
+        body, shown, skipped, stopped = pack_hunks(entry)
+        return ['', 0, stopped] if shown.zero?
+
+        skipped.each { |hunk| @coverage.hunks_skipped << {path: entry.path, hunk: hunk} }
+        @coverage.files_partial << {path: entry.path, shown: shown, total: entry.hunks.size}
+        [entry.header + body + partial_marker(entry, shown), shown, stopped]
+      end
+
+      # Место сначала отдаётся хункам, которые можно показать, и только на
+      # остаток добавляются пометки о слишком больших: иначе пометки могли бы
+      # вытеснить единственный подходящий хунк. Факт пропуска в покрытие
+      # попадает независимо от того, есть ли для пометки место.
+      def pack_hunks(entry)
+        base = entry.header.length + partial_marker(entry, 0).length
+        shown = []
+        skipped = []
+        stopped = false
+        used = 0
+        entry.hunks.each_with_index do |hunk, index|
+          if base + hunk.length > @limit
+            skipped << index
+            next
+          end
+          if base + used + hunk.length > remaining
+            stopped = true
+            break
+          end
+
+          shown << index
+          used += hunk.length
+        end
+
+        body = render_hunks(entry, shown: shown, skipped: skipped, room: remaining - base - used)
+        [body, shown.size, skipped.map { |index| index + 1 }, stopped]
+      end
+
+      def render_hunks(entry, shown:, skipped:, room:)
+        marked = skipped.select do |index|
+          marker = skip_marker(entry, index)
+          next false if marker.length > room
+
+          room -= marker.length
+          true
+        end
+        entry.hunks.each_with_index.filter_map do |hunk, index|
+          next hunk if shown.include?(index)
+
+          skip_marker(entry, index) if marked.include?(index)
+        end.join
+      end
+
+      def skip_marker(entry, index)
+        "[hunk #{index + 1} of #{entry.hunks.size} skipped: larger than the context budget]\n"
+      end
+
+      def joined_length(parts)
+        parts.sum(&:length) + [parts.size - 1, 0].max
+      end
+
+      def partial_marker(entry, shown)
+        "[file #{entry.path}: #{shown} of #{entry.hunks.size} hunks shown]\n"
+      end
+
+      def not_shown_trailer
+        paths = @coverage.files_not_shown
+        listed = []
+        paths.first(NOT_SHOWN_LIST_LIMIT).each do |path|
+          break if listed.sum(&:length) + path.length > TRAILER_RESERVE_CHARS / 2
+
+          listed << path
+        end
+        rest = paths.size - listed.size
+        list = listed.join(', ')
+        list += " and #{rest} more" if rest.positive?
+        "[#{paths.size} file(s) not shown: #{list}]\n"
+      end
+
+      def raise_no_room!(reason)
+        detail = if reason == :non_text
+                   'the entries for files without text changes alone exceed it'
+                 else
+                   "not a single hunk fits after #{@used} chars of entries without text changes"
+                 end
+        raise ContextBudgetError,
+              "Diff does not fit into the context budget of #{@budget} chars: #{detail}. " \
+              'Raise llm.max_prompt_chars / context.max_diff_chars, or add paths to ignore_paths.'
+      end
+    end
+  end
+end

data/lib/aireview/context_builder.rb

@@ -1,16 +1,29 @@
 # frozen_string_literal: true
 require_relative 'utils'
+require_relative 'errors'
 require_relative 'secret_scrubber'
+require_relative 'diff_fetcher'
+require_relative 'context_budget'
 
 module Aireview
   class ContextBuilder
-    MAX_DIFF_CHARS = 120_000
     GENERATE_PROMPT_TEMPLATE = File.read(File.expand_path('prompts/generate.txt', __dir__)).strip.freeze
     CRITIQUE_PROMPT_TEMPLATE = File.read(File.expand_path('prompts/critique.txt', __dir__)).strip.freeze
     LANGUAGE_NAMES = {
       'ru' => 'Russian',
       'en' => 'English'
     }.freeze
+    CHANGES_HEADER = "Changes:\n"
+    CANDIDATES_HEADER = "\n\nCandidates JSON from Generate:\n"
+    # Резерв под кандидатов в промпте критика: три кандидата по ~1 500
+    # символов. Оценка, не гарантия; фактический размер проверяется перед
+    # отправкой.
+    CANDIDATES_RESERVE_CHARS = 4_500
+    STAGES = %i[generate critique].freeze
+
+    # Контекст одного прогона: обе стадии получают одинаковые MR, Jira и дифф,
+    # усечённые один раз под самую тесную из стадий.
+    Context = Struct.new(:user_prompt, :coverage, :sizes, keyword_init: true)
 
     def initialize(config:, logger: Logger.new($stderr))
       @config = config
@@ -20,32 +33,36 @@ module Aireview
         secret_files: config.secret_files,
         logger: logger
       )
+      @diff_fetcher = DiffFetcher.new(ignore_paths: [], logger: logger)
     end
 
-    def build(merge_request:, changes_text:, jira_issue: nil)
-      build_generate_prompt(merge_request: merge_request, changes_text: changes_text, jira_issue: jira_issue)
-    end
+    def prepare(merge_request:, changes:, jira_issue: nil, critique: true)
+      coverage = ContextBudget::Coverage.empty
+      budget = context_budget(critique: critique)
+      sections = merge_request_sections(merge_request, coverage: coverage)
+      sections << jira_section(jira_issue, coverage: coverage) if jira_issue
+      fixed = "#{sections.join("\n\n")}\n\n#{CHANGES_HEADER}"
 
-    def build_generate_prompt(merge_request:, changes_text:, jira_issue: nil)
-      {
-        system_prompt: system_prompt(GENERATE_PROMPT_TEMPLATE),
-        user_prompt: user_prompt(merge_request: merge_request, changes_text: changes_text, jira_issue: jira_issue)
-      }
-    end
+      diff_budget = [budget - fixed.length, @config.max_diff_chars].min
+      entries = @diff_fetcher.entries(@secret_scrubber.scrub_changes(changes))
+      packed = ContextBudget.pack_entries(entries, budget: diff_budget, coverage: coverage)
 
-    def build_critique_prompt(merge_request:, changes_text:, candidates_json:, jira_issue: nil)
-      user = "#{user_prompt(merge_request: merge_request, changes_text: changes_text, jira_issue: jira_issue)}\n\n"
-      user << "Candidates JSON from Generate:\n#{scrub_text(candidates_json)}"
+      sizes = context_sizes(fixed: fixed, packed: packed, budget: budget, diff_budget: diff_budget, critique: critique)
+      log_sizes(sizes)
+      Context.new(user_prompt: fixed + packed.text, coverage: coverage, sizes: sizes)
+    end
 
-      {
-        system_prompt: system_prompt(CRITIQUE_PROMPT_TEMPLATE),
-        user_prompt: user
-      }
+    def build_generate_prompt(context)
+      check_stage_size!(:generate, system_prompt(:generate), context.user_prompt)
     end
 
-    private
+    def build_critique_prompt(context, candidates_json:)
+      user = "#{context.user_prompt}#{CANDIDATES_HEADER}#{scrub_text(candidates_json)}"
+      check_stage_size!(:critique, system_prompt(:critique), user)
+    end
 
-    def system_prompt(template)
+    def system_prompt(stage)
+      template = stage.to_sym == :critique ? CRITIQUE_PROMPT_TEMPLATE : GENERATE_PROMPT_TEMPLATE
       extras = []
       if Aireview::Utils.present?(@config.review_instructions)
         extras << "Additional project instructions:\n#{scrub_text(@config.review_instructions.strip)}"
@@ -55,44 +72,113 @@ module Aireview
       [template, *extras].join("\n\n")
     end
 
-    def user_prompt(merge_request:, changes_text:, jira_issue:)
-      truncated_changes = truncate_changes(scrub_text(changes_text))
+    # Проверка перед отправкой: если кандидаты вышли за резерв и запрос не
+    # помещается, это ошибка, а не повод молча резать контекст, который
+    # генератор уже видел.
+    def check_stage_size!(stage, system, user)
+      limit = @config.max_prompt_chars(stage)
+      total = system.length + user.length
+      if total > limit
+        raise ContextBudgetError,
+              "#{stage.capitalize} request is #{total} chars, over llm.#{stage}.max_prompt_chars=#{limit} " \
+              "(system prompt #{system.length}, context #{user.length})"
+      end
+
+      {system_prompt: system, user_prompt: user}
+    end
+
+    private
+
+    # Минимум по стадиям: контекст один на прогон, поэтому он должен
+    # помещаться в каждую из них вместе с её системным промптом и резервом.
+    def context_budget(critique:)
+      stages = critique ? STAGES : [:generate]
+      budgets = stages.to_h { |stage| [stage, stage_budget(stage)] }
+      stage, budget = budgets.min_by { |_, value| value }
+      return budget if budget.positive?
+
+      raise ContextBudgetError,
+            "System prompt of the #{stage} stage (#{system_prompt(stage).length} chars, including " \
+            "review_instructions) leaves no room for the merge request within llm.#{stage}.max_prompt_chars=" \
+            "#{@config.max_prompt_chars(stage)}"
+    end
 
-      sections = merge_request_sections(merge_request)
-      sections << jira_section(jira_issue) if jira_issue
-      sections << "Changes:\n#{truncated_changes}"
-      sections.join("\n\n")
+    def stage_budget(stage)
+      reserve = stage == :critique ? CANDIDATES_RESERVE_CHARS + CANDIDATES_HEADER.length : 0
+      @config.max_prompt_chars(stage) - system_prompt(stage).length - reserve
     end
 
-    def merge_request_sections(merge_request)
+    def merge_request_sections(merge_request, coverage:)
       source_branch = scrub_text(merge_request['source_branch'])
       target_branch = scrub_text(merge_request['target_branch'])
+      description = ContextBudget.truncate_section(
+        scrub_optional_text(merge_request['description']),
+        limit: @config.max_mr_description_chars,
+        label: 'MR description',
+        coverage: coverage
+      )
 
       [
         "MR: #{scrub_text(merge_request['title'])}",
         "Author: #{scrub_text(merge_request.dig('author', 'name'))}",
         "Branch: #{source_branch} -> #{target_branch}",
-        "Description:\n#{scrub_optional_text(merge_request['description'])}"
+        "Description:\n#{description}"
       ]
     end
 
-    def jira_section(jira_issue)
+    def jira_section(jira_issue, coverage:)
+      description = ContextBudget.truncate_section(
+        scrub_optional_text(jira_issue['description']),
+        limit: @config.max_jira_description_chars,
+        label: 'Jira description',
+        coverage: coverage
+      )
       section = "Jira task (#{scrub_text(jira_issue['key'])}):\n"
       section << "Summary: #{scrub_text(jira_issue['summary'])}\n"
-      section << "Description:\n#{scrub_optional_text(jira_issue['description'])}"
-
-      comments = jira_issue['comments']
-      return section unless comments && !comments.empty?
-
-      section << "\nRecent comments:\n#{comments.map { |comment| scrub_text(comment) }.join("\n")}"
+      section << "Description:\n#{description}"
+
+      comments = Array(jira_issue['comments'])
+      return section if comments.empty?
+
+      rendered = comments.each_with_index.map do |comment, index|
+        ContextBudget.truncate_section(
+          scrub_text(comment),
+          limit: @config.max_jira_comment_chars,
+          label: "Jira comment #{index + 1}",
+          coverage: coverage
+        )
+      end
+      section << "\nRecent comments:\n#{rendered.join("\n")}"
     end
 
-    def truncate_changes(changes_text)
-      text = changes_text.to_s
-      return text if text.length <= MAX_DIFF_CHARS
+    def context_sizes(fixed:, packed:, budget:, diff_budget:, critique:)
+      stages = critique ? STAGES : [:generate]
+      {
+        context_budget: budget,
+        diff_budget: diff_budget,
+        sections: fixed.length,
+        diff: packed.text.length,
+        hunks_shown: packed.shown_hunks,
+        hunks_total: packed.total_hunks,
+        stages: stages.to_h do |stage|
+          system = system_prompt(stage).length
+          [stage, {system_prompt: system, request: system + fixed.length + packed.text.length,
+                   max_prompt_chars: @config.max_prompt_chars(stage)}]
+        end
+      }
+    end
 
-      omitted = text.length - MAX_DIFF_CHARS
-      "#{text[0, MAX_DIFF_CHARS]}\n\n[TRUNCATED #{omitted} chars]"
+    def log_sizes(sizes)
+      @logger.debug(
+        "Context: sections #{sizes[:sections]} chars, diff #{sizes[:diff]} chars " \
+        "(budget #{sizes[:diff_budget]}, hunks #{sizes[:hunks_shown]}/#{sizes[:hunks_total]})"
+      )
+      sizes[:stages].each do |stage, stage_sizes|
+        @logger.debug(
+          "Context #{stage}: request #{stage_sizes[:request]} chars (~#{stage_sizes[:request] / 4} tokens) " \
+          "of max #{stage_sizes[:max_prompt_chars]}, system prompt #{stage_sizes[:system_prompt]}"
+        )
+      end
     end
 
     def scrub_optional_text(text)

data/lib/aireview/diff_fetcher.rb

@@ -3,7 +3,80 @@ require_relative 'utils'
 
 module Aireview
   class DiffFetcher
-    DIFF_UNAVAILABLE = '[DIFF_NOT_AVAILABLE]'
+    NO_TEXT_CHANGES = '[no text changes]'
+    DIFF_UNAVAILABLE = '[diff not available]'
+    BINARY_DIFF = /\ABinary files .* differ/
+
+    # Один файл из ответа GitLab: заголовок, хунки и что с ним можно делать.
+    # kind:
+    #   :text            есть хунки, код можно проверить;
+    #   :no_text_changes переименование, смена режима, пустой файл: проверять
+    #                    нечего;
+    #   :unavailable     GitLab не отдал дифф (too_large, бинарник, пустой
+    #                    дифф без причины): код есть, но проверить его не удалось.
+    class Entry
+      attr_reader :path, :kind, :header, :hunks
+
+      def initialize(change)
+        old_path = change['old_path'] || change['new_path']
+        new_path = change['new_path'] || change['old_path']
+        @path = new_path
+        @header = "diff --git a/#{old_path} b/#{new_path}\n--- a/#{old_path}\n+++ b/#{new_path}\n"
+        diff = change['diff'].to_s
+        @kind = classify(change, diff)
+        @hunks = @kind == :text ? split_hunks(diff) : []
+      end
+
+      def text?
+        kind == :text
+      end
+
+      def unavailable?
+        kind == :unavailable
+      end
+
+      def body
+        case kind
+        when :text then hunks.join
+        when :no_text_changes then "#{NO_TEXT_CHANGES}\n"
+        else "#{DIFF_UNAVAILABLE}\n"
+        end
+      end
+
+      def render
+        header + body
+      end
+
+      private
+
+      # Пустой дифф без объяснимой причины (переименование, смена режима,
+      # пустой новый или удалённый файл) считаем недоступным: код есть, но
+      # GitLab его не отдал.
+      def classify(change, diff)
+        return :unavailable if change['too_large']
+        return :unavailable if diff.match?(BINARY_DIFF)
+        return :text unless diff.strip.empty?
+
+        empty_diff_explained?(change) ? :no_text_changes : :unavailable
+      end
+
+      def empty_diff_explained?(change)
+        return true if %w[renamed_file new_file deleted_file].any? { |flag| change[flag] }
+
+        modes = change.values_at('a_mode', 'b_mode')
+        modes.none?(&:nil?) && modes.uniq.size == 2
+      end
+
+      # Хунки режем по заголовкам @@; текст до первого @@ (или дифф без них,
+      # например заглушка про секретный файл) считается одним хунком.
+      def split_hunks(diff)
+        diff = "#{diff}\n" unless diff.end_with?("\n")
+        pieces = diff.split(/^(?=@@ )/)
+        return pieces if pieces.size <= 1 || pieces.first.start_with?('@@ ')
+
+        [pieces[0] + pieces[1], *pieces[2..]]
+      end
+    end
 
     def initialize(ignore_paths:, logger: Logger.new($stderr))
       @ignore_paths = Array(ignore_paths).compact
@@ -16,8 +89,12 @@ module Aireview
       end
     end
 
+    def entries(changes)
+      Array(changes).map { |change| Entry.new(change) }
+    end
+
     def render(changes)
-      Array(changes).map { |change| render_change(change) }.join("\n")
+      entries(changes).map(&:render).join("\n")
     end
 
     private
@@ -29,19 +106,5 @@ module Aireview
         File.fnmatch?(pattern, path, File::FNM_DOTMATCH | File::FNM_EXTGLOB)
       end
     end
-
-    def render_change(change)
-      old_path = change['old_path'] || change['new_path']
-      new_path = change['new_path'] || change['old_path']
-      diff = change['diff'].to_s
-      diff = DIFF_UNAVAILABLE if diff.strip.empty?
-
-      <<~DIFF
-        diff --git a/#{old_path} b/#{new_path}
-        --- a/#{old_path}
-        +++ b/#{new_path}
-        #{diff}
-      DIFF
-    end
   end
 end

data/lib/aireview/dry_run_report.rb

@@ -0,0 +1,64 @@
+# frozen_string_literal: true
+
+module Aireview
+  # Вывод --dry-run: настройки, сводка контекста и промпты обеих стадий.
+  class DryRunReport
+    def initialize(out)
+      @out = out
+    end
+
+    def render(dry_run)
+      @out.puts('=== LLM SETTINGS ===')
+      @out.puts("Generate: #{dry_run[:generate_model]} temperature=#{dry_run[:generate_temperature]}")
+      if dry_run[:critique_prompt]
+        @out.puts("Critique: #{dry_run[:critique_model]} temperature=#{dry_run[:critique_temperature]}")
+      else
+        @out.puts('Critique: disabled')
+      end
+      @out.puts
+      @out.puts('=== CONTEXT ===')
+      render_context_sizes(dry_run[:sizes])
+      render_coverage(dry_run[:coverage])
+      @out.puts
+      @out.puts('=== GENERATE SYSTEM PROMPT ===')
+      @out.puts(dry_run.dig(:generate_prompt, :system_prompt))
+      @out.puts
+      @out.puts('=== GENERATE USER PROMPT ===')
+      @out.puts(dry_run.dig(:generate_prompt, :user_prompt))
+      return unless dry_run[:critique_prompt]
+
+      @out.puts
+      @out.puts('=== CRITIQUE SYSTEM PROMPT ===')
+      @out.puts(dry_run.dig(:critique_prompt, :system_prompt))
+      @out.puts
+      @out.puts('=== CRITIQUE USER PROMPT ===')
+      @out.puts(dry_run.dig(:critique_prompt, :user_prompt))
+    end
+
+    private
+
+    def render_context_sizes(sizes)
+      @out.puts("Sections: #{sizes[:sections]} chars, diff: #{sizes[:diff]} chars " \
+                "(budget #{sizes[:diff_budget]}, hunks #{sizes[:hunks_shown]}/#{sizes[:hunks_total]})")
+      sizes[:stages].each do |stage, stage_sizes|
+        @out.puts("#{stage.capitalize} request: #{stage_sizes[:request]} chars " \
+                  "(~#{stage_sizes[:request] / 4} tokens) of max #{stage_sizes[:max_prompt_chars]}, " \
+                  "system prompt #{stage_sizes[:system_prompt]}")
+      end
+    end
+
+    def render_coverage(coverage)
+      return @out.puts('Coverage: complete') if coverage.complete?
+
+      @out.puts('Coverage: partial')
+      list('truncated sections', coverage.truncated_sections)
+      list('files not shown', coverage.files_not_shown)
+      coverage.files_partial.each { |file| @out.puts("  #{file[:path]}: #{file[:shown]} of #{file[:total]} hunks") }
+      list('diff not available', coverage.files_unavailable)
+    end
+
+    def list(title, items)
+      @out.puts("  #{title}: #{items.join(', ')}") unless items.empty?
+    end
+  end
+end

data/lib/aireview/errors.rb

@@ -4,5 +4,6 @@ module Aireview
   class ConfigError < Error; end
   class ParseError < Error; end
   class ApiError < Error; end
+  class ContextBudgetError < Error; end
   class HelpRequested < Error; end
 end

data/lib/aireview/prompts/critique.txt

@@ -4,6 +4,10 @@ You are given the diff, the MR description, the Jira context and the candidates
 from the first pass. For every candidate return a verdict with decision=keep
 or reject.
 
+Parts of the context may be truncated to fit the budget; markers in square
+brackets show where. Missing text in a truncated part does not mean a missing
+requirement or missing code.
+
 Be a strict filter:
 - when in doubt, choose reject;
 - keep only the most important and well-supported findings;

data/lib/aireview/prompts/generate.txt

@@ -3,6 +3,10 @@ You are doing the first pass of a merge request review.
 Look only at the diff, the MR description and the Jira context, if present.
 Do not draw conclusions about code outside the diff.
 
+Parts of the context may be truncated to fit the budget; markers in square
+brackets show where. Missing text in a truncated part does not mean a missing
+requirement or missing code.
+
 Do not verify that the specified versions of packages, libraries, tools and
 image tags exist. Do not report that a version does not exist or has not been
 released yet. Check syntax errors and explicit contradictions with the MR/Jira

data/lib/aireview/review_pipeline.rb

@@ -28,12 +28,14 @@ module Aireview
       @logger = logger
     end
 
-    def run(merge_request:, changes_text:, jira_issue: nil, critique: true)
-      generate_prompt = @context_builder.build_generate_prompt(
+    def run(merge_request:, changes:, jira_issue: nil, critique: true)
+      context = @context_builder.prepare(
         merge_request: merge_request,
-        changes_text: changes_text,
-        jira_issue: jira_issue
+        changes: changes,
+        jira_issue: jira_issue,
+        critique: critique
       )
+      generate_prompt = @context_builder.build_generate_prompt(context)
       @logger.info("Pipeline generate pass started (model=#{@config.generate_model})")
       candidates_raw = @reviewer.generate(**generate_prompt)
       generate_result = parse_with_repair(
@@ -48,12 +50,7 @@ module Aireview
 
       accepted = if critique
                    @logger.info("Pipeline critique pass started (model=#{@config.critique_model})")
-                   critique_candidates(
-                     merge_request: merge_request,
-                     changes_text: changes_text,
-                     jira_issue: jira_issue,
-                     candidates: candidates
-                   )
+                   critique_candidates(context: context, candidates: candidates)
                  else
                    @logger.info('Pipeline critique pass skipped')
                    candidates
@@ -61,25 +58,22 @@ module Aireview
 
       @logger.info("Pipeline finished with #{accepted.size} accepted finding(s)")
 
-      ReviewRenderer.new(language: @config.review_language).render(accepted, summary: summary)
+      renderer = ReviewRenderer.new(language: @config.review_language)
+      renderer.render(accepted, summary: summary, coverage: context.coverage)
     end
 
-    def dry_run_prompts(merge_request:, changes_text:, jira_issue: nil, critique: true)
+    def dry_run_prompts(merge_request:, changes:, jira_issue: nil, critique: true)
       @config.require_models!
 
-      generate_prompt = @context_builder.build_generate_prompt(
+      context = @context_builder.prepare(
         merge_request: merge_request,
-        changes_text: changes_text,
-        jira_issue: jira_issue
+        changes: changes,
+        jira_issue: jira_issue,
+        critique: critique
       )
-
+      generate_prompt = @context_builder.build_generate_prompt(context)
       critique_prompt = if critique
-                          @context_builder.build_critique_prompt(
-                            merge_request: merge_request,
-                            changes_text: changes_text,
-                            jira_issue: jira_issue,
-                            candidates_json: DRY_RUN_CANDIDATES_JSON
-                          )
+                          @context_builder.build_critique_prompt(context, candidates_json: DRY_RUN_CANDIDATES_JSON)
                         end
 
       {
@@ -88,21 +82,18 @@ module Aireview
         generate_model: @config.generate_model,
         generate_temperature: @config.generate_temperature,
         critique_model: @config.critique_model,
-        critique_temperature: @config.critique_temperature
+        critique_temperature: @config.critique_temperature,
+        coverage: context.coverage,
+        sizes: context.sizes
       }
     end
 
     private
 
-    def critique_candidates(merge_request:, changes_text:, jira_issue:, candidates:)
+    def critique_candidates(context:, candidates:)
       candidates_json = JSON.pretty_generate(candidates)
       candidates_by_id = index_candidates_by_id(candidates)
-      critique_prompt = @context_builder.build_critique_prompt(
-        merge_request: merge_request,
-        changes_text: changes_text,
-        jira_issue: jira_issue,
-        candidates_json: candidates_json
-      )
+      critique_prompt = @context_builder.build_critique_prompt(context, candidates_json: candidates_json)
       critique_raw = @reviewer.critique(**critique_prompt)
       critique_result = parse_with_repair(
         raw: critique_raw,
@@ -284,10 +275,11 @@ module Aireview
       end
 
       @logger.info("Pipeline #{stage} repair started for #{kind}")
+      prompt = @context_builder.check_stage_size!(stage, REPAIR_SYSTEM_PROMPT, user_prompt)
       if stage == :critique
-        @reviewer.critique(system_prompt: REPAIR_SYSTEM_PROMPT, user_prompt: user_prompt)
+        @reviewer.critique(**prompt)
       else
-        @reviewer.generate(system_prompt: REPAIR_SYSTEM_PROMPT, user_prompt: user_prompt)
+        @reviewer.generate(**prompt)
       end
     end
 

data/lib/aireview/review_renderer.rb

@@ -35,7 +35,16 @@ module Aireview
         where: 'Where',
         problem: 'Problem',
         why: 'Why it matters',
-        suggestion: 'Suggestion'
+        suggestion: 'Suggestion',
+        partial: 'Partial review',
+        not_reviewed: 'Not reviewed',
+        files_not_shown: 'files not reviewed',
+        files_partial: 'files reviewed partially',
+        files_unavailable: 'files without an available diff',
+        sections_truncated: 'sections truncated',
+        hunks_of: 'hunks shown',
+        diff_unavailable: 'diff not available',
+        section_list: 'Truncated sections'
       },
       'ru' => {
         summary: 'Сводка',
@@ -50,7 +59,16 @@ module Aireview
         where: 'Где',
         problem: 'Проблема',
         why: 'Почему важно',
-        suggestion: 'Предложение'
+        suggestion: 'Предложение',
+        partial: 'Ревью частичное',
+        not_reviewed: 'Не вошло в ревью',
+        files_not_shown: 'файлов не проверено',
+        files_partial: 'файлов проверено частично',
+        files_unavailable: 'файлов без доступного диффа',
+        sections_truncated: 'секций усечено',
+        hunks_of: 'хунков показано',
+        diff_unavailable: 'дифф недоступен',
+        section_list: 'Усечённые секции'
       }
     }.freeze
 
@@ -58,7 +76,11 @@ module Aireview
       @labels = LABELS.fetch(language.to_s) { LABELS.fetch(DEFAULT_LANGUAGE) }
     end
 
-    def render(accepted, summary:)
+    # coverage: факты усечения контекста от пайплайна, не текст модели.
+    # 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)
@@ -79,8 +101,8 @@ module Aireview
 
         ## #{label(:result)}
 
-        #{result}
-
+        #{result}#{partial_note(coverage)}
+        #{coverage_block(coverage)}
         #{label(:disclaimer)}
       MARKDOWN
     end
@@ -117,6 +139,34 @@ module Aireview
       end.join("\n\n")
     end
 
+    def partial_note(coverage)
+      return '' if coverage.nil? || coverage.complete?
+
+      counts = {
+        files_not_shown: coverage.files_not_shown.size,
+        files_partial: coverage.files_partial.size,
+        files_unavailable: coverage.files_unavailable.size,
+        sections_truncated: coverage.truncated_sections.size
+      }.reject { |_, count| count.zero? }.map { |key, count| "#{count} #{label(key)}" }
+
+      ". #{label(:partial)}: #{counts.join(', ')}."
+    end
+
+    def coverage_block(coverage)
+      return '' if coverage.nil? || coverage.complete?
+
+      lines = coverage.files_not_shown.map { |path| "- #{path}" }
+      lines += coverage.files_partial.map do |file|
+        "- #{file[:path]}: #{file[:shown]}/#{file[:total]} #{label(:hunks_of)}"
+      end
+      lines += coverage.files_unavailable.map { |path| "- #{path}: #{label(:diff_unavailable)}" }
+      unless coverage.truncated_sections.empty?
+        lines << "- #{label(:section_list)}: #{coverage.truncated_sections.join(', ')}"
+      end
+
+      "\n## #{label(:not_reviewed)}\n\n#{lines.join("\n")}\n"
+    end
+
     def location(finding)
       file = presence(value(finding, 'file'))
       line = value(finding, 'line')

data/lib/aireview/version.rb

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

data/lib/aireview.rb

@@ -20,4 +20,5 @@ require_relative 'aireview/gitlab_client'
 require_relative 'aireview/jira_client'
 require_relative 'aireview/review_marker'
 require_relative 'aireview/publisher'
+require_relative 'aireview/dry_run_report'
 require_relative 'aireview/cli'

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: aireview
 version: !ruby/object:Gem::Version
-  version: 0.1.1
+  version: 0.2.0
 platform: ruby
 authors:
 - Denis Levenko
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2026-09-11 00:00:00.000000000 Z
+date: 2026-09-12 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: dotenv
@@ -63,6 +63,7 @@ extensions: []
 extra_rdoc_files: []
 files:
 - CHANGELOG.md
+- CONTRIBUTORS.md
 - LICENSE
 - README.md
 - bin/aireview
@@ -70,8 +71,11 @@ files:
 - lib/aireview.rb
 - lib/aireview/cli.rb
 - lib/aireview/config.rb
+- lib/aireview/config_limits.rb
+- lib/aireview/context_budget.rb
 - lib/aireview/context_builder.rb
 - lib/aireview/diff_fetcher.rb
+- lib/aireview/dry_run_report.rb
 - lib/aireview/errors.rb
 - lib/aireview/gitlab_client.rb
 - lib/aireview/jira_client.rb
@@ -96,6 +100,7 @@ metadata:
   source_code_uri: https://github.com/DenisDenis9331/aireview
   changelog_uri: https://github.com/DenisDenis9331/aireview/blob/main/CHANGELOG.md
   bug_tracker_uri: https://github.com/DenisDenis9331/aireview/issues
+  funding_uri: https://ko-fi.com/denis1011101
   rubygems_mfa_required: 'true'
 post_install_message:
 rdoc_options: []