thor-interactive 0.1.0.pre.4 → 0.1.0.pre.6

data/lib/thor/interactive/shell.rb

@@ -1,54 +1,54 @@
 # frozen_string_literal: true
 
 require "reline"
-require "shellwords"
-require "thor"
+require_relative "command_dispatch"
 
 class Thor
   module Interactive
     class Shell
       DEFAULT_PROMPT = "> "
       DEFAULT_HISTORY_FILE = "~/.thor_interactive_history"
-      EXIT_COMMANDS = %w[exit quit q].freeze
 
       attr_reader :thor_class, :thor_instance, :prompt
 
+      include CommandDispatch
+
       def initialize(thor_class, options = {})
         @thor_class = thor_class
         @thor_instance = thor_class.new
-        
+
         # Merge class-level interactive options if available
         merged_options = {}
         if thor_class.respond_to?(:interactive_options)
           merged_options.merge!(thor_class.interactive_options)
         end
         merged_options.merge!(options)
-        
+
         @merged_options = merged_options
         @default_handler = merged_options[:default_handler]
         @prompt = merged_options[:prompt] || DEFAULT_PROMPT
         @history_file = File.expand_path(merged_options[:history_file] || DEFAULT_HISTORY_FILE)
-        
+
         # Ctrl-C handling configuration
         @ctrl_c_behavior = merged_options[:ctrl_c_behavior] || :clear_prompt
-        @double_ctrl_c_timeout = merged_options.key?(:double_ctrl_c_timeout) ? 
+        @double_ctrl_c_timeout = merged_options.key?(:double_ctrl_c_timeout) ?
                                 merged_options[:double_ctrl_c_timeout] : 0.5
         @last_interrupt_time = nil
-        
+
         setup_completion
         load_history
       end
 
       def start
         # Track that we're in an interactive session
-        was_in_session = ENV['THOR_INTERACTIVE_SESSION']
-        nesting_level = ENV['THOR_INTERACTIVE_LEVEL'].to_i
-        
-        ENV['THOR_INTERACTIVE_SESSION'] = 'true'
-        ENV['THOR_INTERACTIVE_LEVEL'] = (nesting_level + 1).to_s
-        
+        was_in_session = ENV["THOR_INTERACTIVE_SESSION"]
+        nesting_level = ENV["THOR_INTERACTIVE_LEVEL"].to_i
+
+        ENV["THOR_INTERACTIVE_SESSION"] = "true"
+        ENV["THOR_INTERACTIVE_LEVEL"] = (nesting_level + 1).to_s
+
         puts "(Debug: Interactive session started, level #{nesting_level + 1})" if ENV["DEBUG"]
-        
+
         # Adjust prompt for nested sessions if configured
         display_prompt = @prompt
         if nesting_level > 0 && @merged_options[:nested_prompt_format]
@@ -56,37 +56,35 @@ class Thor
         elsif nesting_level > 0
           display_prompt = "(#{nesting_level + 1}) #{@prompt}"
         end
-        
+
         show_welcome(nesting_level)
-        
+
         puts "(Debug: Entering main loop)" if ENV["DEBUG"]
-        
+
         loop do
           begin
             line = Reline.readline(display_prompt, true)
             puts "(Debug: Got input: #{line.inspect})" if ENV["DEBUG"]
-            
+
             # Reset interrupt tracking on successful input
             @last_interrupt_time = nil if line
-            
+
             if should_exit?(line)
               puts "(Debug: Exit condition met)" if ENV["DEBUG"]
               break
             end
-            
+
             next if line.nil? || line.strip.empty?
-            
+
             puts "(Debug: Processing input: #{line.strip})" if ENV["DEBUG"]
             process_input(line.strip)
             puts "(Debug: Input processed successfully)" if ENV["DEBUG"]
-            
           rescue Interrupt
             # Handle Ctrl-C
             if handle_interrupt
-              break  # Exit on double Ctrl-C
+              break # Exit on double Ctrl-C
             end
-            next  # Continue on single Ctrl-C
-            
+            next # Continue on single Ctrl-C
           rescue SystemExit => e
             puts "A command tried to exit with code #{e.status}. Staying in interactive mode."
             puts "(Debug: SystemExit caught in main loop)" if ENV["DEBUG"]
@@ -97,19 +95,18 @@ class Thor
             # Continue the loop - don't let errors break the session
           end
         end
-        
+
         puts "(Debug: Exited main loop)" if ENV["DEBUG"]
         save_history
         puts nesting_level > 0 ? "Exiting nested session..." : "Goodbye!"
-        
       ensure
         # Restore previous session state
         if was_in_session
-          ENV['THOR_INTERACTIVE_SESSION'] = 'true'
-          ENV['THOR_INTERACTIVE_LEVEL'] = nesting_level.to_s
+          ENV["THOR_INTERACTIVE_SESSION"] = "true"
+          ENV["THOR_INTERACTIVE_LEVEL"] = nesting_level.to_s
         else
-          ENV.delete('THOR_INTERACTIVE_SESSION')
-          ENV.delete('THOR_INTERACTIVE_LEVEL')
+          ENV.delete("THOR_INTERACTIVE_SESSION")
+          ENV.delete("THOR_INTERACTIVE_LEVEL")
         end
       end
 
@@ -121,302 +118,18 @@ class Thor
         end
       end
 
-      def complete_input(text, preposing)
-        # Handle completion for slash commands
-        full_line = preposing + text
-        
-        if full_line.start_with?('/')
-          # Command completion mode
-          if preposing.strip == '/' || preposing.strip.empty?
-            # Complete command names with / prefix
-            command_completions = complete_commands(text.sub(/^\//, ''))
-            command_completions.map { |cmd| "/#{cmd}" }
-          else
-            # Complete command arguments (basic implementation)
-            complete_command_options(text, preposing)
-          end
-        else
-          # Natural language mode - no completion for now
-          []
-        end
-      end
-
-      def complete_commands(text)
-        return [] if text.nil?
-        
-        command_names = @thor_class.tasks.keys + EXIT_COMMANDS + ["help"]
-        command_names.select { |cmd| cmd.start_with?(text) }.sort
-      end
-
-      def complete_command_options(text, preposing)
-        # Basic implementation - can be enhanced later
-        # For now, just return empty array to let Reline handle file completion
-        []
-      end
-
-      def process_input(input)
-        # Handle completely empty input
-        return if input.nil? || input.strip.empty?
-
-        # Check if input starts with / for explicit command mode
-        if input.strip.start_with?('/')
-          # Explicit command mode: /command args
-          handle_slash_command(input.strip[1..-1])
-        elsif is_help_request?(input)
-          # Special case: treat bare "help" as /help for convenience
-          if input.strip.split.length == 1
-            show_help
-          else
-            command_part = input.strip.split[1] 
-            show_help(command_part)
-          end
-        else
-          # Determine if this looks like a command or natural language
-          command_word = input.strip.split(/\s+/, 2).first
-          
-          if thor_command?(command_word)
-            # Looks like a command - handle it as a command (backward compatibility)
-            handle_command(input.strip)
-          elsif @default_handler
-            # Natural language mode: send whole input to default handler
-            begin
-              @default_handler.call(input, @thor_instance)
-            rescue => e
-              puts "Error in default handler: #{e.message}"
-              puts "Input was: #{input}"
-              puts "Try using /commands or type '/help' for available commands."
-            end
-          else
-            # No default handler, suggest using command mode
-            puts "No default handler configured. Use /command for commands, or type '/help' for available commands."
-          end
-        end
-      end
-
-      def handle_slash_command(command_input)
-        return if command_input.empty?
-        handle_command(command_input)
-      end
-
-      def handle_command(command_input)
-        # Extract command and check if it's a single-text command
-        command_word = command_input.split(/\s+/, 2).first
-        
-        if thor_command?(command_word)
-          task = @thor_class.tasks[command_word]
-          
-          if task && single_text_command?(task) && !task.options.any?
-            # Single text command without options - pass everything after command as one argument
-            text_part = command_input.sub(/^#{Regexp.escape(command_word)}\s*/, '')
-            if text_part.empty?
-              invoke_thor_command(command_word, [])
-            else
-              invoke_thor_command(command_word, [text_part])
-            end
-          else
-            # Multi-argument command, use proper parsing
-            args = safe_parse_input(command_input)
-            if args && !args.empty?
-              command = args.shift
-              invoke_thor_command(command, args)
-            else
-              # Parsing failed, try simple split
-              parts = command_input.split(/\s+/)
-              command = parts.shift
-              invoke_thor_command(command, parts)
-            end
-          end
-        else
-          puts "Unknown command: '#{command_word}'. Type '/help' for available commands."
-        end
-      end
-
-      def safe_parse_input(input)
-        # Try proper shell parsing first
-        Shellwords.split(input)
-      rescue ArgumentError
-        # If parsing fails, return nil so caller can handle it
-        nil
-      end
-
-      def parse_input(input)
-        # Legacy method - kept for backward compatibility
-        safe_parse_input(input) || []
-      end
-
-      def handle_unparseable_command(input, command_word)
-        # For commands that failed shell parsing, try intelligent handling
-        task = @thor_class.tasks[command_word]
-        
-        # Always try single text approach first for better natural language support
-        text_part = input.strip.sub(/^#{Regexp.escape(command_word)}\s*/, '')
-        if text_part.empty?
-          invoke_thor_command(command_word, [])
-        else
-          invoke_thor_command(command_word, [text_part])
-        end
-      end
-
-      def single_text_command?(task)
-        # Heuristic: determine if this is likely a single text command
-        return false unless task
-        
-        # Check the method signature to see how many parameters it expects
-        method_name = task.name.to_sym
-        if @thor_instance.respond_to?(method_name)
-          method_obj = @thor_instance.method(method_name)
-          param_count = method_obj.parameters.count { |type, _| type == :req }
-          
-          # Only single required parameter = likely text command
-          param_count == 1
-        else
-          # Fallback for introspection issues
-          false
-        end
-      rescue
-        # If introspection fails, default to false (safer)
-        false
-      end
-
-      def is_help_request?(input)
-        # Check if input is a help request (help, ?, etc.)
-        stripped = input.strip.downcase
-        stripped == "help" || stripped.start_with?("help ")
-      end
-
-      def thor_command?(command)
-        @thor_class.tasks.key?(command) || 
-        @thor_class.subcommand_classes.key?(command) ||
-        command == "help"
-      end
-
-      def invoke_thor_command(command, args)
-        # Use the persistent instance to maintain state
-        if command == "help"
-          show_help(args.first)
-        else
-          # Get the Thor task/command definition
-          task = @thor_class.tasks[command]
-          
-          if task && task.options && !task.options.empty?
-            # Parse options if the command has them defined
-            parsed_args, parsed_options = parse_thor_options(args, task)
-            
-            # Set options on the Thor instance
-            @thor_instance.options = Thor::CoreExt::HashWithIndifferentAccess.new(parsed_options)
-            
-            # Call with parsed arguments only (options are in the options hash)
-            if @thor_instance.respond_to?(command)
-              @thor_instance.send(command, *parsed_args)
-            else
-              @thor_instance.send(command, *parsed_args)
-            end
-          else
-            # No options defined, use original behavior
-            if @thor_instance.respond_to?(command)
-              @thor_instance.send(command, *args)
-            else
-              @thor_instance.send(command, *args)
-            end
-          end
-        end
-      rescue SystemExit => e
-        if e.status == 0
-          puts "Command completed successfully (would have exited with code 0 in CLI mode)"
-        else
-          puts "Command failed with exit code #{e.status}"
-        end
-        puts "(Use 'exit' or Ctrl+D to exit the interactive session)" if ENV["DEBUG"]
-      rescue Thor::Error => e
-        puts "Thor Error: #{e.message}"
-      rescue ArgumentError => e
-        puts "Thor Error: #{e.message}"
-        puts "Try: help #{command}" if thor_command?(command)
-      rescue StandardError => e
-        puts "Error: #{e.message}"
-        puts "Command: #{command}, Args: #{args.inspect}" if ENV["DEBUG"]
-      end
-      
-      def parse_thor_options(args, task)
-        # Convert args array to a format Thor's option parser expects
-        remaining_args = []
-        parsed_options = {}
-        
-        # Create a temporary parser using Thor's options
-        parser = Thor::Options.new(task.options)
-        
-        # Parse the arguments
-        begin
-          if args.is_a?(Array)
-            # Parse the options from the array
-            parsed_options = parser.parse(args)
-            remaining_args = parser.remaining
-          else
-            # Single string argument, split it first
-            split_args = safe_parse_input(args) || args.split(/\s+/)
-            parsed_options = parser.parse(split_args)
-            remaining_args = parser.remaining
-          end
-        rescue Thor::Error => e
-          # If parsing fails, treat everything as arguments (backward compatibility)
-          puts "Option parsing error: #{e.message}" if ENV["DEBUG"]
-          remaining_args = args.is_a?(Array) ? args : [args]
-          parsed_options = {}
-        end
-        
-        [remaining_args, parsed_options]
-      end
-
-      def show_help(command = nil)
-        if command && @thor_class.tasks.key?(command)
-          @thor_class.command_help(Thor::Base.shell.new, command)
-        else
-          puts "Available commands (prefix with /):"
-          @thor_class.tasks.each do |name, task|
-            puts "  /#{name.ljust(19)} #{task.description}"
-          end
-          puts
-          puts "Special commands:"
-          puts "  /help [COMMAND]      Show help for command"
-          puts "  /exit, /quit, /q     Exit the REPL"
-          puts
-          if @default_handler
-            puts "Natural language mode:"
-            puts "  Type anything without / to use default handler"
-          else
-            puts "Use /command syntax for all commands"
-          end
-          puts
-          if ENV["DEBUG"]
-            puts "Debug info:"
-            puts "  Thor class: #{@thor_class.name}"
-            puts "  Available tasks: #{@thor_class.tasks.keys.sort}"
-            puts "  Instance methods: #{@thor_instance.methods.grep(/^[a-z]/).sort}" if @thor_instance
-            puts
-          end
-        end
-      end
-
-      def should_exit?(line)
-        return true if line.nil? # Ctrl+D
-        
-        stripped = line.strip.downcase
-        # Handle both /exit and exit for convenience
-        EXIT_COMMANDS.include?(stripped) || EXIT_COMMANDS.include?(stripped.sub(/^\//, ''))
-      end
-      
       def handle_interrupt
         current_time = Time.now
-        
+
         # Check for double Ctrl-C
         if @last_interrupt_time && @double_ctrl_c_timeout && (current_time - @last_interrupt_time) < @double_ctrl_c_timeout
           puts "\n(Interrupted twice - exiting)"
-          @last_interrupt_time = nil  # Reset for next time
-          return true  # Signal to exit
+          @last_interrupt_time = nil # Reset for next time
+          return true # Signal to exit
         end
-        
+
         @last_interrupt_time = current_time
-        
+
         # Single Ctrl-C behavior
         case @ctrl_c_behavior
         when :clear_prompt
@@ -427,13 +140,13 @@ class Thor
           puts "Press Ctrl-C again to exit, or type 'help' for commands"
         when :silent
           # Just clear the line, no message
-          print "\r#{' ' * 80}\r"
+          print "\r#{" " * 80}\r"
         else
           # Default behavior
           puts "^C"
         end
-        
-        false  # Don't exit, just clear prompt
+
+        false # Don't exit, just clear prompt
       end
 
       def show_welcome(nesting_level = 0)
@@ -449,7 +162,7 @@ class Thor
 
       def load_history
         return unless File.exist?(@history_file)
-        
+
         File.readlines(@history_file, chomp: true).each do |line|
           Reline::HISTORY << line
         end
@@ -459,11 +172,11 @@ class Thor
 
       def save_history
         return unless Reline::HISTORY.size > 0
-        
+
         File.write(@history_file, Reline::HISTORY.to_a.join("\n"))
       rescue => e
-        # Ignore history saving errors  
+        # Ignore history saving errors
       end
     end
   end
-end
+end

data/lib/thor/interactive/tui/output_buffer.rb

@@ -0,0 +1,87 @@
+# frozen_string_literal: true
+
+class Thor
+  module Interactive
+    module TUI
+      # Stores captured command output with scrollback support.
+      # Each entry is a hash with :text and optional :style keys.
+      class OutputBuffer
+        DEFAULT_MAX_LINES = 10_000
+
+        attr_reader :scroll_offset
+
+        def initialize(max_lines: DEFAULT_MAX_LINES)
+          @lines = []
+          @max_lines = max_lines
+          @scroll_offset = 0
+        end
+
+        def append(text, style: nil)
+          text.to_s.split("\n", -1).each do |line|
+            @lines << {text: line, style: style}
+          end
+          trim_to_max
+          # Auto-scroll to bottom when new content arrives
+          @scroll_offset = 0
+        end
+
+        def lines
+          @lines.dup
+        end
+
+        def line_count
+          @lines.length
+        end
+
+        def empty?
+          @lines.empty?
+        end
+
+        def clear
+          @lines.clear
+          @scroll_offset = 0
+        end
+
+        # Returns lines visible in a viewport of given height,
+        # accounting for scroll_offset (0 = bottom, positive = scrolled up).
+        def visible_lines(viewport_height)
+          return @lines.last(viewport_height) if @scroll_offset == 0
+
+          end_index = @lines.length - @scroll_offset
+          end_index = @lines.length if end_index > @lines.length
+          start_index = end_index - viewport_height
+          start_index = 0 if start_index < 0
+
+          @lines[start_index...end_index] || []
+        end
+
+        def scroll_up(amount = 1)
+          max_offset = [@lines.length - 1, 0].max
+          @scroll_offset = [@scroll_offset + amount, max_offset].min
+        end
+
+        def scroll_down(amount = 1)
+          @scroll_offset = [@scroll_offset - amount, 0].max
+        end
+
+        def scroll_to_bottom
+          @scroll_offset = 0
+        end
+
+        def scroll_to_top
+          @scroll_offset = [@lines.length - 1, 0].max
+        end
+
+        def at_bottom?
+          @scroll_offset == 0
+        end
+
+        private
+
+        def trim_to_max
+          @lines.shift(@lines.length - @max_lines) if @lines.length > @max_lines
+        end
+      end
+    end
+  end
+end