ace-review 0.49.0

data/lib/ace/review/atoms/context_limit_resolver.rb

@@ -0,0 +1,162 @@
+# frozen_string_literal: true
+
+module Ace
+  module Review
+    module Atoms
+      # Pure function for resolving model context limits
+      #
+      # Maps model names to their context window sizes. Handles provider prefixes
+      # (google:, anthropic:, openai:) and uses pattern matching for model families.
+      #
+      # Resolution order:
+      # 1. ace-llm provider config (context_limit in providers/*.yml)
+      # 2. Hardcoded pattern matching (MODEL_LIMITS)
+      # 3. Conservative default for unknown models
+      #
+      # @example Basic usage
+      #   ContextLimitResolver.resolve("google:gemini-2.5-pro")
+      #   #=> 1_000_000
+      #
+      # @example Without provider prefix
+      #   ContextLimitResolver.resolve("claude-3-sonnet")
+      #   #=> 200_000
+      module ContextLimitResolver
+        # Conservative default for unknown models
+        DEFAULT_LIMIT = 200_000
+
+        # Model patterns and their context limits (fallback when ace-llm config unavailable)
+        # Order matters - first match wins
+        # Patterns use regex for flexible matching
+        MODEL_LIMITS = [
+          # Gemini models
+          {pattern: /gemini-1\.5-pro/i, limit: 2_000_000},
+          {pattern: /gemini-1\.5-flash/i, limit: 1_000_000},
+          {pattern: /gemini-2\.5-pro/i, limit: 1_000_000},
+          {pattern: /gemini-2\.5-flash/i, limit: 1_000_000},
+          {pattern: /gemini-2\.0/i, limit: 1_000_000},
+          # Fallback for any other gemini model
+          {pattern: /gemini/i, limit: 1_000_000},
+
+          # Claude models (all variants: opus, sonnet, haiku)
+          {pattern: /claude.*opus/i, limit: 1_000_000},
+          {pattern: /claude.*sonnet/i, limit: 1_000_000},
+          {pattern: /claude.*haiku/i, limit: 1_000_000},
+          # Fallback for any other claude model
+          {pattern: /claude/i, limit: 1_000_000},
+
+          # OpenAI models
+          {pattern: /gpt-5\.\d/i, limit: 1_050_000},
+          {pattern: /o4-/i, limit: 1_050_000},
+          {pattern: /gpt-4o/i, limit: 128_000},
+          {pattern: /gpt-4-turbo/i, limit: 128_000},
+          {pattern: /gpt-4-32k/i, limit: 32_768},
+          {pattern: /gpt-4-\d+-preview/i, limit: 128_000}, # gpt-4-1106-preview, gpt-4-0125-preview
+          {pattern: /gpt-4-\d+$/i, limit: 8_192}, # legacy gpt-4-0613, etc.
+          {pattern: /gpt-4$/i, limit: 8_192}, # base gpt-4 model
+          {pattern: /o1-/i, limit: 200_000},
+          {pattern: /o3-/i, limit: 200_000}
+        ].freeze
+
+        # Resolve context limit for a model
+        #
+        # Resolution order:
+        # 1. ace-llm provider config (if available and provider specified)
+        # 2. Hardcoded pattern matching
+        # 3. Default limit
+        #
+        # @param model_name [String, nil] Model identifier, optionally with provider prefix
+        # @return [Integer] Context limit in tokens
+        #
+        # @example With provider prefix
+        #   ContextLimitResolver.resolve("google:gemini-2.5-pro")
+        #   #=> 1_000_000
+        #
+        # @example Without provider prefix
+        #   ContextLimitResolver.resolve("claude-3-opus")
+        #   #=> 200_000
+        #
+        # @example Unknown model
+        #   ContextLimitResolver.resolve("unknown-model")
+        #   #=> 128_000
+        def self.resolve(model_name)
+          return DEFAULT_LIMIT if model_name.nil? || model_name.empty?
+
+          # Try to get limit from ace-llm provider config first
+          limit = load_from_ace_llm(model_name)
+          return limit if limit
+
+          # Fall back to hardcoded pattern matching
+          normalized = strip_provider_prefix(model_name)
+          match = MODEL_LIMITS.find { |entry| normalized.match?(entry[:pattern]) }
+          match ? match[:limit] : DEFAULT_LIMIT
+        end
+
+        # Get the default limit for unknown models
+        #
+        # @return [Integer] Default context limit
+        def self.default_limit
+          DEFAULT_LIMIT
+        end
+
+        # Load context limit from ace-llm provider configuration
+        #
+        # @param model_name [String] Model identifier with provider prefix
+        # @return [Integer, nil] Context limit from config, or nil if not found
+        def self.load_from_ace_llm(model_name)
+          # Extract provider prefix (e.g., "google" from "google:gemini-2.5-pro")
+          return nil unless model_name.include?(":")
+
+          provider = model_name.split(":").first
+          return nil if provider.nil? || provider.empty?
+
+          # Try to load provider config via ace-llm
+          config = load_provider_config(provider)
+          return nil unless config
+
+          # Get context_limit from provider config
+          limit = config["context_limit"]
+          limit.is_a?(Integer) ? limit : nil
+        rescue
+          nil # Fall back to hardcoded on any error
+        end
+        private_class_method :load_from_ace_llm
+
+        # Load provider configuration from ace-llm
+        #
+        # @param provider [String] Provider name (e.g., "google", "anthropic")
+        # @return [Hash, nil] Provider config hash or nil
+        def self.load_provider_config(provider)
+          # Try to use ace-llm's config loader if available
+          return nil unless defined?(Ace::LLM::Molecules::ConfigLoader)
+
+          resolver = Ace::Support::Config.create(
+            config_dir: ".ace",
+            defaults_dir: ".ace-defaults",
+            gem_path: Ace::LLM::Molecules::ConfigLoader.gem_root
+          )
+
+          config = resolver.resolve_namespace("llm", filename: "providers/#{provider}")
+          config.to_h
+        rescue
+          nil
+        end
+        private_class_method :load_provider_config
+
+        # Strip provider prefix from model name
+        #
+        # @param model_name [String] Model identifier
+        # @return [String] Model name without provider prefix
+        #
+        # @example
+        #   strip_provider_prefix("google:gemini-2.5-pro")
+        #   #=> "gemini-2.5-pro"
+        def self.strip_provider_prefix(model_name)
+          # Common provider prefixes
+          model_name.sub(/\A(google|anthropic|openai|codex|cli):/, "")
+        end
+
+        private_class_method :strip_provider_prefix
+      end
+    end
+  end
+end

data/lib/ace/review/atoms/diff_boundary_finder.rb

@@ -0,0 +1,133 @@
+# frozen_string_literal: true
+
+module Ace
+  module Review
+    module Atoms
+      # Pure function for parsing unified diffs into file blocks
+      #
+      # Parses `diff --git` format diffs and extracts individual file blocks
+      # with their paths and content. Used by the chunked strategy to split
+      # large diffs at file boundaries.
+      #
+      # Thread-safe: This module uses only class methods with no mutable
+      # instance state. All methods are pure functions that can be safely
+      # called concurrently from multiple threads.
+      #
+      # @example Basic usage
+      #   blocks = DiffBoundaryFinder.parse(diff_text)
+      #   #=> [
+      #   #     { path: "lib/foo.rb", content: "diff --git...", lines: 45, change_type: :modified },
+      #   #     { path: "test/foo_test.rb", content: "diff --git...", lines: 30, change_type: :modified }
+      #   #   ]
+      module DiffBoundaryFinder
+        # Pattern to match the start of a file diff block
+        # Matches: diff --git a/path/to/file b/path/to/file
+        DIFF_HEADER_PATTERN = /^diff --git a\/(.+?) b\/(.+?)$/
+
+        # Pattern to detect new file mode
+        NEW_FILE_PATTERN = /^new file mode/
+
+        # Pattern to detect deleted file mode
+        DELETED_FILE_PATTERN = /^deleted file mode/
+
+        # Parse a unified diff into individual file blocks
+        #
+        # @param diff_text [String, nil] The unified diff text to parse
+        # @return [Array<Hash>] Array of file blocks, each with:
+        #   - :path [String] - File path (uses 'b/' side)
+        #   - :content [String] - Full diff content for this file
+        #   - :lines [Integer] - Number of lines in the diff block
+        #   - :change_type [Symbol] - :added, :deleted, or :modified
+        #
+        # @example
+        #   DiffBoundaryFinder.parse(diff)
+        #   #=> [{ path: "lib/foo.rb", content: "diff --git...", lines: 45, change_type: :modified }]
+        def self.parse(diff_text)
+          return [] if diff_text.nil? || diff_text.empty?
+
+          blocks = []
+          current_block = nil
+          current_lines = []
+
+          diff_text.each_line do |line|
+            if (match = DIFF_HEADER_PATTERN.match(line))
+              # Save the previous block if exists
+              if current_block
+                current_block[:content] = current_lines.join
+                current_block[:lines] = current_lines.length
+                blocks << current_block
+              end
+
+              # Start a new block
+              current_block = {
+                path: match[2],  # Use the 'b/' side (destination path)
+                content: "",
+                lines: 0,
+                change_type: :modified  # Default, may be updated below
+              }
+              current_lines = [line]
+            elsif current_block
+              current_lines << line
+
+              # Detect change type from mode lines
+              if NEW_FILE_PATTERN.match?(line)
+                current_block[:change_type] = :added
+              elsif DELETED_FILE_PATTERN.match?(line)
+                current_block[:change_type] = :deleted
+              end
+            end
+          end
+
+          # Don't forget the last block
+          if current_block
+            current_block[:content] = current_lines.join
+            current_block[:lines] = current_lines.length
+            blocks << current_block
+          end
+
+          blocks
+        end
+
+        # Parse and return just the file paths from a diff
+        #
+        # @param diff_text [String, nil] The unified diff text to parse
+        # @return [Array<String>] List of file paths in the diff
+        #
+        # @example
+        #   DiffBoundaryFinder.file_paths(diff)
+        #   #=> ["lib/foo.rb", "test/foo_test.rb"]
+        def self.file_paths(diff_text)
+          parse(diff_text).map { |block| block[:path] }
+        end
+
+        # Count the number of files in a diff
+        #
+        # @param diff_text [String, nil] The unified diff text
+        # @return [Integer] Number of files in the diff
+        #
+        # @example
+        #   DiffBoundaryFinder.file_count(diff)
+        #   #=> 5
+        def self.file_count(diff_text)
+          return 0 if diff_text.nil? || diff_text.empty?
+
+          diff_text.scan(DIFF_HEADER_PATTERN).length
+        end
+
+        # Group file blocks by directory
+        #
+        # @param blocks [Array<Hash>] Array of file blocks from #parse
+        # @return [Hash<String, Array<Hash>>] Files grouped by directory
+        #
+        # @example
+        #   DiffBoundaryFinder.group_by_directory(blocks)
+        #   #=> { "lib/atoms" => [...], "test/atoms" => [...] }
+        def self.group_by_directory(blocks)
+          blocks.group_by do |block|
+            File.dirname(block[:path])
+          end
+        end
+      end
+    end
+  end
+end

data/lib/ace/review/atoms/feedback_id_generator.rb

@@ -0,0 +1,66 @@
+# frozen_string_literal: true
+
+require "ace/b36ts"
+
+module Ace
+  module Review
+    module Atoms
+      # Generates unique 8-character Base36 IDs for feedback items.
+      #
+      # Uses ace-b36ts to generate timestamp-based IDs with
+      # millisecond precision that sort chronologically. This enables
+      # natural ordering of feedback items by creation time.
+      #
+      # @example Generate a new ID
+      #   FeedbackIdGenerator.generate
+      #   #=> "i50jj3ab"
+      #
+      # @example IDs are chronologically sortable
+      #   id1 = FeedbackIdGenerator.generate
+      #   sleep(0.1)
+      #   id2 = FeedbackIdGenerator.generate
+      #   id1 < id2 #=> true
+      #
+      class FeedbackIdGenerator
+        # Generate a new 8-character Base36 ID based on current timestamp
+        # with millisecond precision
+        #
+        # @return [String] 8-character Base36 ID (e.g., "i50jj3ab")
+        def self.generate
+          Ace::B36ts.encode(Time.now.utc, format: :ms)
+        end
+
+        # Generate a new ID for a specific time (useful for testing)
+        #
+        # @param time [Time] The time to encode
+        # @return [String] 8-character Base36 ID
+        def self.generate_for(time)
+          Ace::B36ts.encode(time.utc, format: :ms)
+        end
+
+        # Generate a sequence of unique, sequential IDs
+        #
+        # Uses ace-b36ts's encode_sequence to generate IDs that are
+        # guaranteed unique even when created in rapid succession. Each ID is
+        # strictly greater than the previous (lexicographically).
+        #
+        # @param count [Integer] Number of IDs to generate
+        # @return [Array<String>] Array of unique 8-character Base36 IDs
+        # @raise [ArgumentError] If count <= 0
+        #
+        # @example Generate 5 unique IDs
+        #   ids = FeedbackIdGenerator.generate_sequence(5)
+        #   ids.length #=> 5
+        #   ids.uniq.length #=> 5  # All unique
+        #   ids == ids.sort #=> true  # Already sorted
+        def self.generate_sequence(count)
+          Ace::B36ts::Atoms::CompactIdEncoder.encode_sequence(
+            Time.now.utc,
+            count: count,
+            format: :ms
+          )
+        end
+      end
+    end
+  end
+end

data/lib/ace/review/atoms/feedback_slug_generator.rb

@@ -0,0 +1,61 @@
+# frozen_string_literal: true
+
+module Ace
+  module Review
+    module Atoms
+      # Generates URL-safe slugs from feedback item titles.
+      #
+      # Creates slugs suitable for use in filenames and URLs, handling
+      # edge cases like unicode, special characters, and length limits.
+      #
+      # @example Basic usage
+      #   FeedbackSlugGenerator.generate("Missing error handling")
+      #   #=> "missing-error-handling"
+      #
+      # @example Long titles are truncated
+      #   FeedbackSlugGenerator.generate("A very long title that exceeds forty characters limit")
+      #   #=> "a-very-long-title-that-exceeds-forty" (truncated to 40 chars)
+      #
+      # @example Unicode is transliterated or removed
+      #   FeedbackSlugGenerator.generate("Fix bug in caf\u00e9 module")
+      #   #=> "fix-bug-in-caf-module"
+      #
+      class FeedbackSlugGenerator
+        DEFAULT_MAX_LENGTH = 40
+
+        # Generate a URL-safe slug from a title
+        #
+        # @param title [String] The title to convert to a slug
+        # @param max_length [Integer] Maximum slug length (default: 40)
+        # @return [String] URL-safe slug
+        #
+        # @example Basic title
+        #   FeedbackSlugGenerator.generate("Fix authentication bug")
+        #   #=> "fix-authentication-bug"
+        #
+        # @example With special characters
+        #   FeedbackSlugGenerator.generate("Add try/catch block (urgent!)")
+        #   #=> "add-try-catch-block-urgent"
+        #
+        # @example Empty or nil input
+        #   FeedbackSlugGenerator.generate(nil)
+        #   #=> ""
+        #   FeedbackSlugGenerator.generate("")
+        #   #=> ""
+        def self.generate(title, max_length: DEFAULT_MAX_LENGTH)
+          return "" if title.nil? || title.empty?
+
+          title
+            .unicode_normalize(:nfkd)           # Decompose unicode (e.g., é -> e + combining accent)
+            .encode("ASCII", undef: :replace, replace: "") # Strip non-ASCII
+            .gsub(/[^a-zA-Z0-9\-_\s]/, "")      # Remove special chars (keep spaces for now)
+            .gsub(/[\s_]+/, "-").squeeze("-")                     # Collapse consecutive hyphens
+            .gsub(/\A-|-\z/, "")                 # Remove leading/trailing hyphens
+            .downcase
+            .slice(0, max_length)                # Truncate to max length
+            .gsub(/-\z/, "")                     # Remove trailing hyphen after truncation
+        end
+      end
+    end
+  end
+end

data/lib/ace/review/atoms/feedback_state_validator.rb

@@ -0,0 +1,98 @@
+# frozen_string_literal: true
+
+module Ace
+  module Review
+    module Atoms
+      # Validates state transitions for feedback items.
+      #
+      # Implements the feedback item state machine:
+      #   draft -> (verify valid=true) -> pending -> (resolve) -> done [archived]
+      #   draft -> (verify valid=false) -> invalid [archived]
+      #   draft -> (skip) -> skip [archived]
+      #   pending -> (skip) -> skip [archived]
+      #
+      # Terminal states (invalid, skip, done) cannot transition further.
+      #
+      # @example Check if a transition is valid
+      #   FeedbackStateValidator.valid_transition?("draft", "pending")
+      #   #=> true
+      #
+      #   FeedbackStateValidator.valid_transition?("done", "pending")
+      #   #=> false
+      #
+      # @example Get allowed transitions from a status
+      #   FeedbackStateValidator.allowed_transitions("draft")
+      #   #=> ["pending", "invalid", "skip"]
+      #
+      class FeedbackStateValidator
+        # Define the state machine transitions
+        # Maps from_status => [allowed target statuses]
+        TRANSITIONS = {
+          "draft" => %w[pending invalid skip],
+          "pending" => %w[done skip],
+          "invalid" => [],  # Terminal state
+          "skip" => [],     # Terminal state
+          "done" => []      # Terminal state
+        }.freeze
+
+        # Terminal states that require archiving
+        TERMINAL_STATES = %w[invalid skip done].freeze
+
+        # Check if a state transition is valid
+        #
+        # @param from_status [String] Current status
+        # @param to_status [String] Target status
+        # @return [Boolean] True if the transition is allowed
+        #
+        # @example Valid transition
+        #   FeedbackStateValidator.valid_transition?("draft", "pending")
+        #   #=> true
+        #
+        # @example Invalid transition
+        #   FeedbackStateValidator.valid_transition?("draft", "done")
+        #   #=> false
+        def self.valid_transition?(from_status, to_status)
+          allowed = TRANSITIONS[from_status]
+          return false if allowed.nil?
+
+          allowed.include?(to_status)
+        end
+
+        # Get the list of allowed target statuses from a given status
+        #
+        # @param status [String] Current status
+        # @return [Array<String>] List of valid target statuses (empty for terminal states)
+        #
+        # @example
+        #   FeedbackStateValidator.allowed_transitions("draft")
+        #   #=> ["pending", "invalid", "skip"]
+        def self.allowed_transitions(status)
+          TRANSITIONS.fetch(status, []).dup
+        end
+
+        # Check if a status is terminal (requires archiving, no further transitions)
+        #
+        # @param status [String] Status to check
+        # @return [Boolean] True if status is terminal
+        #
+        # @example
+        #   FeedbackStateValidator.terminal?("done")
+        #   #=> true
+        #
+        #   FeedbackStateValidator.terminal?("pending")
+        #   #=> false
+        def self.terminal?(status)
+          TERMINAL_STATES.include?(status)
+        end
+
+        # Check if a status requires archiving
+        #
+        # @param status [String] Status to check
+        # @return [Boolean] True if items with this status should be archived
+        def self.should_archive?(status)
+          terminal?(status)
+        end
+      end
+    end
+  end
+end