reviewer 0.1.5 → 1.0.0

data/lib/reviewer/session/formatter.rb

@@ -0,0 +1,87 @@
+# frozen_string_literal: true
+
+require_relative '../output/formatting'
+
+module Reviewer
+  class Session
+    # Display logic for lifecycle warnings: unrecognized keywords, no matching tools, etc.
+    class Formatter
+      include Output::Formatting
+
+      attr_reader :output, :printer
+      private :output, :printer
+
+      # Creates a formatter for session lifecycle warnings
+      # @param output [Output] the console output handler
+      #
+      # @return [Formatter]
+      def initialize(output)
+        @output = output
+        @printer = output.printer
+      end
+
+      # Displays warnings for keywords that don't match any tool or git scope
+      # @param unrecognized [Array<String>] the unrecognized keyword strings
+      # @param suggestions [Hash{String => String}] keyword => suggested correction
+      #
+      # @return [void]
+      def unrecognized_keywords(unrecognized, suggestions)
+        unrecognized.each do |keyword|
+          printer.puts(:warning, "Unrecognized: #{keyword}")
+          suggestion = suggestions[keyword]
+          printer.puts(:muted, "  did you mean '#{suggestion}'?") if suggestion
+        end
+        output.newline
+      end
+
+      # Displays a warning when an unrecognized output format is requested
+      # @param value [String] the invalid format name
+      # @param known [Array<Symbol>] the valid format options
+      #
+      # @return [void]
+      def invalid_format(value, known)
+        printer.puts(:warning, "Unknown format '#{value}', using 'streaming'")
+        printer.puts(:muted, "Valid formats: #{known.join(', ')}")
+        output.newline
+      end
+
+      # Displays a git-related error with context-appropriate messaging
+      # @param message [String] the error message from the git command
+      #
+      # @return [void]
+      def git_error(message)
+        if message.include?('not a git repository')
+          printer.puts(:warning, 'Not a git repository')
+          printer.puts(:muted, 'Git keywords (staged, modified, etc.) require a git repository')
+        else
+          printer.puts(:warning, 'Git command failed')
+          printer.puts(:muted, message)
+          printer.puts(:muted, 'Continuing without file filtering')
+        end
+      end
+
+      # Displays a message when file-scoping keywords resolved to no files
+      # @param keywords [Array<String>] the file keywords that were requested (e.g. ['staged'])
+      #
+      # @return [void]
+      def no_reviewable_files(keywords:)
+        output.newline
+        printer.puts(:muted, "No reviewable #{keywords.join(', ')} files found")
+        output.newline
+      end
+
+      # Displays a warning when no configured tools match the requested names or tags
+      # @param requested [Array<String>] tool names or tags the user asked for
+      # @param available [Array<String>] all configured tool keys
+      #
+      # @return [void]
+      def no_matching_tools(requested:, available:)
+        output.newline
+        printer.puts(:warning, 'No matching tools found')
+        printer.puts(:muted, "Requested: #{requested.join(', ')}") if requested.any?
+        printer.puts(:muted, "Available: #{available.join(', ')}") if available.any?
+        output.newline
+      end
+    end
+  end
+end

data/lib/reviewer/session.rb

@@ -0,0 +1,208 @@
+# frozen_string_literal: true
+
+require_relative 'session/formatter'
+
+module Reviewer
+  # Run lifecycle with full dependency injection.
+  # Owns the review/format lifecycle that was previously in Reviewer module methods.
+  class Session
+    attr_reader :context, :tools
+    private :context, :tools
+
+    # Creates a session with all dependencies injected
+    # @param context [Context] the shared runtime dependencies (arguments, output, history)
+    # @param tools [Tools] the collection of configured tools
+    #
+    # @return [Session]
+    def initialize(context:, tools:)
+      @context = context
+      @tools = tools
+      context.arguments.keywords.tools = tools
+    end
+
+    # Runs the review command for the current set of tools
+    #
+    # @return [Integer] the maximum exit status from all tools
+    def review
+      run_tools(:review)
+    end
+
+    # Runs the format command for the current set of tools
+    #
+    # @return [Integer] the maximum exit status from all tools
+    def format
+      run_tools(:format)
+    end
+
+    private
+
+    def arguments = context.arguments
+    def output = context.output
+    def history = context.history
+
+    def run_tools(command_type)
+      if json_output?
+        run_json(command_type)
+      else
+        run_text(command_type)
+      end
+    end
+
+    def run_json(command_type)
+      message = json_early_exit_message
+      return emit_json_early_exit(message) if message
+
+      current_tools = tools.current
+      return 0 if current_tools.empty?
+
+      strategy = runner_strategy(current_tools)
+      report = Batch.new(command_type, current_tools, strategy: strategy, context: context).run
+      puts report.to_json
+      report.max_exit_status
+    end
+
+    def run_text(command_type)
+      return 0 if handle_failed_with_nothing_to_run?
+      return 0 if handle_file_scoping_with_no_files?
+
+      warn_unrecognized_keywords
+
+      current_tools = tools.current
+      return warn_no_matching_tools if current_tools.empty?
+
+      show_run_summary(current_tools, command_type)
+
+      strategy = runner_strategy(current_tools)
+      report = Batch.new(command_type, current_tools, strategy: strategy, context: context).run
+      display_text_report(report)
+      show_missing_tools(report, current_tools)
+
+      report.max_exit_status
+    end
+
+    def warn_no_matching_tools
+      formatter.no_matching_tools(
+        requested: arguments.keywords.provided + arguments.tags.to_a,
+        available: tools.all.map { |tool| tool.key.to_s }
+      )
+      0
+    end
+
+    def json_output?
+      arguments.format == :json
+    end
+
+    def json_early_exit_message
+      if failed_with_nothing_to_run?
+        'No failures to retry'
+      elsif file_scoping_with_no_files?
+        "No reviewable #{arguments.files.keywords.join(', ')} files found"
+      end
+    end
+
+    def emit_json_early_exit(message)
+      puts JSON.pretty_generate(
+        success: true,
+        message: message,
+        summary: { total: 0, passed: 0, failed: 0, missing: 0, duration: 0 },
+        tools: []
+      )
+      0
+    end
+
+    def warn_unrecognized_keywords
+      unrecognized = arguments.keywords.unrecognized
+      return if unrecognized.empty?
+
+      suggestions = build_suggestions(unrecognized)
+      formatter.unrecognized_keywords(unrecognized, suggestions)
+    end
+
+    def build_suggestions(unrecognized)
+      possible = arguments.keywords.possible
+      checker = DidYouMean::SpellChecker.new(dictionary: possible)
+
+      unrecognized.each_with_object({}) do |keyword, map|
+        corrections = checker.correct(keyword)
+        map[keyword] = corrections.first if corrections.any?
+      end
+    end
+
+    # Returns true if failed keyword is present with nothing to re-run (caller should return early)
+    def handle_failed_with_nothing_to_run?
+      return false unless failed_with_nothing_to_run?
+
+      display_failed_empty_message
+      true
+    end
+
+    def failed_with_nothing_to_run?
+      keywords = arguments.keywords
+      keywords.failed? &&
+        tools.failed_from_history.empty? &&
+        keywords.for_tool_names.empty? &&
+        keywords.for_tags.empty? &&
+        arguments.tags.to_a.empty?
+    end
+
+    # Returns true if file keywords were provided but resolved to no files (caller should return early)
+    def handle_file_scoping_with_no_files?
+      return false unless file_scoping_with_no_files?
+
+      formatter.no_reviewable_files(keywords: arguments.files.keywords)
+      true
+    end
+
+    def file_scoping_with_no_files?
+      arguments.files.keywords.any? && arguments.files.to_a.empty?
+    end
+
+    def display_failed_empty_message
+      if tools.all.any? { |tool| history.get(tool.key, :last_status) }
+        batch_formatter.no_failures_to_retry
+      else
+        batch_formatter.no_previous_run
+      end
+    end
+
+    def display_text_report(report)
+      if arguments.format == :summary
+        Report::Formatter.new(report, output: output).print
+      elsif report.success?
+        ran_count = report.results.count { |result| !result.missing? && !result.skipped? }
+        batch_formatter.summary(ran_count, report.duration)
+      end
+    end
+
+    def show_missing_tools(report, current_tools)
+      return unless report.missing?
+
+      batch_formatter.missing_tools(report.missing_tools, tools: current_tools)
+    end
+
+    def show_run_summary(current_tools, command_type)
+      return unless arguments.keywords.provided.any?
+
+      entries = build_run_summary(current_tools, command_type)
+      return if entries.size <= 1 && entries.none? { |entry| entry[:files].any? }
+
+      batch_formatter.run_summary(entries)
+    end
+
+    def build_run_summary(current_tools, command_type)
+      current_tools.filter_map do |tool|
+        Command.new(tool, command_type, context: context).run_summary
+      end
+    end
+
+    def runner_strategy(current_tools)
+      arguments.runner_strategy(multiple_tools: current_tools.size > 1)
+    end
+
+    def formatter = @formatter ||= Session::Formatter.new(output)
+
+    def batch_formatter
+      Batch::Formatter.new(output)
+    end
+  end
+end

data/lib/reviewer/setup/catalog.rb

@@ -0,0 +1,233 @@
+# frozen_string_literal: true
+
+module Reviewer
+  module Setup
+    # Frozen hash of known tool definitions with detection signals.
+    # Each entry contains the config structure needed for .reviewer.yml
+    # plus a :detect key with signals for auto-detection.
+    module Catalog
+      # Known tool definitions with detection signals and default configuration
+      TOOLS = {
+        bundle_audit: {
+          name: 'Bundle Audit',
+          description: 'Review gem dependencies for security issues',
+          tags: %w[security dependencies ruby],
+          commands: {
+            install: 'bundle exec gem install bundler-audit',
+            prepare: 'bundle exec bundle-audit update',
+            review: 'bundle exec bundle-audit check --no-update'
+          },
+          detect: {
+            gems: %w[bundler-audit]
+          }
+        },
+        rubocop: {
+          name: 'RuboCop',
+          description: 'Review Ruby syntax and formatting for consistency',
+          tags: %w[ruby syntax],
+          commands: {
+            install: 'bundle exec gem install rubocop',
+            review: 'bundle exec rubocop --parallel',
+            format: 'bundle exec rubocop --auto-correct'
+          },
+          files: { flag: '', separator: ' ', pattern: '*.rb' },
+          detect: {
+            gems: %w[rubocop],
+            files: %w[.rubocop.yml]
+          }
+        },
+        standard: {
+          name: 'Standard',
+          description: 'Zero-configuration Ruby linter',
+          tags: %w[ruby syntax],
+          commands: {
+            review: 'bundle exec standardrb',
+            format: 'bundle exec standardrb --fix'
+          },
+          detect: {
+            gems: %w[standard]
+          }
+        },
+        reek: {
+          name: 'Reek',
+          description: 'Examine Ruby classes for code smells',
+          tags: %w[ruby quality],
+          commands: {
+            install: 'bundle exec gem install reek',
+            review: 'bundle exec reek'
+          },
+          files: { flag: '', separator: ' ', pattern: '*.rb' },
+          detect: {
+            gems: %w[reek],
+            files: %w[.reek.yml]
+          }
+        },
+        flog: {
+          name: 'Flog',
+          description: 'Reports the most tortured Ruby code in a pain report',
+          tags: %w[ruby quality],
+          commands: {
+            install: 'bundle exec gem install flog',
+            review: 'bundle exec flog -g lib'
+          },
+          detect: {
+            gems: %w[flog]
+          }
+        },
+        flay: {
+          name: 'Flay',
+          description: 'Review Ruby code for structural similarities',
+          tags: %w[ruby quality],
+          commands: {
+            install: 'bundle exec gem install flay',
+            review: 'bundle exec flay ./lib'
+          },
+          detect: {
+            gems: %w[flay]
+          }
+        },
+        brakeman: {
+          name: 'Brakeman',
+          description: 'Static analysis security scanner for Rails',
+          tags: %w[security ruby],
+          commands: {
+            install: 'bundle exec gem install brakeman',
+            review: 'bundle exec brakeman --no-pager -q'
+          },
+          detect: {
+            gems: %w[brakeman],
+            directories: %w[app/controllers]
+          }
+        },
+        fasterer: {
+          name: 'Fasterer',
+          description: 'Suggest performance improvements for Ruby code',
+          tags: %w[ruby quality performance],
+          commands: {
+            install: 'bundle exec gem install fasterer',
+            review: 'bundle exec fasterer'
+          },
+          files: { flag: '', separator: ' ', pattern: '*.rb' },
+          detect: {
+            gems: %w[fasterer]
+          }
+        },
+        tests: {
+          name: 'Minitest',
+          description: 'Unit tests and coverage',
+          tags: %w[ruby tests],
+          commands: {
+            review: 'bundle exec rake test'
+          },
+          files: { review: 'bundle exec ruby -Itest', pattern: '*_test.rb', map_to_tests: 'minitest' },
+          detect: {
+            gems: %w[minitest],
+            directories: %w[test]
+          }
+        },
+        specs: {
+          name: 'RSpec',
+          description: 'Behavior-driven tests and coverage',
+          tags: %w[ruby tests],
+          commands: {
+            review: 'bundle exec rspec'
+          },
+          files: { flag: '', separator: ' ', pattern: '*_spec.rb', map_to_tests: 'rspec' },
+          detect: {
+            gems: %w[rspec],
+            directories: %w[spec]
+          }
+        },
+        eslint: {
+          name: 'ESLint',
+          description: 'Lint JavaScript and TypeScript code',
+          tags: %w[javascript linting syntax],
+          commands: {
+            review: 'npx eslint .',
+            format: 'npx eslint . --fix'
+          },
+          files: { flag: '', separator: ' ', pattern: '*.js' },
+          detect: {
+            files: %w[.eslintrc .eslintrc.js .eslintrc.json .eslintrc.yml eslint.config.js eslint.config.mjs]
+          }
+        },
+        prettier: {
+          name: 'Prettier',
+          description: 'Check code formatting consistency',
+          tags: %w[javascript formatting],
+          commands: {
+            review: 'npx prettier --check .',
+            format: 'npx prettier --write .'
+          },
+          detect: {
+            files: %w[.prettierrc .prettierrc.js .prettierrc.json .prettierrc.yml .prettierrc.yaml]
+          }
+        },
+        stylelint: {
+          name: 'Stylelint',
+          description: 'Lint CSS and SCSS for errors and consistency',
+          tags: %w[css linting],
+          commands: {
+            review: 'npx stylelint "**/*.css"',
+            format: 'npx stylelint "**/*.css" --fix'
+          },
+          files: { flag: '', separator: ' ', pattern: '*.css' },
+          detect: {
+            files: %w[.stylelintrc .stylelintrc.js .stylelintrc.json .stylelintrc.yml]
+          }
+        },
+        typescript: {
+          name: 'TypeScript',
+          description: 'Type-check TypeScript code',
+          tags: %w[javascript typescript],
+          commands: {
+            review: 'npx tsc --noEmit'
+          },
+          detect: {
+            files: %w[tsconfig.json]
+          }
+        },
+        biome: {
+          name: 'Biome',
+          description: 'Lint and format JavaScript and TypeScript',
+          tags: %w[javascript linting formatting],
+          commands: {
+            review: 'npx @biomejs/biome check .',
+            format: 'npx @biomejs/biome check . --fix'
+          },
+          files: { flag: '', separator: ' ', pattern: '*.js' },
+          detect: {
+            files: %w[biome.json biome.jsonc]
+          }
+        }
+      }.freeze
+
+      # Returns the full catalog of known tools
+      #
+      # @return [Hash] frozen hash of tool definitions
+      def self.all = TOOLS
+
+      # Returns the config for a tool key without the :detect key
+      #
+      # @param key [Symbol] the tool key
+      # @return [Hash, nil] config hash without :detect, or nil if not found
+      def self.config_for(key)
+        definition = TOOLS[key]
+        return nil unless definition
+
+        definition.except(:detect)
+      end
+
+      # Returns the detection signals for a tool key
+      #
+      # @param key [Symbol] the tool key
+      # @return [Hash, nil] detect hash, or nil if not found
+      def self.detect_for(key)
+        definition = TOOLS[key]
+        return nil unless definition
+
+        definition[:detect]
+      end
+    end
+  end
+end

data/lib/reviewer/setup/detector.rb

@@ -0,0 +1,61 @@
+# frozen_string_literal: true
+
+module Reviewer
+  module Setup
+    # Scans a project directory to detect which review tools are applicable
+    # based on Gemfile.lock contents, config files, and directory structure.
+    class Detector
+      # Value object for a single detection result (tool key + evidence).
+      # @!attribute key [rw]
+      #   @return [Symbol] the tool identifier from the catalog
+      # @!attribute reasons [rw]
+      #   @return [Array<String>] evidence strings explaining why the tool was detected
+      Result = Struct.new(:key, :reasons, keyword_init: true) do
+        # @return [String] human-readable tool name from the catalog, or the key as fallback
+        def name = Catalog.config_for(key)&.dig(:name) || key.to_s
+        # @return [String] formatted line for display (name + reasons)
+        def summary = "  #{name.ljust(22)}#{reasons.join(', ')}"
+      end
+
+      attr_reader :project_dir
+
+      # Creates a detector for scanning a project directory for supported tools
+      # @param project_dir [Pathname, String] the project root to scan
+      #
+      # @return [Detector]
+      def initialize(project_dir = Pathname.pwd)
+        @project_dir = Pathname(project_dir)
+      end
+
+      # Scans the project and returns detection results for matching tools
+      #
+      # @return [Array<Result>] detected tools with evidence
+      def detect
+        gems = GemfileLock.new(project_dir.join('Gemfile.lock')).gem_names
+
+        Catalog.all.filter_map do |key, definition|
+          reasons = reasons_for(definition[:detect], gems)
+          Result.new(key: key, reasons: reasons) if reasons.any?
+        end
+      end
+
+      private
+
+      def reasons_for(detect, gems)
+        gem_reasons(detect, gems) + file_reasons(detect) + directory_reasons(detect)
+      end
+
+      def gem_reasons(detect, gems)
+        Array(detect[:gems]).select { |name| gems.include?(name) }.map { |name| "#{name} in Gemfile.lock" }
+      end
+
+      def file_reasons(detect)
+        Array(detect[:files]).select { |name| project_dir.join(name).exist? }
+      end
+
+      def directory_reasons(detect)
+        Array(detect[:directories]).select { |name| project_dir.join(name).directory? }.map { |name| "#{name}/ directory" }
+      end
+    end
+  end
+end

data/lib/reviewer/setup/formatter.rb

@@ -0,0 +1,94 @@
+# frozen_string_literal: true
+
+require_relative '../output/formatting'
+
+module Reviewer
+  module Setup
+    # Display logic for the first-run setup flow
+    class Formatter
+      include Output::Formatting
+
+      attr_reader :output, :printer
+      private :output, :printer
+
+      # Creates a formatter for setup flow display
+      # @param output [Output] the console output handler
+      #
+      # @return [Formatter]
+      def initialize(output)
+        @output = output
+        @printer = output.printer
+      end
+
+      # Displays the welcome message when Reviewer has no configuration file
+      #
+      # @return [void]
+      def first_run_greeting
+        output.newline
+        printer.puts(:bold, "It looks like you're setting up Reviewer for the first time on this project.")
+        output.newline
+        printer.puts(:muted, 'This will auto-detect your tools and generate a .reviewer.yml configuration file.')
+        output.newline
+      end
+
+      # Displays a hint about `rvw init` when the user declines initial setup
+      #
+      # @return [void]
+      def first_run_skip
+        printer.puts(:muted, 'You can run `rvw init` any time to auto-detect and configure your tools.')
+        output.newline
+      end
+
+      # Displays a notice when `rvw init` is run but .reviewer.yml already exists
+      # @param config_file [Pathname] the existing configuration file path
+      #
+      # @return [void]
+      def setup_already_exists(config_file)
+        output.newline
+        printer.puts(:bold, "Configuration already exists: #{config_file.basename}")
+        output.newline
+        printer.puts(:muted, 'Run `rvw doctor` for a diagnostic report.')
+        printer.puts(:muted, 'To regenerate, remove the file and run `rvw init` again.')
+        output.newline
+      end
+
+      # Displays a message when auto-detection finds no supported tools in the project
+      #
+      # @return [void]
+      def setup_no_tools_detected
+        output.newline
+        printer.puts(:bold, 'No supported tools detected.')
+        output.newline
+        printer.puts(:muted, 'Create .reviewer.yml manually:')
+        printer.puts(:muted, "  #{Setup::CONFIG_URL}")
+        output.newline
+      end
+
+      # Displays the results of a successful setup with the detected tools
+      # @param results [Array<Detector::Result>] the tools that were detected and configured
+      #
+      # @return [void]
+      def setup_success(results)
+        output.newline
+        printer.puts(:success, 'Created .reviewer.yml')
+        print_detected_tools(results)
+        print_setup_footer
+      end
+
+      private
+
+      def print_detected_tools(results)
+        output.newline
+        printer.puts(:bold, 'Detected tools:')
+        results.each { |result| printer.puts(:default, result.summary) }
+      end
+
+      def print_setup_footer
+        output.newline
+        printer.puts(:muted, "Configure further:    #{Setup::CONFIG_URL}")
+        printer.puts(:muted, 'Run `rvw` to review your code.')
+        output.newline
+      end
+    end
+  end
+end