ace-review 0.54.2 → 0.55.0

data/lib/ace/review/cli/commands/review.rb

@@ -60,6 +60,8 @@ module Ace
           option :pr_comments, type: :boolean, desc: "Include PR comments as feedback source (default: true for --pr)"
           option :post_comment, type: :boolean, desc: "Post review as PR comment (requires --pr)"
           option :gh_timeout, type: :integer, desc: "Timeout for gh CLI operations in seconds (default: 30)"
+          option :evidence_session, type: :array, desc: "Include selected prior review sessions as context"
+          option :prepare_goals_brief, type: :boolean, desc: "Generate or reuse the shared goals brief for this PR and preset"
 
           # Standard options
           option :version, type: :boolean, desc: "Show version information"
@@ -73,7 +75,7 @@ module Ace
 
           def call(**cli_options)
             # Remove ace-support-cli specific keys (args is leftover arguments)
-            cli_options = cli_options.reject { |k, _| k == :args }
+            cli_options = cli_options.except(:args)
 
             if cli_options[:version]
               puts "ace-review #{Ace::Review::VERSION}"
@@ -90,6 +92,11 @@ module Ace
               return
             end
 
+            if cli_options[:prepare_goals_brief]
+              prepare_goals_brief(cli_options)
+              return
+            end
+
             # Type-convert numeric options (ace-support-cli returns strings, Thor converted to integers)
             cli_options[:gh_timeout] = cli_options[:gh_timeout]&.to_i if cli_options[:gh_timeout]
 
@@ -101,6 +108,16 @@ module Ace
 
           private
 
+          def prepare_goals_brief(cli_options)
+            raise Ace::Support::Cli::Error.new("--pr is required for goals-brief preparation") unless cli_options[:pr]
+
+            options = Models::ReviewOptions.new(build_review_options(cli_options))
+            result = Organisms::ReviewManager.new.prepare_goals_brief(options)
+            raise Ace::Support::Cli::Error.new(result[:error]) unless result[:success]
+
+            puts "✓ Goals brief #{result[:cache_hit] ? "reused" : "generated"}: #{result[:path]}"
+          end
+
           def execute_review
             display_config_summary
 
@@ -168,10 +185,8 @@ module Ace
               validate_model_names(models)
               # Store in :models (array) not :model (expects string)
               options[:models] = models
-              options.delete(:model)
-            else
-              options.delete(:model)
             end
+            options.delete(:model)
           end
 
           def validate_model_names(models)
@@ -194,6 +209,9 @@ module Ace
               puts "✓ Review saved: #{result[:output_file]}"
             elsif result[:session_dir]
               puts "✓ Review session prepared: #{result[:session_dir]}"
+              if result[:budget]
+                puts "  Estimated complete input: #{result[:budget][:total_tokens]} / #{result[:budget][:input_limit]} tokens"
+              end
 
               # Display prompt files for ace-bundle workflow
               if result[:system_prompt_file] && result[:user_prompt_file]
@@ -295,7 +313,7 @@ module Ace
             puts
 
             # Header
-            puts format("%-20s %-50s %-10s", "Preset", "Description", "Source")
+            puts format("%-20s %-50s %-10s", *%w[Preset Description Source])
             puts "-" * 80
 
             # Load preset manager to get descriptions

data/lib/ace/review/cli.rb

@@ -16,6 +16,7 @@ module Ace
       # Separator for array options that won't conflict with internal commas
       # ASCII Unit Separator (0x1F) is designed for separating fields
       ARRAY_SEPARATOR = "\x1F"
+      CONTEXT_FLAGS = %w[--evidence-session].freeze
 
       # Pre-process array options to work around ace-support-cli limitation
       #
@@ -31,6 +32,7 @@ module Ace
         i = 0
         accumulated_subject = []
         accumulated_model = []
+        accumulated_context = Hash.new { |hash, key| hash[key] = [] }
 
         while i < args.length
           arg = args[i]
@@ -51,6 +53,15 @@ module Ace
             next
           end
 
+          CONTEXT_FLAGS.each do |flag|
+            next unless arg == flag || arg.start_with?("#{flag}=")
+
+            accumulated_context[flag] << extract_flag_value(arg, args, i)
+            i = skip_to_next_arg(args, i)
+            break
+          end
+          next if CONTEXT_FLAGS.any? { |flag| arg == flag || arg.start_with?("#{flag}=") }
+
           result << arg
           i += 1
         end
@@ -59,6 +70,9 @@ module Ace
         result.insert(0, "--model", accumulated_model.join(",")) unless accumulated_model.empty?
         # Subject uses ARRAY_SEPARATOR to preserve internal commas (e.g., files:a.rb,b.rb)
         result.insert(0, "--subject", accumulated_subject.join(ARRAY_SEPARATOR)) unless accumulated_subject.empty?
+        accumulated_context.each do |flag, values|
+          result.insert(0, flag, values.join(ARRAY_SEPARATOR)) unless values.empty?
+        end
 
         result
       end
@@ -85,7 +99,9 @@ module Ace
       # @param index [Integer] Current index
       # @return [Integer] Next index to process
       def self.skip_to_next_arg(args, index)
-        if args[index].include?("=") || (index + 1 < args.length && !args[index + 1].start_with?("--"))
+        if args[index].include?("=")
+          index + 1
+        elsif index + 1 < args.length && !args[index + 1].start_with?("--")
           index + 2
         else
           index + 1

data/lib/ace/review/models/feedback_item.rb

@@ -68,7 +68,7 @@ module Ace
 
           @status = attrs[:status] || "draft"
           @priority = attrs[:priority] || "medium"
-          @created = attrs[:created] || Time.now.utc.iso8601
+          @created = attrs[:created] || Time.now.utc.iso8601(6)
           @updated = attrs[:updated] || @created
           @finding = attrs[:finding]
           @context = attrs[:context]
@@ -130,7 +130,7 @@ module Ace
         # @return [FeedbackItem] New instance with merged attributes
         def dup_with(**changes)
           # Auto-update the updated timestamp when making changes
-          changes[:updated] ||= Time.now.utc.iso8601
+          changes[:updated] ||= Time.now.utc.iso8601(6)
           FeedbackItem.new(to_h.merge(stringify_keys(changes)))
         end
 

data/lib/ace/review/models/review_options.rb

@@ -11,6 +11,7 @@ module Ace
           :auto_execute, :save_session, :session_dir,
           :pr, :post_comment, :pr_metadata, :gh_timeout,
           :pr_comments, :pr_comment_data,
+          :evidence_sessions,
           :no_feedback, :feedback_model,
           :list_presets, :list_prompts, :help
 
@@ -57,6 +58,7 @@ module Ace
           # PR comment options
           @pr_comments = hash[:pr_comments]  # nil = use default, true/false = explicit
           @pr_comment_data = nil  # Populated during execution
+          @evidence_sessions = Array(hash[:evidence_session]).flat_map { |value| value.to_s.split("\x1F") }.reject(&:empty?)
 
           # Feedback extraction options
           @no_feedback = hash[:no_feedback] || false

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

@@ -0,0 +1,92 @@
+# frozen_string_literal: true
+
+require "digest"
+require_relative "../atoms/diff_boundary_finder"
+require_relative "subject_filter"
+
+module Ace
+  module Review
+    module Molecules
+      # Selects complete file diffs before ace-bundle renders a review packet.
+      # Refuses unparsed input instead of silently dropping a changed file.
+      module DiffScope
+        def self.select(diff, patterns = nil, groups: nil)
+          patterns = patterns.transform_keys(&:to_s) if patterns.is_a?(Hash)
+          groups = groups.map { |group| group.is_a?(Hash) ? group.transform_keys(&:to_s) : group } if groups.is_a?(Array)
+          valid_groups = groups.nil? || (groups.is_a?(Array) && groups.all? { |group| valid_patterns?(group) && !group.nil? })
+          unless valid_patterns?(patterns) && valid_groups
+            return {success: false, error: "Review file patterns/groups must contain include/exclude arrays of glob strings"}
+          end
+
+          blocks = Atoms::DiffBoundaryFinder.parse(diff)
+          unless blocks.any? && blocks.map { |block| block[:content] }.join == diff
+            return {success: false, error: "Cannot account for every PR diff block; review input is incomplete"}
+          end
+
+          filters = [patterns, *Array(groups)].compact
+          selected, excluded = blocks.partition { |block| selected_block?(block, filters) }
+          if selected.empty?
+            return {success: false, error: "Review scope contains no changed files"}
+          end
+
+          {
+            success: true,
+            diff: selected.map { |block| block[:content] }.join,
+            manifest: {
+              raw_sha256: Digest::SHA256.hexdigest(diff),
+              selected_sha256: Digest::SHA256.hexdigest(selected.map { |block| block[:content] }.join),
+              selected_files: selected.map { |block| block[:path] },
+              excluded_files: excluded.map { |block| block[:path] },
+              binary_files: binary_paths(blocks),
+              renames: selected.filter_map do |block|
+                {from: block[:old_path], to: block[:path]} if block[:old_path] != block[:path]
+              end,
+              received_diff_accounted_for: true,
+              file_pattern_groups: filters
+            }
+          }
+        rescue ArgumentError => e
+          {success: false, error: "Cannot account for every PR diff block: #{e.message}"}
+        end
+
+        def self.binary_paths(blocks)
+          blocks.select { |block| binary_only?(block) }.map { |block| block[:path] }
+        end
+
+        def self.valid_patterns?(patterns)
+          return true if patterns.nil?
+          return false unless patterns.is_a?(Hash)
+          return false unless (patterns.keys.map(&:to_s) - %w[include exclude]).empty?
+
+          patterns.values.all? { |value| value.is_a?(Array) && value.all? { |item| item.is_a?(String) && !item.empty? } }
+        end
+        private_class_method :valid_patterns?
+
+        def self.binary_only?(block)
+          block[:content].each_line.any? do |line|
+            line.start_with?("Binary files ", "GIT binary patch")
+          end
+        end
+        private_class_method :binary_only?
+
+        def self.selected_block?(block, filters)
+          return true if filters.empty?
+          paths = [block[:path], block[:old_path]].compact.uniq
+          return false if filters.any? do |patterns|
+            paths.any? do |path|
+              Array(patterns["exclude"]).any? { |pattern| SubjectFilter.glob_match?(pattern, path) }
+            end
+          end
+
+          paths.any? do |path|
+            filters.all? do |patterns|
+              includes = Array(patterns["include"])
+              includes.empty? || includes.any? { |pattern| SubjectFilter.glob_match?(pattern, path) }
+            end
+          end
+        end
+        private_class_method :selected_block?
+      end
+    end
+  end
+end

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

@@ -3,6 +3,7 @@
 require "json"
 require "fileutils"
 require "tmpdir"
+require_relative "../atoms/prompt_budget"
 
 module Ace
   module Review
@@ -28,7 +29,7 @@ module Ace
       class FeedbackSynthesizer
         # Cached system prompt and prompt-path lookups to avoid repeated
         # shell/file reads during test and command-heavy runs.
-        FALLBACK_SYSTEM_PROMPT = <<~PROMPT.freeze
+        FALLBACK_SYSTEM_PROMPT = <<~PROMPT
           Synthesize feedback from code review reports into unique findings.
 
           For each unique issue found:
@@ -56,6 +57,8 @@ module Ace
           - When only one report: extract all findings as-is with that reviewer
           - When multiple reports: deduplicate findings that describe the same issue
           - When multiple reviewers find the same issue, list ALL of them in reviewers array
+          - Preserve every distinct finding, including ones reported by only one reviewer
+          - Consensus is metadata, never a reason to omit a finding
           - Merge file arrays from all sources for each finding
           - Return ONLY the JSON, no markdown code fences
         PROMPT
@@ -66,10 +69,10 @@ module Ace
               system_prompt_cache.fetch(prompt_name) do
                 prompt_path = resolve_prompt_path_cached(prompt_name)
 
-                if prompt_path && File.exist?(prompt_path)
-                  system_prompt_cache[prompt_name] = File.read(prompt_path)
+                system_prompt_cache[prompt_name] = if prompt_path && File.exist?(prompt_path)
+                  File.read(prompt_path)
                 else
-                  system_prompt_cache[prompt_name] = FALLBACK_SYSTEM_PROMPT
+                  FALLBACK_SYSTEM_PROMPT
                 end
               end
             end
@@ -117,9 +120,6 @@ module Ace
           end
         end
 
-        # Maximum combined report size before truncation (characters)
-        MAX_COMBINED_SIZE = 200_000
-
         attr_reader :llm_executor
 
         def initialize(llm_executor: nil)
@@ -161,26 +161,19 @@ module Ace
         # @param report_paths [Array<String>] Paths to report files
         # @return [Array<Hash>] Array of report hashes with :path, :reviewer, :content
         def read_reports(report_paths)
-          reports = []
-
-          report_paths.each do |path|
-            next unless File.exist?(path)
-
+          report_paths.map do |path|
+            raise ArgumentError, "Review report is missing: #{path}" unless File.file?(path)
             content = File.read(path)
-            next if content.strip.empty?
+            raise ArgumentError, "Review report is empty: #{path}" if content.strip.empty?
 
             reviewer = extract_reviewer_from_filename(path)
-            reports << {
+            {
               path: path,
               reviewer: reviewer,
               content: content,
               size: content.bytesize
             }
-          rescue => e
-            warn "Warning: Failed to read report #{path}: #{e.message}" if Ace::Review.debug?
           end
-
-          reports
         end
 
         # Synthesize reports into unified findings
@@ -200,6 +193,14 @@ module Ace
           output_file = File.join(session_dir, "feedback-synthesis.raw.txt")
 
           synthesis_model = model || default_synthesis_model
+          budget = Atoms::PromptBudget.check(system_prompt: system_prompt, user_prompt: user_prompt,
+            models: [synthesis_model])
+          unless budget[:success]
+            return synthesize_reports_separately(reports, session_dir, synthesis_model) if reports.length > 1
+
+            return error_result("Synthesis prompt exceeds budget: #{budget[:errors].join("; ")}")
+          end
+
           display_synthesis_start(reports.size, synthesis_model)
 
           result = @llm_executor.execute(
@@ -225,6 +226,26 @@ module Ace
           )
         end
 
+        def synthesize_reports_separately(reports, session_dir, model)
+          extracted = reports.each_with_index.map do |report, index|
+            part_dir = File.join(session_dir, "report-#{index + 1}")
+            FileUtils.mkdir_p(part_dir)
+            result = synthesize_reports([report], part_dir, model)
+            return error_result("Report #{index + 1} could not be extracted: #{result[:error]}") unless result[:success]
+
+            result[:items]
+          end.flatten
+
+          # Keep every finding. Per-report extraction cannot safely infer that
+          # two differently worded findings are the same defect.
+          ids = extracted.empty? ? [] : Atoms::FeedbackIdGenerator.generate_sequence(extracted.length)
+          items = extracted.each_with_index.map { |item, index| item.dup_with(id: ids[index]) }
+          persist_cleaned_json(session_dir, {"findings" => items.map(&:to_h)})
+          {success: true, items: items,
+           metadata: {total_findings: items.length, consensus_findings: 0,
+                      reviewers_count: reports.length, segmented: true}}
+        end
+
         # Load the synthesis system prompt
         #
         # @return [String] System prompt content
@@ -244,9 +265,6 @@ module Ace
         # @param reports [Array<Hash>] Array of report data
         # @return [String] User prompt
         def build_reports_prompt(reports)
-          # Check total size
-          total_size = reports.sum { |r| r[:size] }
-
           content = "Synthesize these #{reports.size} code review report"
           content += (reports.size == 1) ? "." : "s into unique, deduplicated findings."
           content += "\n\n"
@@ -256,16 +274,7 @@ module Ace
             content += "---\n"
             content += "## Report #{idx + 1}: #{report[:reviewer]}\n\n"
 
-            # Truncate individual reports if total is too large
-            report_content = report[:content]
-            if total_size > MAX_COMBINED_SIZE
-              max_per_report = MAX_COMBINED_SIZE / reports.size
-              if report_content.length > max_per_report
-                report_content = report_content[0, max_per_report] + "\n\n[... truncated ...]"
-              end
-            end
-
-            content += report_content
+            content += report[:content]
             content += "\n\n"
           end
 

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

@@ -1,5 +1,6 @@
 # frozen_string_literal: true
 
+require "ace/git/github"
 require "tempfile"
 
 module Ace
@@ -17,11 +18,11 @@ module Ace
         # @return [Hash] Result with :success, :comment_url, :preview, :error
         def self.post_comment(pr_identifier, review_text, options = {})
           # Parse identifier using ace-git
-          parsed = Ace::Git::Atoms::PrIdentifierParser.parse(pr_identifier)
+          parsed = Ace::Git::Github::PrIdentifier.parse(pr_identifier)
           gh_format = parsed.gh_format
 
           # Check PR state before posting
-          state_check = check_pr_state(gh_format)
+          state_check = check_pr_state(parsed)
           return state_check unless state_check[:success]
 
           # Format comment with metadata
@@ -38,7 +39,7 @@ module Ace
           end
 
           # Post comment via gh CLI
-          result = post_via_gh(gh_format, formatted_comment)
+          result = post_via_gh(parsed, formatted_comment)
 
           if result[:success]
             comment_url = extract_comment_url(result[:stdout], parsed.to_h)
@@ -54,7 +55,7 @@ module Ace
             }
           end
         rescue Ace::Review::Errors::GhCliNotInstalledError, Ace::Review::Errors::GhAuthenticationError,
-          Ace::Git::GhNotInstalledError, Ace::Git::GhAuthenticationError
+          Ace::Git::ProviderCliMissingError, Ace::Git::ProviderAuthenticationError
           raise
         rescue => e
           {
@@ -65,13 +66,13 @@ module Ace
 
         # Check if PR is in a state that allows comments
         #
-        # @param gh_format [String] PR identifier in gh format
+        # @param parsed [Ace::Git::Github::PrIdentifier::ParseResult] Parsed PR target
         # @return [Hash] Result with :success or :error
-        def self.check_pr_state(gh_format)
+        def self.check_pr_state(parsed)
           # Fetch PR metadata
-          result = Ace::Git::Molecules::GhCliExecutor.execute(
+          result = Ace::Git::Github::CliExecutor.execute(
             "pr",
-            ["view", gh_format, "--json", "state,number"]
+            ["view", *parsed.cli_target_args, "--json", "state,number"]
           )
 
           unless result[:success]
@@ -160,19 +161,19 @@ module Ace
 
         # Post comment via gh CLI using a temp file for the body
         #
-        # @param gh_format [String] PR identifier in gh format
+        # @param parsed [Ace::Git::Github::PrIdentifier::ParseResult] Parsed PR target
         # @param comment_body [String] Comment content
         # @return [Hash] Result from gh CLI
-        def self.post_via_gh(gh_format, comment_body)
+        def self.post_via_gh(parsed, comment_body)
           # Write comment to temp file (gh pr comment reads from file)
           Tempfile.create(["review-comment", ".md"]) do |file|
             file.write(comment_body)
             file.flush
 
             # Post using gh pr comment
-            Ace::Git::Molecules::GhCliExecutor.execute(
+            Ace::Git::Github::CliExecutor.execute(
               "pr",
-              ["comment", gh_format, "--body-file", file.path]
+              ["comment", *parsed.cli_target_args, "--body-file", file.path]
             )
           end
         end

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

@@ -1,5 +1,6 @@
 # frozen_string_literal: true
 
+require "ace/git/github"
 require "json"
 
 module Ace
@@ -23,8 +24,7 @@ module Ace
           end
 
           # Parse identifier using ace-git
-          parsed = Ace::Git::Atoms::PrIdentifierParser.parse(pr_identifier)
-          gh_format = parsed.gh_format
+          parsed = Ace::Git::Github::PrIdentifier.parse(pr_identifier)
 
           # Build message
           short_sha = commit_sha.to_s[0..6]
@@ -34,9 +34,9 @@ module Ace
           timeout = options[:timeout] || 30
 
           # Post comment using gh CLI
-          result = Ace::Git::Molecules::GhCliExecutor.execute(
+          result = Ace::Git::Github::CliExecutor.execute(
             "pr",
-            ["comment", gh_format, "--body", body],
+            ["comment", *parsed.cli_target_args, "--body", body],
             timeout: timeout
           )
 
@@ -55,7 +55,7 @@ module Ace
             }
           end
         rescue Ace::Review::Errors::GhCliNotInstalledError, Ace::Review::Errors::GhAuthenticationError,
-          Ace::Git::GhNotInstalledError, Ace::Git::GhAuthenticationError
+          Ace::Git::ProviderCliMissingError, Ace::Git::ProviderAuthenticationError
           raise
         rescue => e
           {
@@ -92,7 +92,7 @@ module Ace
           mutation = build_resolve_thread_mutation(thread_id)
 
           # Execute via gh api graphql
-          result = Ace::Git::Molecules::GhCliExecutor.execute(
+          result = Ace::Git::Github::CliExecutor.execute(
             "api",
             ["graphql", "-f", "query=#{mutation}"],
             timeout: timeout
@@ -120,7 +120,7 @@ module Ace
             }
           end
         rescue Ace::Review::Errors::GhCliNotInstalledError, Ace::Review::Errors::GhAuthenticationError,
-          Ace::Git::GhNotInstalledError, Ace::Git::GhAuthenticationError
+          Ace::Git::ProviderCliMissingError, Ace::Git::ProviderAuthenticationError
           raise
         rescue => e
           {

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

@@ -1,5 +1,6 @@
 # frozen_string_literal: true
 
+require "ace/git/github"
 require "json"
 require_relative "../atoms/retry_with_backoff"
 
@@ -71,7 +72,7 @@ module Ace
         # @return [Hash] Result with :success, :comments, :reviews, :review_threads, :error
         def self.fetch(pr_identifier, options = {})
           # Parse identifier to get gh CLI format using ace-git
-          parsed = Ace::Git::Atoms::PrIdentifierParser.parse(pr_identifier)
+          parsed = Ace::Git::Github::PrIdentifier.parse(pr_identifier)
           gh_format = parsed.gh_format
 
           # Default timeout for PR operations
@@ -82,7 +83,7 @@ module Ace
           fields = "comments,reviews,number,title,author"
 
           result = Ace::Review::Atoms::RetryWithBackoff.execute(options) do
-            Ace::Git::Molecules::GhCliExecutor.execute("pr", ["view", gh_format, "--json", fields], timeout: timeout)
+            Ace::Git::Github::CliExecutor.execute("pr", ["view", *parsed.cli_target_args, "--json", fields], timeout: timeout)
           end
 
           if result[:success]
@@ -117,7 +118,7 @@ module Ace
             error: "Failed to parse PR comments: #{e.message}"
           }
         rescue Ace::Review::Errors::GhCliNotInstalledError, Ace::Review::Errors::GhAuthenticationError,
-          Ace::Git::GhNotInstalledError, Ace::Git::GhAuthenticationError
+          Ace::Git::ProviderCliMissingError, Ace::Git::ProviderAuthenticationError
           raise
         rescue => e
           {
@@ -251,7 +252,7 @@ module Ace
 
           # Execute GraphQL query
           result = Ace::Review::Atoms::RetryWithBackoff.execute(options) do
-            Ace::Git::Molecules::GhCliExecutor.execute(
+            Ace::Git::Github::CliExecutor.execute(
               "api",
               [
                 "graphql",
@@ -383,7 +384,7 @@ module Ace
         # @return [String, nil] "owner/name" format or nil if not a GitHub repo
         def self.discover_repo_from_remote(options = {})
           timeout = options[:timeout] || 10
-          result = Ace::Git::Molecules::GhCliExecutor.execute(
+          result = Ace::Git::Github::CliExecutor.execute(
             "repo",
             ["view", "--json", "owner,name"],
             timeout: timeout
@@ -396,7 +397,7 @@ module Ace
           return nil unless owner && name
 
           "#{owner}/#{name}"
-        rescue JSON::ParserError, StandardError
+        rescue
           nil
         end