ace-review 0.49.0

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

@@ -0,0 +1,216 @@
+# frozen_string_literal: true
+
+require "yaml"
+
+module Ace
+  module Review
+    module Models
+      # Represents a single feedback item from a code review.
+      #
+      # FeedbackItem is an immutable data structure containing all information
+      # about a review finding, including its status, priority, and resolution.
+      #
+      # @example Creating a feedback item (multiple reviewers with consensus)
+      #   item = FeedbackItem.new(
+      #     id: "8o7abcd123",
+      #     title: "Missing error handling",
+      #     files: ["src/handlers/user.rb:42-55"],
+      #     reviewers: ["google:gemini-2.5-flash", "anthropic:claude-3.5-sonnet", "openai:gpt-4"],
+      #     status: "pending",
+      #     priority: "high",
+      #     consensus: true,
+      #     finding: "The error handling is incomplete..."
+      #   )
+      #
+      # @example Creating a modified copy
+      #   resolved_item = item.dup_with(status: "done", resolution: "Added try-catch block")
+      #
+      class FeedbackItem
+        # Valid status values for feedback items
+        VALID_STATUSES = %w[draft pending invalid skip done].freeze
+
+        # Valid priority values for feedback items
+        VALID_PRIORITIES = %w[critical high medium low].freeze
+
+        # Minimum number of reviewers for consensus
+        CONSENSUS_THRESHOLD = 3
+
+        attr_reader :id, :title, :files, :reviewers, :status, :priority,
+          :created, :updated, :finding, :context, :research, :resolution, :consensus
+
+        # Initialize a new FeedbackItem from a hash of attributes
+        #
+        # @param attrs [Hash] Attributes for the feedback item
+        # @option attrs [String] :id 10-character Base36 ID (6-char timestamp + 4-char random)
+        # @option attrs [String] :title Short description of the finding
+        # @option attrs [Array<String>] :files File references (path:line-range format)
+        # @option attrs [Array<String>] :reviewers LLM models that found this
+        # @option attrs [String] :reviewer Single reviewer string (converted to reviewers array)
+        # @option attrs [String] :status One of: draft, pending, invalid, skip, done
+        # @option attrs [String] :priority One of: critical, high, medium, low
+        # @option attrs [Boolean] :consensus True if 3+ models agree on this finding
+        # @option attrs [String] :created ISO8601 timestamp
+        # @option attrs [String] :updated ISO8601 timestamp
+        # @option attrs [String] :finding Original finding text
+        # @option attrs [String, nil] :context Additional context (optional)
+        # @option attrs [String, nil] :research Verification research (optional)
+        # @option attrs [String, nil] :resolution How it was resolved (optional)
+        # @raise [ArgumentError] If status or priority values are invalid
+        def initialize(attrs = {})
+          # Support both symbol and string keys
+          attrs = symbolize_keys(attrs)
+
+          @id = attrs[:id]
+          @title = attrs[:title]
+          @files = Array(attrs[:files])
+
+          @reviewers = normalize_reviewers(attrs[:reviewers], attrs[:reviewer])
+
+          @status = attrs[:status] || "draft"
+          @priority = attrs[:priority] || "medium"
+          @created = attrs[:created] || Time.now.utc.iso8601
+          @updated = attrs[:updated] || @created
+          @finding = attrs[:finding]
+          @context = attrs[:context]
+          @research = attrs[:research]
+          @resolution = attrs[:resolution]
+
+          # Consensus: true if 3+ models agree (can be explicitly set or computed)
+          @consensus = attrs.key?(:consensus) ? attrs[:consensus] : (@reviewers.length >= CONSENSUS_THRESHOLD)
+
+          validate!
+          freeze_arrays
+        end
+
+        # Accessor for single reviewer (returns first reviewer)
+        # @return [String, nil] First reviewer or nil if none
+        def reviewer
+          @reviewers.first
+        end
+
+        # Convert the feedback item to a hash
+        #
+        # @return [Hash] Hash representation with string keys
+        def to_h
+          hash = {
+            "id" => id,
+            "title" => title,
+            "files" => files.dup,
+            "status" => status,
+            "priority" => priority,
+            "created" => created,
+            "updated" => updated,
+            "finding" => finding,
+            "context" => context,
+            "research" => research,
+            "resolution" => resolution
+          }
+
+          # Use reviewers array if multiple reviewers, otherwise use singular reviewer key
+          if @reviewers.length > 1
+            hash["reviewers"] = @reviewers.dup
+            hash["consensus"] = consensus if consensus
+          else
+            hash["reviewer"] = reviewer
+          end
+
+          hash.compact
+        end
+
+        # Convert the feedback item to YAML
+        #
+        # @return [String] YAML representation
+        def to_yaml
+          to_h.to_yaml
+        end
+
+        # Create a new FeedbackItem with modified attributes
+        #
+        # @param changes [Hash] Attributes to change
+        # @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
+          FeedbackItem.new(to_h.merge(stringify_keys(changes)))
+        end
+
+        # Check if two feedback items are equal
+        #
+        # @param other [FeedbackItem] Other item to compare
+        # @return [Boolean] True if equal
+        def ==(other)
+          return false unless other.is_a?(FeedbackItem)
+
+          id == other.id &&
+            title == other.title &&
+            files == other.files &&
+            reviewers == other.reviewers &&
+            status == other.status &&
+            priority == other.priority &&
+            finding == other.finding
+        end
+
+        alias_method :eql?, :==
+
+        # Hash code for use in hash tables
+        #
+        # @return [Integer] Hash code
+        def hash
+          [id, title, files, reviewers, status, priority, finding].hash
+        end
+
+        private
+
+        # Validate status and priority values
+        #
+        # @raise [ArgumentError] If values are invalid
+        def validate!
+          unless VALID_STATUSES.include?(status)
+            raise ArgumentError, "Invalid status '#{status}'. Must be one of: #{VALID_STATUSES.join(", ")}"
+          end
+
+          unless VALID_PRIORITIES.include?(priority)
+            raise ArgumentError, "Invalid priority '#{priority}'. Must be one of: #{VALID_PRIORITIES.join(", ")}"
+          end
+        end
+
+        # Freeze array attributes to ensure immutability
+        def freeze_arrays
+          @files.freeze
+          @reviewers.freeze
+        end
+
+        # Normalize reviewers from various input formats
+        #
+        # @param reviewers [Array<String>, nil] Reviewers array
+        # @param reviewer [String, nil] Single reviewer string
+        # @return [Array<String>] Normalized reviewers array
+        def normalize_reviewers(reviewers, reviewer)
+          if reviewers.is_a?(Array) && reviewers.any?
+            reviewers.map(&:to_s).reject(&:empty?)
+          elsif reviewer && !reviewer.to_s.empty?
+            [reviewer.to_s]
+          else
+            []
+          end
+        end
+
+        # Convert hash keys to symbols
+        #
+        # @param hash [Hash] Hash with string or symbol keys
+        # @return [Hash] Hash with symbol keys
+        def symbolize_keys(hash)
+          hash.transform_keys(&:to_sym)
+        end
+
+        # Convert hash keys to strings
+        #
+        # @param hash [Hash] Hash with string or symbol keys
+        # @return [Hash] Hash with string keys
+        def stringify_keys(hash)
+          hash.transform_keys(&:to_s)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,208 @@
+# frozen_string_literal: true
+
+module Ace
+  module Review
+    module Models
+      # Options for code review execution
+      class ReviewOptions
+        attr_accessor :preset, :output_dir, :output, :context, :subject,
+          :prompt_base, :prompt_format, :prompt_focus, :add_focus,
+          :prompt_guidelines, :model, :models, :dry_run, :verbose,
+          :auto_execute, :save_session, :session_dir,
+          :pr, :post_comment, :pr_metadata, :gh_timeout,
+          :pr_comments, :pr_comment_data,
+          :no_feedback, :feedback_model,
+          :list_presets, :list_prompts, :help
+
+        def initialize(hash = {})
+          # Core options
+          @preset = hash[:preset] || Ace::Review.get("defaults", "preset")
+          @output_dir = hash[:output_dir]
+          @output = hash[:output]
+
+          # Context and subject
+          @context = hash[:context]
+          @subject = hash[:subject]
+
+          # Prompt composition overrides
+          @prompt_base = hash[:prompt_base]
+          @prompt_format = hash[:prompt_format]
+          @prompt_focus = hash[:prompt_focus]
+          @add_focus = hash[:add_focus]
+          @prompt_guidelines = hash[:prompt_guidelines]
+
+          # Execution options
+          @model = hash[:model]
+          @models = hash[:models]
+          @dry_run = hash[:dry_run] || false
+          @verbose = hash[:verbose] || false
+          @auto_execute = if @dry_run
+            false
+          elsif hash[:auto_execute].nil?
+            Ace::Review.get("defaults", "auto_execute") || false
+          else
+            hash[:auto_execute]
+          end
+
+          # Session options
+          @save_session = hash.fetch(:save_session, true)
+          @session_dir = hash[:session_dir]
+
+          # PR review options
+          @pr = hash[:pr]
+          @post_comment = hash[:post_comment] || false
+          @pr_metadata = hash[:pr_metadata]
+          @gh_timeout = hash[:gh_timeout]
+
+          # PR comment options
+          @pr_comments = hash[:pr_comments]  # nil = use default, true/false = explicit
+          @pr_comment_data = nil  # Populated during execution
+
+          # Feedback extraction options
+          @no_feedback = hash[:no_feedback] || false
+          @feedback_model = hash[:feedback_model]
+
+          # List commands
+          @list_presets = hash[:list_presets] || false
+          @list_prompts = hash[:list_prompts] || false
+          @help = hash[:help] || false
+        end
+
+        # Convert back to hash for compatibility
+        def to_h
+          instance_variables.each_with_object({}) do |var, hash|
+            key = var.to_s.delete_prefix("@").to_sym
+            value = instance_variable_get(var)
+            hash[key] = value unless value.nil?
+          end
+        end
+
+        # Check if this is a list command
+        def list_command?
+          list_presets || list_prompts || help
+        end
+
+        # Check if this is a PR review
+        def pr_review?
+          !pr.nil? && !pr.to_s.strip.empty?
+        end
+
+        # Check if comment posting should be triggered (includes dry-run preview)
+        def should_post_comment?
+          pr_review? && post_comment
+        end
+
+        # Check if PR comments should be included as feedback source
+        # Enabled by default for PR reviews, can be disabled with --no-pr-comments
+        def include_pr_comments?
+          return false unless pr_review?
+
+          # Explicit flag overrides everything
+          return pr_comments unless pr_comments.nil?
+
+          # Check config default (defaults to true for PR reviews)
+          config_default = Ace::Review.get("defaults", "pr_comments")
+          config_default.nil? || config_default
+        end
+
+        # Check if output should be saved
+        def save_output?
+          !dry_run && save_session
+        end
+
+        # Check if feedback extraction is enabled
+        def feedback_enabled?
+          !@no_feedback
+        end
+
+        # Get effective model (single model)
+        # Priority: model scalar > first model in models array > config_model > default
+        def effective_model(config_model = nil)
+          return model if model
+          return models.first if models&.any?
+          config_model || "google:gemini-2.5-flash"
+        end
+
+        # Get effective models array
+        # Returns array of models, handling both single model and multi-model cases
+        # Priority: models array > model scalar > config_models > default
+        def effective_models(config_models = nil)
+          # If models array is set (from CLI), use it
+          return models if models&.any?
+
+          # If model scalar is set, wrap in array
+          return [model] if model
+
+          # If config provides models array, use it
+          if config_models.is_a?(Array) && config_models.any?
+            return config_models
+          end
+
+          # If config provides single model, wrap in array
+          if config_models.is_a?(String) && !config_models.empty?
+            return [config_models]
+          end
+
+          # Default to single model
+          ["google:gemini-2.5-flash"]
+        end
+
+        # Merge with config values
+        def merge_config(config)
+          return if config.nil?
+
+          # Merge system prompt configuration if not overridden
+          @prompt_base ||= config.dig("system_prompt", "base")
+          @prompt_format ||= config.dig("system_prompt", "format")
+
+          # Handle focus modules
+          if @add_focus && config.dig("system_prompt", "focus")
+            existing_focus = config.dig("system_prompt", "focus") || []
+            additional_focus = @add_focus.split(",").map(&:strip)
+            @prompt_focus = (existing_focus + additional_focus).uniq.join(",")
+          elsif !@prompt_focus && config.dig("system_prompt", "focus")
+            @prompt_focus = Array(config.dig("system_prompt", "focus")).join(",")
+          end
+
+          @prompt_guidelines ||= Array(config.dig("system_prompt", "guidelines")).join(",") if config.dig("system_prompt", "guidelines")
+
+          # Merge other config values
+          @context ||= config["context"]
+          @subject ||= config["subject"]
+
+          # Handle models from config
+          # CLI models override preset models
+          unless @models&.any?
+            if config["models"].is_a?(Array) && config["models"].any?
+              @models = config["models"]
+            elsif config["model"]
+              @model ||= config["model"]
+            end
+          end
+
+          @gh_timeout ||= config["gh_timeout"]
+
+          self
+        end
+
+        # Build system prompt composition hash
+        def system_prompt_composition
+          composition = {}
+
+          composition["base"] = prompt_base if prompt_base
+          composition["format"] = prompt_format if prompt_format
+
+          if prompt_focus
+            composition["focus"] = prompt_focus.split(",").map(&:strip)
+          end
+
+          if prompt_guidelines
+            composition["guidelines"] = prompt_guidelines.split(",").map(&:strip)
+          end
+
+          composition.empty? ? nil : composition
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,181 @@
+# frozen_string_literal: true
+
+module Ace
+  module Review
+    module Models
+      # Represents a configured reviewer entity with focus areas and filtering capabilities.
+      #
+      # Reviewers are configured entities that transform from simple model names to
+      # full-featured review participants with focus areas, file filtering, and
+      # weighted contributions.
+      #
+      # @example Creating a reviewer from config
+      #   reviewer = Reviewer.new(
+      #     name: "code-fit",
+      #     model: "google:gemini-2.5-pro",
+      #     focus: "code_quality",
+      #     system_prompt_additions: "Focus on SOLID principles...",
+      #     file_patterns: { include: ["lib/**/*.rb"], exclude: ["**/*_test.rb"] },
+      #     weight: 1.0,
+      #     critical: false
+      #   )
+      #
+      class Reviewer
+        # Default weight for reviewers (1.0 = full contribution)
+        DEFAULT_WEIGHT = 1.0
+
+        attr_reader :name, :model, :focus, :system_prompt_additions,
+          :file_patterns, :weight, :critical
+
+        # Initialize a new Reviewer from a configuration hash
+        #
+        # @param config [Hash] Configuration hash with reviewer settings
+        # @option config [String] :name Human-readable name for the reviewer
+        # @option config [String] :model LLM model identifier (e.g., "google:gemini-2.5-pro")
+        # @option config [String] :focus Review focus area (e.g., "code_quality", "security")
+        # @option config [String] :system_prompt_additions Additional system prompt text
+        # @option config [Hash] :file_patterns File filtering patterns
+        # @option config [Float] :weight Contribution weight (0.0-1.0, default: 1.0)
+        # @option config [Boolean] :critical Whether findings are always highlighted
+        def initialize(config = {})
+          # Support both symbol and string keys
+          config = normalize_keys(config)
+
+          @name = config["name"]
+          @model = config["model"]
+          @focus = config["focus"]
+          @system_prompt_additions = config["system_prompt_additions"]
+          @file_patterns = normalize_file_patterns(config["file_patterns"])
+          @weight = (config["weight"] || DEFAULT_WEIGHT).to_f
+          @critical = config["critical"] || false
+
+          validate!
+        end
+
+        # Create Reviewers from preset config (new reviewers array format)
+        #
+        # @param config [Hash] Preset configuration
+        # @return [Array<Reviewer>] Array of reviewer instances
+        def self.from_preset_config(config)
+          config = normalize_hash_keys(config)
+
+          # New format: reviewers array
+          if config["reviewers"].is_a?(Array) && config["reviewers"].any?
+            return config["reviewers"].map { |r| new(r) }
+          end
+
+          []
+        end
+
+        # Filter subject content based on reviewer's file patterns
+        #
+        # Delegates to SubjectFilter molecule for actual filtering logic.
+        #
+        # @param subject [Hash] Subject configuration with files/diff/content
+        # @return [Hash] Filtered subject (deep copy with only matching content)
+        def filter_subject(subject)
+          Molecules::SubjectFilter.filter(subject, file_patterns)
+        end
+
+        # Enhance system prompt with reviewer's additions
+        #
+        # @param base_prompt [String] Original system prompt
+        # @return [String] Enhanced prompt with reviewer additions
+        def enhance_system_prompt(base_prompt)
+          return base_prompt unless system_prompt_additions
+          return system_prompt_additions if base_prompt.nil? || base_prompt.empty?
+
+          "#{base_prompt}\n\n#{system_prompt_additions}"
+        end
+
+        # Check if this reviewer has file patterns configured
+        #
+        # Delegates to SubjectFilter molecule.
+        #
+        # @return [Boolean] True if file patterns are configured
+        def has_file_patterns?
+          Molecules::SubjectFilter.has_patterns?(file_patterns)
+        end
+
+        # Check if a file path matches this reviewer's patterns
+        #
+        # Delegates to SubjectFilter molecule.
+        #
+        # @param file_path [String] File path to check
+        # @return [Boolean] True if file matches (or no patterns configured)
+        def matches_file?(file_path)
+          Molecules::SubjectFilter.matches_file?(file_path, file_patterns)
+        end
+
+        # Convert to hash representation
+        #
+        # @return [Hash] Hash with string keys
+        def to_h
+          {
+            "name" => name,
+            "model" => model,
+            "focus" => focus,
+            "system_prompt_additions" => system_prompt_additions,
+            "file_patterns" => file_patterns,
+            "weight" => weight,
+            "critical" => critical
+          }.compact
+        end
+
+        # Check equality with another reviewer
+        #
+        # @param other [Reviewer] Other reviewer to compare
+        # @return [Boolean] True if equal
+        def ==(other)
+          return false unless other.is_a?(Reviewer)
+
+          name == other.name &&
+            model == other.model &&
+            focus == other.focus &&
+            weight == other.weight &&
+            critical == other.critical
+        end
+
+        alias_method :eql?, :==
+
+        # Hash code for use in hash tables
+        #
+        # @return [Integer] Hash code
+        def hash
+          [name, model, focus, weight, critical].hash
+        end
+
+        private
+
+        # Validate required fields
+        def validate!
+          raise ArgumentError, "Reviewer model is required" if model.nil? || model.to_s.strip.empty?
+          raise ArgumentError, "Reviewer weight must be between 0 and 1" if weight < 0 || weight > 1
+        end
+
+        # Normalize hash keys to strings (supports both symbol and string keys)
+        def normalize_keys(hash)
+          return {} unless hash.is_a?(Hash)
+          hash.transform_keys(&:to_s)
+        end
+
+        # Class method for key normalization
+        def self.normalize_hash_keys(hash)
+          return {} unless hash.is_a?(Hash)
+          hash.transform_keys(&:to_s)
+        end
+
+        # Normalize file patterns structure
+        def normalize_file_patterns(patterns)
+          return nil unless patterns.is_a?(Hash)
+
+          normalized = normalize_keys(patterns)
+          {
+            "include" => Array(normalized["include"]),
+            "exclude" => Array(normalized["exclude"])
+          }
+        end
+      end
+    end
+  end
+end