synthra 0.1.0

data/lib/synthra/repl/enhanced_repl.rb

@@ -0,0 +1,607 @@
+# frozen_string_literal: true
+
+# =============================================================================
+# Synthra Enhanced REPL with History, Aliases, Export, and Tab Completion
+# =============================================================================
+#
+# Provides enhanced REPL features:
+# - Command aliases (t: table, d: debug, i: inspect)
+# - Readline-based command history with arrow key navigation
+# - Tab completion for schema names and commands
+# - Export to file (gen User 100 > users.json)
+# - Improved error messages with "did you mean" suggestions
+#
+# Note: Most methods in this file are interactive and marked with :nocov:
+# as they require stdin/stdout interaction that's difficult to test.
+#
+# =============================================================================
+
+require_relative "formatter"
+
+module Synthra
+  module REPL
+    # Command aliases for the REPL
+    # Maps short aliases to full command names
+    COMMAND_ALIASES = {
+      "t" => "table",
+      "d" => "debug",
+      "i" => "inspect",
+      "g" => "gen",
+      "l" => "list",
+      "h" => "help",
+      "q" => "quit"
+    }.freeze
+
+    # All available REPL commands
+    COMMANDS = %w[
+      load list info gen table debug inspect seed mode help quit exit
+    ].freeze
+
+    # Enhanced REPL with history, completion, and export
+    class EnhancedREPL
+      # @return [Registry] the schema registry
+      attr_reader :registry
+
+      # @return [Integer, nil] the current seed for deterministic generation
+      attr_reader :current_seed
+
+      # @return [Symbol] the current generation mode
+      attr_reader :current_mode
+
+      # @return [Array<String>] command history
+      attr_reader :history
+
+      # Initialize the Enhanced REPL
+      #
+      # @param registry [Registry] optional pre-loaded registry
+      # @param verbose [Boolean] enable verbose output
+      #
+      def initialize(registry: nil, verbose: false)
+        @registry = registry || Registry.new
+        @current_seed = nil
+        @current_mode = :random
+        @verbose = verbose
+        @history = []
+        @running = false
+        setup_readline
+      end
+
+      # Check if readline is available
+      #
+      # @return [Boolean] true if readline is available
+      #
+      def readline_available?
+        @readline_available
+      end
+
+      # Run the REPL
+      #
+      # @return [Integer] exit code
+      #
+      # :nocov:
+      def run
+        @running = true
+        print_welcome
+
+        while @running
+          input = read_input
+          break if input.nil?
+
+          input = input.strip
+          next if input.empty?
+
+          @history << input
+          process_command(input)
+        end
+
+        CLI::EXIT_SUCCESS
+      end
+      # :nocov:
+
+      # Process a single command
+      #
+      # @param input [String] the command input
+      # @return [void]
+      #
+      def process_command(input)
+        # Check for export redirect syntax: command > filename
+        if input.include?(" > ")
+          command_part, filename = input.split(" > ", 2)
+          execute_with_export(command_part.strip, filename.strip)
+        else
+          execute_command(input)
+        end
+      rescue => e
+        puts "❌ Error: #{e.message}"
+        puts e.backtrace.first(3).join("\n") if @verbose
+      end
+
+      # Stop the REPL
+      #
+      # @return [void]
+      #
+      def stop
+        @running = false
+      end
+
+      private
+
+      # Set up readline if available
+      #
+      # @return [void]
+      #
+      def setup_readline
+        begin
+          require "readline"
+          @readline_available = true
+          setup_completion
+        rescue LoadError
+          @readline_available = false
+        end
+      end
+
+      # Set up tab completion
+      #
+      # @return [void]
+      #
+      def setup_completion
+        return unless @readline_available
+
+        Readline.completion_proc = proc do |input|
+          completions_for(input)
+        end
+        Readline.completion_append_character = " "
+      end
+
+      # Get completions for the current input
+      #
+      # @param input [String] partial input
+      # @return [Array<String>] matching completions
+      #
+      def completions_for(input)
+        # Get the line buffer to understand context
+        line = Readline.line_buffer rescue input
+
+        if line.nil? || line.strip.empty? || !line.include?(" ")
+          # Complete commands
+          all_commands = COMMANDS + COMMAND_ALIASES.keys
+          all_commands.select { |c| c.start_with?(input.downcase) }
+        else
+          # Complete schema names for commands that take them
+          command = line.split.first&.downcase
+          if %w[gen table debug inspect info g t d i].include?(command)
+            @registry.names.select { |name| name.downcase.start_with?(input.downcase) }
+          else
+            []
+          end
+        end
+      end
+
+      # Read input from user
+      #
+      # @return [String, nil] user input or nil on EOF
+      #
+      # :nocov:
+      def read_input
+        if @readline_available
+          Readline.readline("synthra> ", true)
+        else
+          print "synthra> "
+          $stdin.gets
+        end
+      end
+      # :nocov:
+
+      # Print welcome message
+      #
+      # @return [void]
+      #
+      # :nocov:
+      def print_welcome
+        puts "=" * 60
+        puts "Synthra Interactive REPL (Enhanced)"
+        puts "=" * 60
+        puts
+        puts "Commands (aliases in parentheses):"
+        puts "  load <path>           - Load schemas from file/directory"
+        puts "  list (l)              - List loaded schemas"
+        puts "  info <Schema>         - Show schema details"
+        puts "  gen <Schema> [N] (g)  - Generate records (JSON)"
+        puts "  table <Schema> [N] (t)- Generate records (table view)"
+        puts "  debug <Schema> (d)    - Step-through debug generation"
+        puts "  inspect <Schema> (i)  - Generate and show detailed inspection"
+        puts "  seed <number>         - Set seed for deterministic output"
+        puts "  mode <mode>           - Set mode (random/edge/invalid/hostile/mixed)"
+        puts "  help (h)              - Show this help"
+        puts "  quit/exit (q)         - Exit REPL"
+        puts
+        puts "Export to file:"
+        puts "  gen User 100 > users.json    - Export to JSON file"
+        puts "  table User 10 > users.txt    - Export table to text file"
+        puts
+        if @readline_available
+          puts "Tab completion and command history enabled!"
+        else
+          puts "Install 'readline' gem for history and tab completion"
+        end
+        puts
+      end
+      # :nocov:
+
+      # Execute command with export to file
+      #
+      # @param command [String] the command to execute
+      # @param filename [String] the file to export to
+      # @return [void]
+      #
+      def execute_with_export(command, filename)
+        # Capture output
+        output = capture_output { execute_command(command) }
+
+        if output && !output.strip.empty?
+          File.write(filename, output)
+          puts "✅ Exported to #{filename} (#{output.bytesize} bytes)"
+        else
+          puts "❌ No output to export"
+        end
+      end
+
+      # Capture stdout output from a block
+      #
+      # @yield block to execute
+      # @return [String] captured output
+      #
+      def capture_output
+        original_stdout = $stdout
+        $stdout = StringIO.new
+        yield
+        $stdout.string
+      ensure
+        $stdout = original_stdout
+      end
+
+      # Execute a single command
+      #
+      # @param input [String] command input
+      # @return [void]
+      #
+      def execute_command(input)
+        return if input.nil? || input.strip.empty?
+
+        # Expand aliases
+        parts = input.split(/\s+/, 2)
+        command = parts[0]&.downcase
+        rest = parts[1]
+
+        return if command.nil? || command.empty?
+
+        # Check for alias
+        if COMMAND_ALIASES.key?(command)
+          command = COMMAND_ALIASES[command]
+        end
+
+        # Reconstruct full input
+        full_input = rest ? "#{command} #{rest}" : command
+
+        case full_input
+        when /^load\s+(.+)$/
+          cmd_load($1.strip)
+        when "list", "l"
+          cmd_list
+        when /^info\s+(\w+)$/
+          cmd_info($1)
+        when /^gen\s+(\w+)(?:\s+(\d+))?$/
+          cmd_gen($1, ($2 || "1").to_i)
+        when /^table\s+(\w+)(?:\s+(\d+))?$/
+          cmd_table($1, ($2 || "1").to_i)
+        when /^debug\s+(\w+)$/
+          cmd_debug($1)
+        when /^inspect\s+(\w+)$/
+          cmd_inspect($1)
+        when /^seed\s+(\d+)$/
+          cmd_seed($1.to_i)
+        when /^mode\s+(random|edge|invalid|hostile|mixed)$/
+          cmd_mode($1.to_sym)
+        when "help", "h"
+          cmd_help
+        when "quit", "exit", "q"
+          cmd_quit
+        else
+          suggest_command(command)
+        end
+      end
+
+      # Suggest similar command for typos
+      #
+      # @param unknown [String] unknown command
+      # @return [void]
+      #
+      def suggest_command(unknown)
+        all_commands = COMMANDS + COMMAND_ALIASES.keys
+        suggestions = Utils::StringDistance.similar_strings(unknown, all_commands, max_distance: 2)
+
+        if suggestions.any?
+          puts "Unknown command: #{unknown}"
+          puts Utils::StringDistance.format_suggestions(suggestions)
+        else
+          puts "Unknown command: #{unknown}. Type 'help' for available commands."
+        end
+      end
+
+      # Load schemas from path
+      #
+      # @param path [String] file or directory path
+      # @return [void]
+      #
+      def cmd_load(path)
+        if File.directory?(path)
+          Dir.glob(File.join(path, "*.dsl")).each do |f|
+            @registry.load_file(f, validate: false)
+          end
+        else
+          @registry.load_file(path, validate: false)
+        end
+        puts "✅ Loaded #{@registry.size} schema(s)"
+      rescue => e
+        puts "❌ Error: #{e.message}"
+      end
+
+      # List loaded schemas
+      #
+      # @return [void]
+      #
+      def cmd_list
+        if @registry.size == 0
+          puts "No schemas loaded. Use 'load <path>' first."
+        else
+          puts "Loaded schemas:"
+          @registry.schemas.each do |name, schema|
+            version = schema.version ? " v#{schema.version}" : ""
+            deprecated = schema.deprecated? ? " [DEPRECATED]" : ""
+            puts "  - #{name}#{version}#{deprecated}"
+          end
+        end
+      end
+
+      # Show schema info
+      #
+      # @param name [String] schema name
+      # @return [void]
+      #
+      def cmd_info(name)
+        schema = find_schema(name)
+        return unless schema
+
+        puts "Schema: #{name}"
+        puts "  Version: #{schema.version || 'not specified'}"
+        puts "  Fields: #{schema.fields.length}"
+        schema.fields.each do |f|
+          optional = f.optional? ? "?" : ""
+          nullable = f.nullable? ? " (nullable)" : ""
+          puts "    - #{f.name}#{optional}: #{f.type_name}#{nullable}"
+        end
+      end
+
+      # Generate records
+      #
+      # @param name [String] schema name
+      # @param count [Integer] number of records
+      # @return [void]
+      #
+      def cmd_gen(name, count)
+        schema = find_schema(name)
+        return unless schema
+
+        opts = build_generation_opts
+
+        if count == 1
+          record = schema.generate(**opts)
+          puts JSON.pretty_generate(record)
+        else
+          records = schema.generate_many(count, **opts)
+          puts JSON.pretty_generate(records)
+        end
+      end
+
+      # Generate table output
+      #
+      # @param name [String] schema name
+      # @param count [Integer] number of records
+      # @return [void]
+      #
+      def cmd_table(name, count)
+        schema = find_schema(name)
+        return unless schema
+
+        opts = build_generation_opts
+
+        if count == 1
+          record = schema.generate(**opts)
+          puts Formatter.table(record)
+        else
+          records = schema.generate_many(count, **opts)
+          puts Formatter.table(records)
+        end
+      end
+
+      # Debug generation
+      #
+      # @param name [String] schema name
+      # @return [void]
+      #
+      # :nocov:
+      def cmd_debug(name)
+        schema = find_schema(name)
+        return unless schema
+
+        puts "🐛 Debug Mode: Generating #{schema.name}"
+        puts "=" * 60
+        puts "Press Enter to continue after each field, 'q' to quit, 'c' to continue without pausing"
+        puts
+
+        field_index = 0
+        generated_fields = {}
+        auto_continue = false
+
+        original_callback = Synthra.configuration.on_field_generated
+
+        Synthra.configuration.on_field_generated = lambda do |schema_name, field_name, value, duration|
+          field_index += 1
+          generated_fields[field_name] = value
+
+          puts "\n[Field #{field_index}] #{field_name}"
+          puts "─" * 60
+          puts "Value: #{Formatter.format_value(value, 80)}"
+          puts "Duration: #{duration}ms" if duration
+          puts "Schema: #{schema_name}"
+
+          # Show context state - all previously generated fields
+          if generated_fields.size > 1
+            puts "\n📋 Context (#{generated_fields.size - 1} prior fields):"
+            generated_fields.each do |k, v|
+              next if k == field_name
+              puts "    #{k.to_s.ljust(20)} = #{Formatter.format_value(v, 50)}"
+            end
+          end
+          puts
+
+          return if auto_continue
+
+          loop do
+            print "Press Enter to continue, 'q' to quit, 'c' to continue without pausing: "
+            response = $stdin.gets&.strip&.downcase
+
+            case response
+            when "q", "quit"
+              Synthra.configuration.on_field_generated = original_callback
+              puts "Debug cancelled."
+              throw :debug_cancelled
+            when "c", "continue"
+              auto_continue = true
+              puts "Continuing without pausing..."
+              break
+            when "", nil
+              break
+            else
+              puts "Invalid input. Press Enter, 'q', or 'c'."
+            end
+          end
+        end
+
+        begin
+          catch(:debug_cancelled) do
+            opts = build_generation_opts
+            result = schema.generate(**opts)
+
+            puts
+            puts "=" * 60
+            puts "✅ Generation Complete!"
+            puts "=" * 60
+            puts
+            puts "Final Record:"
+            puts Formatter.table(result)
+          end
+        ensure
+          Synthra.configuration.on_field_generated = original_callback
+        end
+      end
+      # :nocov:
+
+      # Inspect generation
+      #
+      # @param name [String] schema name
+      # @return [void]
+      #
+      def cmd_inspect(name)
+        schema = find_schema(name)
+        return unless schema
+
+        opts = build_generation_opts
+        record = schema.generate(**opts)
+
+        puts "📊 Generated Record:"
+        puts "=" * 60
+        puts Formatter.table(record)
+        puts
+        puts "📋 JSON Format:"
+        puts JSON.pretty_generate(record)
+        puts
+        puts "📏 Statistics:"
+        puts "  Fields: #{record.keys.length}"
+        puts "  Total size: #{JSON.generate(record).bytesize} bytes"
+        record.each do |key, value|
+          type = value.class.name
+          size = case value
+                 when String then "#{value.bytesize} bytes"
+                 when Hash then "#{value.keys.length} keys"
+                 when Array then "#{value.length} items"
+                 else value.inspect.length.to_s + " chars"
+                 end
+          puts "    #{key}: #{type} (#{size})"
+        end
+      end
+
+      # Set seed
+      #
+      # @param seed [Integer] seed value
+      # @return [void]
+      #
+      def cmd_seed(seed)
+        @current_seed = seed
+        puts "✅ Seed set to #{@current_seed}"
+      end
+
+      # Set mode
+      #
+      # @param mode [Symbol] generation mode
+      # @return [void]
+      #
+      def cmd_mode(mode)
+        @current_mode = mode
+        puts "✅ Mode set to #{@current_mode}"
+      end
+
+      # Show help
+      #
+      # @return [void]
+      #
+      def cmd_help
+        puts "Commands: load, list (l), info, gen (g), table (t), debug (d), inspect (i), seed, mode, help (h), quit (q)"
+        puts "Export: Use '> filename' to export output (e.g., 'gen User 100 > users.json')"
+      end
+
+      # Quit REPL
+      #
+      # @return [void]
+      #
+      def cmd_quit
+        puts "Goodbye!"
+        stop
+      end
+
+      # Find schema by name with suggestions
+      #
+      # @param name [String] schema name
+      # @return [Schema, nil] schema or nil if not found
+      #
+      def find_schema(name)
+        @registry.schema(name)
+      rescue KeyError
+        suggestions = Utils::StringDistance.similar_strings(name, @registry.names, max_distance: 3)
+        puts "❌ Schema '#{name}' not found"
+        puts Utils::StringDistance.format_suggestions(suggestions) if suggestions.any?
+        nil
+      end
+
+      # Build generation options hash
+      #
+      # @return [Hash] generation options
+      #
+      def build_generation_opts
+        opts = { registry: @registry, mode: @current_mode }
+        opts[:seed] = @current_seed if @current_seed
+        opts
+      end
+    end
+  end
+end