ace-review 0.49.0

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

@@ -0,0 +1,378 @@
+# frozen_string_literal: true
+
+require "pathname"
+
+module Ace
+  module Review
+    module CLI
+      module Commands
+        # ace-support-cli Command class for the review command
+        #
+        # Executes code review using presets or custom configuration.
+        class Review < Ace::Support::Cli::Command
+          include Ace::Support::Cli::Base
+
+          desc <<~DESC.strip
+            Execute code review using presets or custom configuration
+
+            Presets provide pre-configured review types with focused prompts:
+              code         → General code review
+              code-pr      → PR-focused code review
+              security     → Security-focused review
+              performance  → Performance-focused review
+              docs         → Documentation review
+
+            Configuration:
+              Global config:  ~/.ace/review/config.yml
+              Project config: .ace/review/config.yml
+              Example:        ace-review/.ace-defaults/review/config.yml
+
+            Presets configured via review.presets
+          DESC
+
+          example [
+            "--preset code-pr             # PR code review",
+            "--preset security --auto-execute  # Run and apply fixes",
+            "--pr 123                      # Review by PR number",
+            "--preset code --subject diff:HEAD~3 --subject files:docs/**/*.md",
+            "--preset security --dry-run   # Preview without executing"
+          ]
+
+          # Review configuration options
+          option :preset, type: :string, desc: "Review preset from configuration"
+          option :output_dir, type: :string, desc: "Custom output directory for review"
+          option :output, type: :string, desc: "Specific output file path"
+          option :context, type: :string, desc: "Context configuration (preset name or YAML)"
+          option :subject, type: :array, desc: "Subject configuration (can be specified multiple times)"
+          option :prompt_base, type: :string, desc: "Base prompt module"
+          option :prompt_format, type: :string, desc: "Format module"
+          option :prompt_focus, type: :string, desc: "Focus modules (comma-separated)"
+          option :add_focus, type: :string, desc: "Add focus modules to preset"
+          option :prompt_guidelines, type: :string, desc: "Guideline modules (comma-separated)"
+          option :model, type: :array, desc: "LLM model(s) to use (can be specified multiple times)"
+          option :no_feedback, type: :boolean, desc: "Skip feedback extraction from review reports"
+          option :feedback_model, type: :string, desc: "Model to use for feedback extraction"
+          option :dry_run, type: :boolean, desc: "Prepare review without executing"
+          option :auto_execute, type: :boolean, default: nil, desc: "Execute LLM query automatically"
+          option :save_session, type: :boolean, desc: "Save session files (default: true)"
+          option :session_dir, type: :string, desc: "Custom session directory"
+          option :pr, type: :string, desc: "Review GitHub PR (number, URL, or owner/repo#number)"
+          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)"
+
+          # Standard options
+          option :version, type: :boolean, desc: "Show version information"
+          option :list_presets, type: :boolean, desc: "List available review presets"
+          option :list_prompts, type: :boolean, desc: "List available prompt modules"
+          option :quiet, type: :boolean, aliases: %w[-q], desc: "Suppress non-essential output"
+          option :verbose, type: :boolean, aliases: %w[-v], desc: "Show verbose output"
+          option :debug, type: :boolean, aliases: %w[-d], desc: "Show debug output"
+
+          attr_reader :options
+
+          def call(**cli_options)
+            # Remove ace-support-cli specific keys (args is leftover arguments)
+            cli_options = cli_options.reject { |k, _| k == :args }
+
+            if cli_options[:version]
+              puts "ace-review #{Ace::Review::VERSION}"
+              return
+            end
+
+            if cli_options[:list_presets]
+              show_list_presets
+              return
+            end
+
+            if cli_options[:list_prompts]
+              show_list_prompts
+              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]
+
+            # Build and store options for testing compatibility
+            @options = build_review_options(cli_options)
+
+            execute_review
+          end
+
+          private
+
+          def execute_review
+            display_config_summary
+
+            # Convert options hash to ReviewOptions object
+            review_options = Models::ReviewOptions.new(@options)
+
+            puts "Analyzing code with preset '#{review_options.preset}'..." if review_options.verbose
+
+            manager = Organisms::ReviewManager.new
+            result = manager.execute_review(review_options)
+
+            if result[:success]
+              handle_success(result, review_options)
+            else
+              handle_error(result)
+            end
+          rescue => e
+            raise Ace::Support::Cli::Error.new(e.message)
+          end
+
+          def build_review_options(cli_options)
+            # Start with CLI options
+            options = cli_options.dup
+
+            # Handle repeatable options
+            process_subjects(options)
+            process_models(options)
+
+            # Set defaults
+            options[:save_session] = true unless options.key?(:save_session)
+
+            options
+          end
+
+          def process_subjects(options)
+            return unless options[:subject]
+
+            # Handle both array input (from tests/API) and string input (from CLI)
+            # CLI uses ARRAY_SEPARATOR (\x1F) to preserve internal commas in subjects
+            subjects = Array(options[:subject]).flat_map do |s|
+              s.to_s.split(CLI::ARRAY_SEPARATOR)
+            end.compact.map(&:strip).reject(&:empty?)
+
+            if subjects.any?
+              # Deduplicate subjects (order preserved)
+              subjects.uniq!
+              # Single value: pass as-is, Multiple: pass as array
+              options[:subject] = (subjects.size == 1) ? subjects.first : subjects
+            else
+              options.delete(:subject)
+            end
+          end
+
+          def process_models(options)
+            return unless options[:model]
+
+            # ace-support-cli's array option gives us an array
+            models = Array(options[:model]).compact.map(&:strip).reject(&:empty?)
+
+            if models.any?
+              # Also split comma-separated values
+              models = models.flat_map { |m| m.split(",").map(&:strip).reject(&:empty?) }
+              # Deduplicate and validate
+              models.uniq!
+              validate_model_names(models)
+              # Store in :models (array) not :model (expects string)
+              options[:models] = models
+              options.delete(:model)
+            else
+              options.delete(:model)
+            end
+          end
+
+          def validate_model_names(models)
+            models.each do |model|
+              unless model.match?(/\A[a-zA-Z0-9\-_:.@]+\z/)
+                raise ArgumentError, "Invalid model name '#{model}'. Model names can only contain alphanumeric characters, hyphens, underscores, colons, and dots."
+              end
+            end
+          end
+
+          def handle_success(result, review_options)
+            # Handle multi-model results
+            if result[:summary]
+              handle_multi_model_success(result)
+              return
+            end
+
+            # Display review saved/prepared message
+            if result[:output_file]
+              puts "✓ Review saved: #{result[:output_file]}"
+            elsif result[:session_dir]
+              puts "✓ Review session prepared: #{result[:session_dir]}"
+
+              # Display prompt files for ace-bundle workflow
+              if result[:system_prompt_file] && result[:user_prompt_file]
+                puts "  System prompt: #{result[:system_prompt_file]}"
+                puts "  User prompt: #{result[:user_prompt_file]}"
+
+                unless @options[:dry_run]
+                  puts
+                  puts "To execute with LLM:"
+                  puts "  ace-llm --file #{result[:user_prompt_file]} --context #{result[:system_prompt_file]}"
+                end
+              elsif result[:prompt_file]
+                puts "  Prompt: #{result[:prompt_file]}"
+                unless @options[:dry_run]
+                  puts
+                  puts "To execute with LLM:"
+                  puts "  ace-llm --file #{result[:prompt_file]}"
+                end
+              end
+            end
+
+            # Display comment posting results
+            if result[:comment_url]
+              puts "✓ Review posted to PR: #{result[:comment_url]}"
+            elsif result[:comment_error]
+              puts "✗ Failed to post comment: #{result[:comment_error]}"
+              puts "  (Review saved locally - you can post manually)"
+            end
+
+            # Display dry-run preview
+            if result[:dry_run_preview]
+              puts
+              puts "=== Comment Preview (Dry Run) ==="
+              puts result[:dry_run_preview]
+              puts "=== End Preview ==="
+            end
+          end
+
+          def handle_multi_model_success(result)
+            puts
+            puts "Reviews saved (#{result[:summary][:success_count]} of #{result[:summary][:total_models]} succeeded):"
+            puts "  Session directory: #{result[:session_dir]}"
+            puts
+
+            if result[:output_files]&.any?
+              result[:output_files].each do |file|
+                puts "  ✓ #{File.basename(file)}"
+              end
+            end
+
+            if result[:failed_models]&.any?
+              puts
+              puts "Failed models:"
+              result[:failed_models].each do |model|
+                puts "  ✗ #{model}"
+              end
+            end
+
+            puts
+            puts "Total duration: #{result[:summary][:total_duration]}s"
+
+            if result[:feedback_count]
+              puts
+              puts "Feedback: #{result[:feedback_count]} items extracted"
+            elsif result[:feedback_error]
+              puts
+              puts "Feedback extraction failed: #{result[:feedback_error]}"
+            end
+          end
+
+          def handle_error(result)
+            raise Ace::Support::Cli::Error.new(result[:error])
+          end
+
+          def display_config_summary
+            return if @options[:quiet]
+
+            require "ace/core"
+            Ace::Core::Atoms::ConfigSummary.display(
+              command: "review",
+              config: Ace::Review.config,
+              defaults: load_defaults,
+              options: @options,
+              quiet: false
+            )
+          end
+
+          def show_list_presets
+            manager = Organisms::ReviewManager.new
+
+            presets = manager.list_presets
+            if presets.empty?
+              puts "No presets found"
+              puts "Create presets in .ace/review/config.yml or .ace/review/presets/"
+              return
+            end
+
+            puts "Available Review Presets:"
+            puts
+
+            # Header
+            puts format("%-20s %-50s %-10s", "Preset", "Description", "Source")
+            puts "-" * 80
+
+            # Load preset manager to get descriptions
+            preset_manager = Molecules::PresetManager.new
+
+            presets.each do |name|
+              preset = preset_manager.load_preset(name)
+              description = preset&.dig("description") || "-"
+
+              # Determine source
+              source = if preset_manager.send(:load_preset_from_file, name)
+                "file"
+              elsif preset_manager.send(:load_preset_from_config, name)
+                "config"
+              else
+                "default"
+              end
+
+              puts format("%-20s %-50s %-10s", name, description, source)
+            end
+          end
+
+          def show_list_prompts
+            manager = Organisms::ReviewManager.new
+
+            prompts = manager.list_prompts
+            if prompts.empty?
+              puts "No prompt modules found"
+              return
+            end
+
+            puts "Available Prompt Modules:"
+            puts
+
+            prompts.each do |category, items|
+              puts "  #{category}/"
+              format_prompt_items(items, "    ")
+            end
+          end
+
+          def format_prompt_items(items, indent)
+            case items
+            when Hash
+              items.each do |name, value|
+                if value.is_a?(Array)
+                  puts "#{indent}#{name}/"
+                  value.each do |item|
+                    source = item.is_a?(Hash) ? " (#{item[:source]})" : ""
+                    item_name = item.is_a?(Hash) ? item[:name] : item
+                    puts "#{indent}  #{item_name}#{source}"
+                  end
+                else
+                  source = value.is_a?(String) ? " (#{value})" : ""
+                  puts "#{indent}#{name}#{source}"
+                end
+              end
+            when Array
+              items.each { |item| puts "#{indent}#{item}" }
+            when String
+              puts "#{indent}#{items}"
+            end
+          end
+
+          def load_defaults
+            gem_root = Gem.loaded_specs["ace-review"]&.gem_dir ||
+              File.expand_path("../../../../../..", __dir__)
+            defaults_path = File.join(gem_root, ".ace-defaults", "review", "config.yml")
+
+            if File.exist?(defaults_path)
+              require "yaml"
+              YAML.safe_load_file(defaults_path, permitted_classes: [Date], aliases: true) || {}
+            else
+              {}
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,71 @@
+# frozen_string_literal: true
+
+require "ace/support/cli"
+require "ace/core"
+require_relative "../version"
+
+# Reuse existing feedback command classes
+require_relative "commands/feedback/create"
+require_relative "commands/feedback/list"
+require_relative "commands/feedback/show"
+require_relative "commands/feedback/verify"
+require_relative "commands/feedback/skip"
+require_relative "commands/feedback/resolve"
+
+module Ace
+  module Review
+    # Flat CLI registry for ace-review-feedback (review feedback management).
+    #
+    # Replaces the nested `ace-review feedback <subcommand>` pattern with
+    # flat `ace-review-feedback <command>` invocations.
+    module FeedbackCLI
+      extend Ace::Support::Cli::RegistryDsl
+
+      PROGRAM_NAME = "ace-review-feedback"
+
+      # Application commands with descriptions (for help output)
+      REGISTERED_COMMANDS = [
+        ["list", "List feedback items from a review"],
+        ["create", "Create feedback from review output"],
+        ["show", "Show feedback details"],
+        ["verify", "Verify feedback as valid or invalid"],
+        ["skip", "Skip a feedback item"],
+        ["resolve", "Resolve a feedback item"]
+      ].freeze
+
+      HELP_EXAMPLES = [
+        "ace-review-feedback create                        # From latest review session",
+        "ace-review-feedback list --status pending          # Unresolved items",
+        "ace-review-feedback verify 42 --valid              # Confirm finding",
+        "ace-review-feedback resolve 42                     # Mark as resolved"
+      ].freeze
+
+      # Register flat commands (reusing existing command classes)
+      register "list", CLI::Commands::FeedbackSubcommands::List
+      register "create", CLI::Commands::FeedbackSubcommands::Create
+      register "show", CLI::Commands::FeedbackSubcommands::Show
+      register "verify", CLI::Commands::FeedbackSubcommands::Verify
+      register "skip", CLI::Commands::FeedbackSubcommands::Skip
+      register "resolve", CLI::Commands::FeedbackSubcommands::Resolve
+
+      # Register version command
+      version_cmd = Ace::Support::Cli::VersionCommand.build(
+        gem_name: "ace-review-feedback",
+        version: Ace::Review::VERSION
+      )
+      register "version", version_cmd
+      register "--version", version_cmd
+
+      # Register help command
+      help_cmd = Ace::Support::Cli::HelpCommand.build(
+        program_name: PROGRAM_NAME,
+        version: Ace::Review::VERSION,
+        commands: REGISTERED_COMMANDS,
+        examples: HELP_EXAMPLES
+      )
+      register "help", help_cmd
+      register "--help", help_cmd
+      register "-h", help_cmd
+    end
+  end
+end

data/lib/ace/review/cli.rb

@@ -0,0 +1,103 @@
+# frozen_string_literal: true
+
+require "ace/support/cli"
+require "ace/core"
+require_relative "../review"
+# Commands
+require_relative "cli/commands/review"
+
+module Ace
+  module Review
+    # CLI namespace for ace-review command loading.
+    #
+    # ace-review uses a single-command ace-support-cli entrypoint that calls
+    # CLI::Commands::Review directly from the executable.
+    module CLI
+      # Separator for array options that won't conflict with internal commas
+      # ASCII Unit Separator (0x1F) is designed for separating fields
+      ARRAY_SEPARATOR = "\x1F"
+
+      # Pre-process array options to work around ace-support-cli limitation
+      #
+      # ace-support-cli's type: :array only captures the last occurrence of a flag.
+      # This method merges multiple occurrences using ARRAY_SEPARATOR
+      # (not comma) to preserve internal commas in subject values
+      # like "files:a.rb,b.rb".
+      #
+      # @param args [Array<String>] Raw command-line arguments
+      # @return [Array<String>] Pre-processed arguments with merged array options
+      def self.preprocess_array_options(args)
+        result = []
+        i = 0
+        accumulated_subject = []
+        accumulated_model = []
+
+        while i < args.length
+          arg = args[i]
+
+          # Track --subject occurrences for merging
+          if arg == "--subject" || arg.start_with?("--subject=")
+            value = extract_flag_value(arg, args, i)
+            accumulated_subject << value
+            i = skip_to_next_arg(args, i)
+            next
+          end
+
+          # Track --model occurrences for merging
+          if arg == "--model" || arg.start_with?("--model=")
+            value = extract_flag_value(arg, args, i)
+            accumulated_model << value
+            i = skip_to_next_arg(args, i)
+            next
+          end
+
+          result << arg
+          i += 1
+        end
+
+        # Insert merged flags at position 0 (single-command mode, no command name to skip)
+        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?
+
+        result
+      end
+
+      # Extract value from flag argument
+      #
+      # @param arg [String] Current argument (may be --flag=value or just --flag)
+      # @param args [Array<String>] All arguments
+      # @param index [Integer] Current index
+      # @return [String] Extracted value
+      def self.extract_flag_value(arg, args, index)
+        if arg.include?("=")
+          arg.split("=", 2)[1]
+        elsif index + 1 < args.length && !args[index + 1].start_with?("--")
+          args[index + 1]
+        else
+          ""
+        end
+      end
+
+      # Calculate next index after consuming flag value
+      #
+      # @param args [Array<String>] All arguments
+      # @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?("--"))
+          index + 2
+        else
+          index + 1
+        end
+      end
+
+      # Entry point for CLI invocation (used by tests via cli_helpers)
+      #
+      # @param args [Array<String>] Command-line arguments
+      def self.start(args)
+        Ace::Support::Cli::Runner.new(Commands::Review).call(args: args)
+      end
+    end
+  end
+end

data/lib/ace/review/errors.rb

@@ -0,0 +1,146 @@
+# frozen_string_literal: true
+
+module Ace
+  module Review
+    # Namespace for ace-review errors
+    module Errors
+      # Base error class for all ace-review errors
+      class Error < StandardError; end
+
+      # Raised when a required dependency is missing
+      class MissingDependencyError < Error
+        attr_reader :dependency_name, :install_command
+
+        def initialize(dependency_name, install_command = nil)
+          @dependency_name = dependency_name
+          @install_command = install_command || "gem install #{dependency_name}"
+
+          message = "Required gem '#{dependency_name}' not found.\n"
+          message += "Install with: #{@install_command}"
+
+          super(message)
+        end
+      end
+
+      # Raised when ace-bundle fails to process bundle
+      class BundleProcessingError < Error
+        attr_reader :details
+
+        def initialize(message, details = nil)
+          @details = details
+          super(message)
+        end
+      end
+
+      # Raised when gh CLI is not installed
+      class GhCliNotInstalledError < Error
+        def initialize
+          message = "GitHub CLI (gh) is not installed.\n"
+          message += "Install with:\n"
+          message += "  macOS: brew install gh\n"
+          message += "  Linux: See https://cli.github.com/manual/installation\n"
+          message += "  Windows: See https://cli.github.com/manual/installation"
+
+          super(message)
+        end
+      end
+
+      # Raised when user is not authenticated with GitHub
+      class GhAuthenticationError < Error
+        def initialize
+          message = "GitHub authentication required.\n"
+          message += "Run 'gh auth login' to authenticate with GitHub.\n"
+          message += "Check status: gh auth status"
+
+          super(message)
+        end
+      end
+
+      # Raised when a PR is not found
+      class PrNotFoundError < Error
+        attr_reader :pr_identifier
+
+        def initialize(pr_identifier, details = nil)
+          @pr_identifier = pr_identifier
+          message = "Pull request '#{pr_identifier}' not found."
+          message += "\n#{details}" if details
+
+          super(message)
+        end
+      end
+
+      # Raised when PR diff exceeds GitHub's API size limit (300 files)
+      class DiffTooLargeError < Error
+        attr_reader :pr_identifier
+
+        def initialize(pr_identifier, details = nil)
+          @pr_identifier = pr_identifier
+          message = "Pull request '#{pr_identifier}' diff exceeds GitHub API size limit."
+          message += "\n#{details}" if details
+
+          super(message)
+        end
+      end
+
+      # Raised when attempting to post to a closed/merged PR
+      class PrStateError < Error
+        attr_reader :pr_number, :state
+
+        def initialize(pr_number, state)
+          @pr_number = pr_number
+          @state = state
+
+          message = "Cannot post comment to PR ##{pr_number}.\n"
+          message += "PR is in '#{state}' state. Comments can only be posted to open PRs."
+
+          super(message)
+        end
+      end
+
+      # Raised when gh CLI encounters a network error
+      class GhNetworkError < Error; end
+
+      # Raised when ace-task cannot find task
+      class TaskNotFoundError < Error
+        attr_reader :task_ref
+
+        def initialize(task_ref)
+          @task_ref = task_ref
+          message = "Task '#{task_ref}' not found.\n"
+          message += "Run 'ace-task show #{task_ref}' for details."
+          super(message)
+        end
+      end
+
+      # Raised when task exists but has no path
+      class TaskPathNotFoundError < Error
+        attr_reader :task_ref
+
+        def initialize(task_ref)
+          @task_ref = task_ref
+          message = "Task '#{task_ref}' exists but has no path.\n"
+          message += "Check task status with: ace-task show #{task_ref}"
+          super(message)
+        end
+      end
+
+      # Raised when a subprocess command times out
+      class CommandTimeoutError < Error
+        attr_reader :command, :timeout_seconds
+
+        def initialize(command, timeout_seconds)
+          @command = command
+          @timeout_seconds = timeout_seconds
+          message = "Command '#{command}' timed out after #{timeout_seconds} seconds."
+          super(message)
+        end
+      end
+
+      # Raised when context composition fails
+      class ContextComposerError < Error; end
+
+      # Raised when an unknown review strategy is requested
+      class UnknownStrategyError < Error; end
+    end
+  end
+end