aireview 0.1.0 → 0.2.0

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;
@@ -23,6 +27,12 @@ Implementation details (config flags, deploy settings, new fields, helper
 methods), accompanying refactoring and any changes whose relation to the task
 is plausible are NOT task_mismatch. Reject such candidates.
 
+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
+requirements as usual.
+Reject candidates claiming that a version does not exist.
+
 Reject a candidate if it:
 - is not confirmed by the diff or Jira;
 - is based on an assumption about code outside the diff;

data/lib/aireview/prompts/generate.txt

@@ -3,6 +3,15 @@ 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
+requirements as usual.
+
 Look only for the most important and well-supported findings:
 - bugs, regressions, data loss;
 - security and performance risks;

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')