kotoshu 0.3.0

data/lib/kotoshu/cli/interactive_reviewer.rb

@@ -0,0 +1,319 @@
+# frozen_string_literal: true
+
+require_relative 'navigation_manager'
+require_relative 'display_formatter'
+require_relative '../analyzers/semantic_analyzer'
+
+module Kotoshu
+  module Cli
+    # Interactive review session for spell/grammar checking.
+    #
+    # Provides a user-friendly terminal interface for reviewing errors
+    # with full navigation support (forward, backward, jump, skip, accept).
+    #
+    # @example Starting an interactive session
+    #   reviewer = InteractiveReviewer.new(document, analyzer)
+    #   reviewer.run  # Enters interactive loop
+    #
+    # @example Batch mode (non-interactive)
+    #   reviewer = InteractiveReviewer.new(document, analyzer)
+    #   reporter = reviewer.run_batch  # Returns BatchReporter
+    class InteractiveReviewer
+      attr_reader :document, :analyzer, :navigation, :formatter
+
+      # Create a new interactive reviewer.
+      #
+      # @param document [Documents::Document] Document to review
+      # @param analyzer [Analyzers::SemanticAnalyzer] Error analyzer
+      # @param formatter [DisplayFormatter, nil] Display formatter (default: new instance)
+      def initialize(document, analyzer, formatter: nil)
+        raise ArgumentError, "Document required" unless document
+        raise ArgumentError, "Analyzer required" unless analyzer
+
+        @document = document
+        @analyzer = analyzer
+
+        # Analyze document for errors
+        errors = @analyzer.analyze(@document)
+
+        # Create navigation manager
+        @navigation = NavigationManager.new(errors)
+
+        # Create display formatter
+        @formatter = formatter || DisplayFormatter.new
+
+        @running = false
+        @show_context = true
+      end
+
+      # Run the interactive review loop.
+      #
+      # @return [Hash] Session summary with statistics
+      def run
+        @running = true
+
+        # Show welcome message
+        show_welcome
+
+        # Show summary screen
+        puts @formatter.summary_screen(@document, @navigation)
+
+        # Main interactive loop
+        while @running && @navigation.current
+          show_current_error
+          process_input(get_user_input)
+        end
+
+        # Show exit message
+        show_exit_summary
+
+        # Return session summary
+        session_summary
+      end
+
+      # Run in batch mode (non-interactive).
+      #
+      # @return [BatchReporter] Reporter with results
+      def run_batch
+        # Analyze all errors without user interaction
+        errors = @navigation.errors
+
+        # Apply all high-confidence corrections automatically
+        errors.each do |error|
+          if error.high_confidence? && error.suggestions&.any?
+            @navigation.accept_suggestion(error.recommended_suggestion)
+          end
+        end
+
+        # Return batch reporter
+        require_relative 'batch_reporter'
+        BatchReporter.new(@document, @navigation, @formatter)
+      end
+
+      # Check if session has errors.
+      #
+      # @return [Boolean] True if there are errors to review
+      def has_errors?
+        @navigation.errors.any?
+      end
+
+      # Get session statistics.
+      #
+      # @return [Hash] Statistics hash
+      def statistics
+        @navigation.statistics
+      end
+
+      private
+
+      # Show welcome message.
+      def show_welcome
+        puts ""
+        puts @formatter.colorize("╔═══════════════════════════════════════════════════════════════╗", :bold)
+        puts @formatter.colorize("║           Kotoshu Interactive Spell/Grammar Review          ║", :bold)
+        puts @formatter.colorize("╚═══════════════════════════════════════════════════════════════╝", :bold)
+        puts ""
+        puts "Document: #{@document.name}"
+        puts "Language: #{@document.language_code}"
+        puts "Errors found: #{@navigation.errors.size}"
+        puts ""
+        puts "Type 'h' for help, 'q' to quit"
+        puts ""
+      end
+
+      # Show current error screen.
+      def show_current_error
+        error = @navigation.current
+        return unless error
+
+        index = @navigation.current_index + 1
+        total = @navigation.errors.size
+
+        puts @formatter.issue_screen(error, index: index, total: total, show_context: @show_context)
+      end
+
+      # Get user input from terminal.
+      #
+      # @return [String] User input
+      def get_user_input
+        print @formatter.prompt("Action>")
+        $stdin.gets&.chomp || 'q'
+      end
+
+      # Process user input command.
+      #
+      # @param input [String] User input
+      def process_input(input)
+        return if input.nil? || input.empty?
+
+        case input
+        when '', 'n', 'enter'
+          # Move to next error
+          @navigation.forward
+
+        when 'b', 'back'
+          # Move to previous error
+          @navigation.backward
+
+        when 's', 'skip'
+          # Skip current error
+          @navigation.skip_current
+
+        when /^(\d+)$/
+          # Accept suggestion by number
+          suggestion_number = $1.to_i - 1  # Convert to 0-based index
+          accept_suggestion_by_number(suggestion_number)
+
+        when 'j', 'jump'
+          # Jump to error
+          jump_to_error
+
+        when 'f', 'first'
+          @navigation.first
+
+        when 'l', 'last'
+          @navigation.last
+
+        when 'l', 'list'
+          # List all errors
+          puts @formatter.list_all_errors(@navigation)
+          puts @formatter.prompt("Press Enter to continue...")
+          $stdin.gets
+
+        when 't', 'toggle'
+          # Toggle context display
+          @show_context = !@show_context
+
+        when 'v', 'verbose'
+          # Toggle verbose mode
+          @formatter.verbose = !@formatter.verbose
+          puts @formatter.success("Verbose mode: #{@formatter.verbose ? 'ON' : 'OFF'}")
+
+        when '?'
+          # Show summary
+          puts @formatter.summary_screen(@document, @navigation)
+
+        when 'h', 'help'
+          # Show help
+          puts @formatter.help_screen
+          puts @formatter.prompt("Press Enter to continue...")
+          $stdin.gets
+
+        when 'q', 'quit'
+          # Quit and save
+          quit_with_save
+
+        when 'Q', 'QUIT'
+          # Quit without saving
+          quit_without_save
+
+        when '!', 'export'
+          # Export corrections
+          export_corrections
+
+        else
+          # Unknown command
+          puts @formatter.warning("Unknown command: #{input}. Type 'h' for help.")
+        end
+      end
+
+      # Accept suggestion by number.
+      #
+      # @param number [Integer] Suggestion number (0-based)
+      def accept_suggestion_by_number(number)
+        error = @navigation.current
+        return unless error
+
+        suggestions = error.suggestions || []
+        if number < 0 || number >= suggestions.size
+          puts @formatter.warning("Invalid suggestion number: #{number + 1}")
+          return
+        end
+
+        suggestion = suggestions[number]
+        @navigation.accept_suggestion(suggestion)
+        puts @formatter.success("Accepted: #{error.original} → #{suggestion.word}")
+      end
+
+      # Jump to specific error.
+      def jump_to_error
+        print @formatter.prompt("Jump to error number>")
+        input = $stdin.gets&.chomp
+
+        return unless input
+
+        number = input.to_i - 1  # Convert to 0-based
+        if number >= 0 && number < @navigation.errors.size
+          @navigation.jump_to(number)
+        else
+          puts @formatter.warning("Invalid error number: #{input}")
+        end
+      end
+
+      # Quit and save changes.
+      def quit_with_save
+        @running = false
+        puts @formatter.success("Changes saved!")
+      end
+
+      # Quit without saving.
+      def quit_without_save
+        @running = false
+        puts @formatter.warning("Quit without saving. No changes were made.")
+      end
+
+      # Export corrections to file.
+      def export_corrections
+        print @formatter.prompt("Export to file (default: corrections.json)>")
+        filepath = $stdin.gets&.chomp || 'corrections.json'
+
+        # Export corrections
+        corrections = @navigation.export_corrections
+
+        # Write to file
+        require 'json'
+        File.write(filepath, JSON.pretty_generate(corrections))
+
+        puts @formatter.export_summary(@navigation, filepath)
+        puts @formatter.prompt("Press Enter to continue...")
+        $stdin.gets
+      end
+
+      # Show exit summary.
+      def show_exit_summary
+        puts ""
+        puts @formatter.statistics(@navigation)
+        puts ""
+
+        if @navigation.modified.any?
+          puts @formatter.success("#{@navigation.modified.size} corrections applied")
+        end
+
+        if @navigation.skipped.any?
+          puts "#{@navigation.skipped.size} errors skipped"
+        end
+
+        pending = @navigation.errors.size - @navigation.modified.size - @navigation.skipped.size
+        if pending > 0
+          puts "#{pending} errors remaining"
+        end
+      end
+
+      # Get session summary.
+      #
+      # @return [Hash] Session summary
+      def session_summary
+        {
+          document: {
+            name: @document.name,
+            format: @document.format,
+            language: @document.language_code
+          },
+          statistics: @navigation.statistics,
+          corrections: @navigation.export_corrections,
+          history: @navigation.history_summary
+        }
+      end
+    end
+  end
+end

data/lib/kotoshu/cli/language_resolver.rb

@@ -0,0 +1,91 @@
+# frozen_string_literal: true
+
+module Kotoshu
+  module Cli
+    # Resolves which language a check should run in.
+    #
+    # The CLI's --language flag accepts:
+    #   - omitted / "auto"   → detect from content, fall back if needed
+    #   - "default"          → Configuration.default_language (no detection)
+    #   - any other code     → used as-is
+    #
+    # Pure logic — no IO. Detection delegates to Kotoshu::Language.detect
+    # which uses character-set heuristics and needs no model download.
+    # A detection only "sticks" if the detected language is set up
+    # (Kotoshu.setup? returns true); otherwise the configured default
+    # is used and a fallback note is included in the result.
+    class LanguageResolver
+      Result = Struct.new(:language, :detected, :fallback, :note, keyword_init: true)
+
+      # @param flag_value [String, nil] Raw --language flag value.
+      # @param default_language [String, nil] Configuration.default_language.
+      # @param detector [#detect] Object responding to .detect(text) -> String|nil.
+      #   Defaults to Kotoshu::Language.
+      # @param setup_predicate [#call] Callable returning true if a language is
+      #   set up. Defaults to Kotoshu.method(:setup?).
+      def initialize(flag_value:, default_language:,
+                     detector: Kotoshu::Language,
+                     setup_predicate: Kotoshu.method(:setup?))
+        @flag_value = flag_value
+        @default_language = default_language
+        @detector = detector
+        @setup_predicate = setup_predicate
+      end
+
+      # @param text [String] The document text, used only when flag is "auto".
+      # @return [Result]
+      def resolve(text:)
+        case @flag_value
+        when nil, "auto"
+          resolve_auto(text)
+        when "default"
+          Result.new(language: @default_language, detected: nil, fallback: nil,
+                     note: nil)
+        else
+          Result.new(language: @flag_value, detected: nil, fallback: nil,
+                     note: nil)
+        end
+      end
+
+      private
+
+      def resolve_auto(text)
+        detected = safe_detect(text)
+        if detected.nil?
+          return Result.new(language: @default_language, detected: nil,
+                            fallback: @default_language,
+                            note: "No language detected; using default '#{@default_language}'.")
+        end
+        if setup?(detected)
+          return Result.new(language: detected, detected: detected, fallback: nil,
+                            note: "Detected: #{detected}.")
+        end
+
+        Result.new(language: @default_language, detected: detected,
+                   fallback: @default_language,
+                   note: "Detected: #{detected} (fallback: #{@default_language}).")
+      end
+
+      def safe_detect(text)
+        return nil if text.nil? || text.strip.empty?
+
+        detected = @detector.detect(text)
+        return nil if detected.nil? || detected.strip.empty?
+
+        normalize(detected)
+      rescue StandardError
+        nil
+      end
+
+      def normalize(code)
+        code.to_s.downcase.split(/[-_]/).first
+      end
+
+      def setup?(lang)
+        return false if lang.nil? || lang.strip.empty?
+
+        @setup_predicate.call(lang)
+      end
+    end
+  end
+end

data/lib/kotoshu/cli/navigation_manager.rb

@@ -0,0 +1,272 @@
+# frozen_string_literal: true
+
+module Kotoshu
+  module Cli
+    # Manages navigation through errors in interactive review mode.
+    #
+    # Tracks current position, user decisions, and provides filtering
+    # for efficient error review.
+    #
+    # @example Creating navigation for errors
+    #   nav = NavigationManager.new(errors)
+    #   nav.forward  # Move to next error
+    #   nav.accept_suggestion(error.suggestions.first)
+    class NavigationManager
+      attr_reader :errors, :current_index, :history, :skipped, :modified
+
+      # Create a new navigation manager.
+      #
+      # @param errors [Array<Models::SemanticError>] Sorted list of errors
+      def initialize(errors)
+        raise ArgumentError, "Errors cannot be nil" if errors.nil?
+        raise ArgumentError, "Errors must be an Array" unless errors.is_a?(Array)
+
+        @errors = errors.sort # Errors are Comparable
+        @current_index = 0
+        @history = []
+        @skipped = Set.new
+        @modified = Set.new
+        @filters = {}
+      end
+
+      # Get the current error.
+      #
+      # @return [Models::SemanticError, nil] Current error or nil
+      def current
+        return nil if @current_index >= @errors.size
+
+        @errors[@current_index]
+      end
+
+      # Check if there's a next error.
+      #
+      # @return [Boolean] True if there's a next error
+      def next?
+        @current_index < @errors.size - 1
+      end
+
+      # Check if there's a previous error.
+      #
+      # @return [Boolean] True if there's a previous error
+      def previous?
+        @current_index > 0
+      end
+
+      # Navigation methods
+
+      # Move to next error.
+      #
+      # @return [Models::SemanticError, nil] Next error or nil
+      def forward
+        return nil unless next?
+
+        @current_index += 1
+        current
+      end
+
+      # Move to previous error.
+      #
+      # @return [Models::SemanticError, nil] Previous error or nil
+      def backward
+        return nil unless previous?
+
+        @current_index -= 1
+        current
+      end
+
+      # Jump to specific error by index.
+      #
+      # @param index [Integer] Error index (0-based)
+      # @return [Models::SemanticError, nil] Error at index or nil
+      def jump_to(index)
+        return nil if index < 0 || index >= @errors.size
+
+        @current_index = index
+        current
+      end
+
+      # Jump to first error.
+      #
+      # @return [Models::SemanticError, nil] First error or nil
+      def first
+        jump_to(0)
+      end
+
+      # Jump to last error.
+      #
+      # @return [Models::SemanticError, nil] Last error or nil
+      def last
+        jump_to(@errors.size - 1)
+      end
+
+      # Skip the current error.
+      #
+      # @return [Models::SemanticError, nil] Next error or nil
+      def skip_current
+        @skipped.add(@current_index)
+        forward
+      end
+
+      # Accept a suggestion for the current error.
+      #
+      # Records the decision and marks the error as modified.
+      #
+      # @param suggestion [Models::Suggestion] The suggestion to accept
+      # @return [Models::SemanticError, nil] Next error or nil
+      def accept_suggestion(suggestion)
+        error = current
+        return nil unless error
+
+        record_decision(
+          error_id: error.id,
+          action: :accept,
+          original: error.original,
+          replacement: suggestion.word,
+          confidence: error.confidence
+        )
+
+        @modified.add(@current_index)
+        forward
+      end
+
+      # List all errors with their status.
+      #
+      # @return [Array<String>] Formatted error list
+      def list_all
+        @errors.each_with_index.map do |error, idx|
+          status = status_for(idx)
+          "#{idx + 1}. #{status} #{error.abbreviated}"
+        end
+      end
+
+      # Filter errors by minimum confidence.
+      #
+      # @param min_confidence [Float] Minimum confidence threshold (0.0 to 1.0)
+      # @return [Array<Models::SemanticError>] Filtered errors
+      def filter_by_confidence(min_confidence: 0.0)
+        @errors.select { |e| e.confidence >= min_confidence }
+      end
+
+      # Filter errors by type(s).
+      #
+      # @param types [Array<Symbol>] Error types to include
+      # @return [Array<Models::SemanticError>] Filtered errors
+      def filter_by_type(*types)
+        @errors.select { |e| types.include?(e.error_type) }
+      end
+
+      # Get only pending errors (not skipped or modified).
+      #
+      # @return [Array<Models::SemanticError>] Pending errors
+      def pending
+        @errors.each_with_index.reject do |_, idx|
+          @skipped.include?(idx) || @modified.include?(idx)
+        end.map(&:last)
+      end
+
+      # Get statistics about the errors.
+      #
+      # @return [Hash] Statistics hash
+      def statistics
+        {
+          total: @errors.size,
+          skipped: @skipped.size,
+          modified: @modified.size,
+          pending: pending.size,
+          by_type: @errors.group_by(&:error_type).transform_values(&:size),
+          by_confidence: {
+            high: @errors.count(&:high_confidence?),
+            medium: @errors.count { |e| e.confidence > 0.5 && e.confidence <= 0.8 },
+            low: @errors.count { |e| e.confidence <= 0.5 }
+          }
+        }
+      end
+
+      # Get all errors sorted by status (pending first).
+      #
+      # @return [Array<Models::SemanticError>] Errors sorted by status
+      def by_status
+        pending + @errors.each_with_index.select { |_, idx|
+          @modified.include?(idx)
+        }.map(&:last).reverse + @errors.each_with_index.select { |_, idx|
+          @skipped.include?(idx)
+        }.map(&:last).reverse
+      end
+
+      # Reset navigation state (clear all decisions).
+      #
+      # @return [void]
+      def reset
+        @current_index = 0
+        @history.clear
+        @skipped.clear
+        @modified.clear
+      end
+
+      # Export corrections as a list of changes.
+      #
+      # @return [Array<Hash>] List of correction changes
+      def export_corrections
+        @modified.to_a.sort.map do |idx|
+          error = @errors[idx]
+          suggestion = error.recommended_suggestion
+
+          {
+            line: error.location.line,
+            original: error.original,
+            replacement: suggestion.word,
+            error_type: error.error_type,
+            confidence: error.confidence
+          }
+        end
+      end
+
+      # Get user decision history.
+      #
+      # @return [Array<Hash>] List of decisions made
+      def history_summary
+        @history.map.with_index.map do |decision, idx|
+          {
+            id: idx + 1,
+            error_id: decision[:error_id],
+            action: decision[:action],
+            original: decision[:original],
+            replacement: decision[:replacement],
+            confidence: decision[:confidence],
+            timestamp: decision[:timestamp]
+          }
+        end
+      end
+
+      private
+
+      # Record a user decision.
+      #
+      # @param error_id [String] Error identifier
+      # @param action [Symbol] Action taken (:accept, :skip, :edit)
+      # @param original [String] Original text
+      # @param replacement [String] Replacement text
+      # @param confidence [Float] Confidence score
+      def record_decision(error_id:, action:, original:, replacement:, confidence:)
+        @history << {
+          error_id: error_id,
+          action: action,
+          original: original,
+          replacement: replacement,
+          confidence: confidence,
+          timestamp: Time.now
+        }
+      end
+
+      # Get status string for an error index.
+      #
+      # @param idx [Integer] Error index
+      # @return [String] Status string
+      def status_for(idx)
+        return "[DONE]" if @modified.include?(idx)
+        return "[SKIP]" if @skipped.include?(idx)
+        "[PENDING]"
+      end
+    end
+  end
+end