thor-interactive 0.1.0.pre.3 → 0.1.0.pre.5

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: '049af6f0fedd7bda65c5845a878bd02afe8e9e5cf705ebad254c333e0151ecd7'
-  data.tar.gz: '049e366b5d3d1e4d0076c7c69d69240b00f0768b3b2687d23e9482dd7bf368dd'
+  metadata.gz: 7166b4156516b241939081e8c9fc67aba249ceae1be85b4693d4afdb7638b08d
+  data.tar.gz: 8c3f92ab064d86f27a028dd685037d8e205e452ae840a674c39025d21fd8acfb
 SHA512:
-  metadata.gz: bc5ccc2b2765f3f5c4591c181445dbc4b0ef66982c982758fb6053fa79de968c7583f019be85a747c51474e6e2f55f8834b9c4fd3314b1186dd6185a9be9e092
-  data.tar.gz: cc284a24f5f2a24bb016651e4252a9230d89c84d0e86b382fb4b936d11063422f78338d4c0917aedcf0a6e6d9fe7dcb66f8e7fb22c479c2903f355265e00cc79
+  metadata.gz: 66f640e0df6d3f1699c6cd1e9612bd6f149da4a7716bcc66e49092a4dbe0f6e568eb98e97dc9e8eecc12548f8149eadbf01ab4149e0ab832d6a57fcf7c3237fe
+  data.tar.gz: a5993427b1e28efaa8849440ff0a16e724cb25dc746d0f49292bad78c2d1f364f5526e57d30e73361c236c1460c248ddb4eaf7c32ec370965622583982881232

data/examples/completion_demo.rb

@@ -0,0 +1,191 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+require "bundler/setup"
+require "thor/interactive"
+
+class CompletionDemo < Thor
+  include Thor::Interactive::Command
+  
+  configure_interactive(
+    prompt: "demo> "
+  )
+  
+  desc "process FILE", "Process a file"
+  option :output, type: :string, aliases: "-o", desc: "Output file"
+  option :format, type: :string, enum: ["json", "xml", "yaml"], desc: "Output format"
+  option :verbose, type: :boolean, aliases: "-v", desc: "Verbose output"
+  def process(file)
+    puts "Processing: #{file}"
+    puts "Output to: #{options[:output]}" if options[:output]
+    puts "Format: #{options[:format]}" if options[:format]
+    puts "Verbose: ON" if options[:verbose]
+  end
+  
+  desc "convert INPUT OUTPUT", "Convert file format"
+  option :from, type: :string, required: true, desc: "Source format"
+  option :to, type: :string, required: true, desc: "Target format"
+  def convert(input, output)
+    puts "Converting: #{input} -> #{output}"
+    puts "Format: #{options[:from]} -> #{options[:to]}"
+  end
+  
+  desc "read FILE", "Read a file"
+  def read(file)
+    if File.exist?(file)
+      puts "Reading #{file}:"
+      puts "-" * 40
+      puts File.read(file).lines.first(10).join
+      puts "-" * 40
+      puts "(Showing first 10 lines)"
+    else
+      puts "File not found: #{file}"
+    end
+  end
+  
+  desc "list [DIR]", "List files in directory"
+  option :all, type: :boolean, aliases: "-a", desc: "Show hidden files"
+  option :long, type: :boolean, aliases: "-l", desc: "Long format"
+  def list(dir = ".")
+    puts "Listing files in: #{dir}"
+    
+    pattern = options[:all] ? "*" : "[^.]*"
+    files = Dir.glob(File.join(dir, pattern))
+    
+    if options[:long]
+      files.each do |file|
+        stat = File.stat(file)
+        type = File.directory?(file) ? "d" : "-"
+        size = stat.size.to_s.rjust(10)
+        name = File.basename(file)
+        name += "/" if File.directory?(file)
+        puts "#{type} #{size} #{name}"
+      end
+    else
+      files.each { |f| puts File.basename(f) }
+    end
+  end
+  
+  desc "test", "Test completion features"
+  def test
+    puts <<~TEST
+    
+    === Path Completion Demo ===
+    
+    This demo showcases the new completion features:
+    
+    1. PATH COMPLETION
+       Start typing a path and press TAB:
+       /process <TAB>           # Shows files in current directory
+       /process ex<TAB>         # Completes to 'examples/'
+       /process ~/Doc<TAB>      # Completes home directory paths
+       /process ./lib/<TAB>     # Shows files in lib directory
+    
+    2. OPTION COMPLETION
+       Type - or -- and press TAB:
+       /process file.txt --<TAB>     # Shows all options
+       /process file.txt --v<TAB>    # Completes to --verbose
+       /process file.txt -<TAB>      # Shows short options
+    
+    3. SMART DETECTION
+       After file options, paths are completed:
+       /process --output <TAB>       # Completes paths
+       /process -o <TAB>             # Also completes paths
+    
+    4. COMMAND COMPLETION
+       Still works as before:
+       /proc<TAB>                    # Completes to /process
+       /con<TAB>                     # Completes to /convert
+    
+    TRY THESE EXAMPLES:
+    
+    Basic file completion:
+      /read <TAB>
+      /read README<TAB>
+      /read lib/<TAB>
+      
+    Option completion:
+      /process file.txt --<TAB>
+      /process file.txt --verb<TAB>
+      /convert input.txt output.json --<TAB>
+      
+    Path after options:
+      /process --output <TAB>
+      /process -o ~/Desktop/<TAB>
+      
+    Directory listing:
+      /list <TAB>
+      /list examples/<TAB>
+      /list --<TAB>
+    
+    TEST
+  end
+  
+  desc "create_test_files", "Create test files for demo"
+  def create_test_files
+    puts "Creating test files..."
+    
+    # Create some test files
+    files = [
+      "test_file.txt",
+      "test_data.json",
+      "test_doc.md",
+      "test_config.yaml",
+      "test_log.log"
+    ]
+    
+    files.each do |file|
+      File.write(file, "Test content for #{file}\n")
+      puts "  Created: #{file}"
+    end
+    
+    # Create a test directory
+    Dir.mkdir("test_dir") unless Dir.exist?("test_dir")
+    File.write("test_dir/nested.txt", "Nested file content\n")
+    puts "  Created: test_dir/nested.txt"
+    
+    puts "\nTest files created! Try tab completion with these files."
+  end
+  
+  desc "clean_test_files", "Remove test files"
+  def clean_test_files
+    puts "Cleaning up test files..."
+    
+    files = [
+      "test_file.txt",
+      "test_data.json", 
+      "test_doc.md",
+      "test_config.yaml",
+      "test_log.log",
+      "test_dir/nested.txt"
+    ]
+    
+    files.each do |file|
+      if File.exist?(file)
+        File.delete(file)
+        puts "  Removed: #{file}"
+      end
+    end
+    
+    Dir.rmdir("test_dir") if Dir.exist?("test_dir") && Dir.empty?("test_dir")
+    puts "Cleanup complete!"
+  end
+  
+  default_task :test
+end
+
+if __FILE__ == $0
+  puts "Path Completion Demo"
+  puts "==================="
+  puts
+  puts "Tab completion now supports:"
+  puts "  • File and directory paths"
+  puts "  • Command option names"
+  puts "  • Smart detection of when to complete paths"
+  puts
+  puts "Type '/test' for examples or '/create_test_files' to create test files"
+  puts "Press TAB at any time to see completions!"
+  puts
+  
+  CompletionDemo.new.interactive
+end

data/examples/edge_case_test.rb

@@ -0,0 +1,107 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+require "bundler/setup"
+require "thor/interactive"
+
+class EdgeCaseTest < Thor
+  include Thor::Interactive::Command
+  
+  configure_interactive(
+    prompt: "test> ",
+    default_handler: ->(input, instance) { 
+      puts "DEFAULT HANDLER: '#{input}'"
+    }
+  )
+  
+  desc "topics [FILTER]", "List topics"
+  option :summarize, type: :boolean, desc: "Summarize topics"
+  option :format, type: :string, desc: "Output format"
+  def topics(filter = nil)
+    puts "TOPICS COMMAND:"
+    puts "  Filter: #{filter.inspect}"
+    puts "  Options: #{options.to_h.inspect}"
+  end
+  
+  desc "echo TEXT", "Echo text"
+  def echo(text)
+    puts "ECHO: '#{text}'"
+  end
+  
+  desc "test", "Run edge case tests"
+  def test
+    puts "\n=== Edge Case Tests ==="
+    
+    puts "\n1. Unknown option:"
+    puts "   Input: /topics --unknown-option"
+    process_input("/topics --unknown-option")
+    
+    puts "\n2. Unknown option with value:"
+    puts "   Input: /topics --unknown-option value"
+    process_input("/topics --unknown-option value")
+    
+    puts "\n3. Mixed text and option-like strings:"
+    puts "   Input: /topics The start of a string --option the rest"
+    process_input("/topics The start of a string --option the rest")
+    
+    puts "\n4. Valid option mixed with text:"
+    puts "   Input: /topics Some text --summarize more text"
+    process_input("/topics Some text --summarize more text")
+    
+    puts "\n5. Option-like text in echo command (no options defined):"
+    puts "   Input: /echo This has --what-looks-like an option"
+    process_input("/echo This has --what-looks-like an option")
+    
+    puts "\n6. Real option after text:"
+    puts "   Input: /topics AI and ML --format json"
+    process_input("/topics AI and ML --format json")
+    
+    puts "\n=== End Tests ==="
+  end
+  
+  private
+  
+  def process_input(input)
+    # Simulate what the shell does
+    if input.start_with?('/')
+      send(:handle_slash_command, input[1..-1])
+    else
+      @default_handler.call(input, self)
+    end
+  rescue => e
+    puts "   ERROR: #{e.message}"
+  end
+  
+  def handle_slash_command(command_input)
+    parts = command_input.split(/\s+/, 2)
+    command = parts[0]
+    args = parts[1] || ""
+    
+    if command == "topics"
+      # Parse with shellwords
+      require 'shellwords'
+      parsed = Shellwords.split(args) rescue args.split(/\s+/)
+      invoke("topics", parsed)
+    elsif command == "echo"
+      echo(args)
+    end
+  rescue => e
+    puts "   ERROR: #{e.message}"
+  end
+end
+
+if __FILE__ == $0
+  puts "Edge Case Testing"
+  puts "================="
+  
+  # Create instance and run tests
+  app = EdgeCaseTest.new
+  app.test
+  
+  puts "\nInteractive mode - try these:"
+  puts "  /topics --unknown-option"
+  puts "  /topics The start --option the rest"
+  puts
+  
+  app.interactive
+end

data/examples/options_demo.rb

@@ -0,0 +1,235 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+require "bundler/setup"
+require "thor/interactive"
+
+class OptionsDemo < Thor
+  include Thor::Interactive::Command
+  
+  configure_interactive(
+    prompt: "opts> "
+  )
+  
+  desc "process FILE", "Process a file with various options"
+  option :verbose, type: :boolean, aliases: "-v", desc: "Enable verbose output"
+  option :format, type: :string, default: "json", enum: ["json", "xml", "yaml", "csv"], desc: "Output format"
+  option :output, type: :string, aliases: "-o", desc: "Output file"
+  option :limit, type: :numeric, aliases: "-l", desc: "Limit number of results"
+  option :skip, type: :numeric, default: 0, desc: "Skip N results"
+  option :tags, type: :array, desc: "Tags to filter by"
+  option :config, type: :hash, desc: "Additional configuration"
+  option :dry_run, type: :boolean, desc: "Don't actually process, just show what would happen"
+  def process(file)
+    if options[:dry_run]
+      puts "DRY RUN MODE - No actual processing"
+    end
+    
+    puts "Processing file: #{file}"
+    puts "=" * 50
+    
+    if options[:verbose]
+      puts "Verbose mode enabled"
+      puts "All options:"
+      options.each do |key, value|
+        puts "  #{key}: #{value.inspect}"
+      end
+      puts
+    end
+    
+    puts "Format: #{options[:format]}"
+    puts "Output: #{options[:output] || 'stdout'}"
+    
+    if options[:limit]
+      puts "Limiting to #{options[:limit]} results"
+      puts "Skipping first #{options[:skip]} results" if options[:skip] > 0
+    end
+    
+    if options[:tags] && !options[:tags].empty?
+      puts "Filtering by tags: #{options[:tags].join(', ')}"
+    end
+    
+    if options[:config] && !options[:config].empty?
+      puts "Configuration:"
+      options[:config].each do |key, value|
+        puts "  #{key}: #{value}"
+      end
+    end
+    
+    unless options[:dry_run]
+      puts "\n[Simulating processing...]"
+      sleep(1)
+      puts "✓ Processing complete!"
+    end
+  end
+  
+  desc "search QUERY", "Search with options"
+  option :case_sensitive, type: :boolean, aliases: "-c", desc: "Case sensitive search"
+  option :regex, type: :boolean, aliases: "-r", desc: "Use regex"
+  option :files, type: :array, aliases: "-f", desc: "Files to search in"
+  option :max_results, type: :numeric, default: 10, desc: "Maximum results"
+  def search(query)
+    puts "Searching for: #{query}"
+    puts "Options:"
+    puts "  Case sensitive: #{options[:case_sensitive] ? 'Yes' : 'No'}"
+    puts "  Regex mode: #{options[:regex] ? 'Yes' : 'No'}"
+    puts "  Max results: #{options[:max_results]}"
+    
+    if options[:files]
+      puts "  Searching in files: #{options[:files].join(', ')}"
+    else
+      puts "  Searching in all files"
+    end
+    
+    # Simulate search
+    results = [
+      "result_1.txt:10: #{query} found here",
+      "result_2.txt:25: another #{query} match",
+      "result_3.txt:40: #{query} appears again"
+    ]
+    
+    puts "\nResults:"
+    results.take(options[:max_results]).each do |result|
+      puts "  #{result}"
+    end
+  end
+  
+  desc "convert INPUT OUTPUT", "Convert file from one format to another"
+  option :from, type: :string, required: true, desc: "Input format"
+  option :to, type: :string, required: true, desc: "Output format"
+  option :preserve_metadata, type: :boolean, desc: "Preserve file metadata"
+  option :compression, type: :string, enum: ["none", "gzip", "bzip2", "xz"], default: "none"
+  def convert(input, output)
+    puts "Converting: #{input} → #{output}"
+    puts "Format: #{options[:from]} → #{options[:to]}"
+    puts "Compression: #{options[:compression]}"
+    puts "Preserve metadata: #{options[:preserve_metadata] ? 'Yes' : 'No'}"
+    
+    # Validation
+    unless File.exist?(input)
+      puts "Error: Input file '#{input}' not found"
+      return
+    end
+    
+    puts "\n[Simulating conversion...]"
+    puts "✓ Conversion complete!"
+  end
+  
+  desc "test", "Test various option formats"
+  def test
+    puts "\n=== Option Parsing Test Cases ==="
+    puts "\nTry these commands to test option parsing:\n"
+    
+    examples = [
+      "/process file.txt --verbose",
+      "/process file.txt -v",
+      "/process data.json --format xml --output result.xml",
+      "/process data.json --format=yaml --limit=100",
+      "/process file.txt --tags important urgent todo",
+      "/process file.txt --config env:production db:postgres",
+      "/process file.txt -v --format csv -o output.csv --limit 50",
+      "/process file.txt --dry-run --verbose",
+      "",
+      "/search 'hello world' --case-sensitive",
+      "/search pattern -r -f file1.txt file2.txt file3.txt",
+      "/search query --max-results 5",
+      "",
+      "/convert input.json output.yaml --from json --to yaml",
+      "/convert data.csv data.json --from=csv --to=json --compression=gzip"
+    ]
+    
+    examples.each do |example|
+      puts example.empty? ? "" : "  #{example}"
+    end
+    
+    puts "\n=== Features Demonstrated ==="
+    puts "✓ Boolean options (--verbose, -v)"
+    puts "✓ String options (--format xml, --format=xml)"
+    puts "✓ Numeric options (--limit 100)"
+    puts "✓ Array options (--tags tag1 tag2 tag3)"
+    puts "✓ Hash options (--config key1:val1 key2:val2)"
+    puts "✓ Required options (--from, --to in convert)"
+    puts "✓ Default values (format: json, skip: 0)"
+    puts "✓ Enum validation (format must be json/xml/yaml/csv)"
+    puts "✓ Short aliases (-v for --verbose, -o for --output)"
+    puts "✓ Multiple options in one command"
+  end
+  
+  desc "help_options", "Explain how options work in interactive mode"
+  def help_options
+    puts <<~HELP
+    
+    === Option Parsing in thor-interactive ===
+    
+    Thor-interactive now fully supports Thor's option parsing!
+    
+    BASIC USAGE:
+      /command arg1 arg2 --option value --flag
+    
+    OPTION TYPES:
+      Boolean:  --verbose or -v (no value needed)
+      String:   --format json or --format=json
+      Numeric:  --limit 100 or --limit=100
+      Array:    --tags tag1 tag2 tag3
+      Hash:     --config key1:val1 key2:val2
+    
+    FEATURES:
+      • Long form: --option-name value
+      • Short form: -o value
+      • Equals syntax: --option=value
+      • Multiple options: --opt1 val1 --opt2 val2
+      • Default values: Defined in Thor command
+      • Required options: Must be provided
+      • Enum validation: Limited to specific values
+    
+    BACKWARD COMPATIBILITY:
+      • Commands without options work as before
+      • Natural language still works for text commands
+      • Single-text commands preserve their behavior
+      • Default handler unaffected
+    
+    EXAMPLES:
+      # Boolean flag
+      /process file.txt --verbose
+      
+      # String option with equals
+      /process file.txt --format=xml
+      
+      # Multiple options
+      /process file.txt -v --format csv --limit 10
+      
+      # Array option
+      /search term --files file1.txt file2.txt
+      
+      # Hash option  
+      /deploy --config env:prod region:us-west
+    
+    HOW IT WORKS:
+      1. Thor-interactive detects if command has options defined
+      2. Uses Thor's option parser to parse the arguments
+      3. Separates options from regular arguments
+      4. Sets options hash on Thor instance
+      5. Calls command with remaining arguments
+      6. Falls back to original behavior if parsing fails
+    
+    NATURAL LANGUAGE:
+      Natural language input still works! Options are only
+      parsed for Thor commands that define them. Text sent
+      to default handlers is unchanged.
+    
+    HELP
+  end
+  
+  default_task :test
+end
+
+if __FILE__ == $0
+  puts "Thor Options Demo"
+  puts "=================="
+  puts
+  puts "This demo shows Thor option parsing in interactive mode."
+  puts "Type '/test' to see examples or '/help_options' for details."
+  puts
+  
+  OptionsDemo.new.interactive
+end

data/lib/thor/interactive/shell.rb

@@ -149,10 +149,182 @@ class Thor
       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
+        # Parse the command and check what we're completing
+        parts = preposing.split(/\s+/)
+        command = parts[0].sub(/^\//, '') if parts[0]
+
+        # Check if this is a subcommand
+        subcommand_class = @thor_class.subcommand_classes[command] if command
+        if subcommand_class
+          return complete_subcommand_args(subcommand_class, text, parts)
+        end
+
+        # Get the Thor task if it exists
+        task = @thor_class.tasks[command] if command
+
+        # Check if we're likely completing a path
+        if path_like?(text) || after_path_option?(preposing)
+          complete_path(text)
+        elsif text.start_with?('--') || text.start_with?('-')
+          # Complete option names
+          complete_option_names(task, text)
+        else
+          # Default to path completion for positional args that might be files
+          # This helps with commands that take file arguments
+          complete_path(text)
+        end
+      end
+
+      def complete_subcommand_args(subcommand_class, text, parts)
+        # parts[0] = "/db" or "db", parts[1..] = subcommand args
+        if parts.length <= 1
+          # No subcommand yet typed, complete subcommand names
+          # e.g. "/db <TAB>"
+          complete_subcommands(subcommand_class, text)
+        else
+          # A subcommand name has been typed, check for option completion
+          sub_cmd_name = parts[1]
+          sub_task = subcommand_class.tasks[sub_cmd_name]
+
+          if text.start_with?('--') || text.start_with?('-')
+            complete_option_names(sub_task, text)
+          else
+            # Could be completing a subcommand name or a positional arg
+            if parts.length == 2 && !text.empty?
+              # Still typing the subcommand name, e.g. "/db cr<TAB>"
+              # But only if 'text' is part of a subcommand name being typed
+              # (parts[1] is the preposing word, text is what's being completed)
+              complete_subcommands(subcommand_class, text)
+            else
+              complete_path(text)
+            end
+          end
+        end
+      end
+
+      def complete_subcommands(subcommand_class, text)
+        return [] if text.nil?
+
+        command_names = subcommand_class.tasks.keys
+        command_names.select { |cmd| cmd.start_with?(text) }.sort
+      end
+      
+      def path_like?(text)
+        # Check if text looks like a path
+        text.match?(%r{^[~./]|/}) || text.match?(/\.(txt|rb|md|json|xml|yaml|yml|csv|log|html|css|js)$/i)
+      end
+      
+      def after_path_option?(preposing)
+        # Check if we're after a common file/path option
+        preposing.match?(/(?:--file|--output|--input|--path|--dir|--directory|-f|-o|-i|-d)\s*$/)
+      end
+      
+      def complete_path(text)
+        return [] if text.nil?
+        
+        # Special case for empty text - show files in current directory
+        if text.empty?
+          matches = Dir.glob("*", File::FNM_DOTMATCH).select do |path|
+            basename = File.basename(path)
+            basename != '.' && basename != '..'
+          end
+          return format_path_completions(matches, text)
+        end
+        
+        # Expand ~ to home directory for matching
+        expanded = text.start_with?('~') ? File.expand_path(text) : text
+        
+        # Determine directory and prefix for matching
+        if text.end_with?('/')
+          # User typed a directory with trailing slash - show its contents
+          dir = expanded
+          prefix = ''
+        elsif File.directory?(expanded) && !text.end_with?('/')
+          # It's a directory without trailing slash - complete the directory name
+          dir = File.dirname(expanded)
+          prefix = File.basename(expanded)
+        else
+          # Completing a partial filename
+          dir = File.dirname(expanded)
+          prefix = File.basename(expanded)
+        end
+        
+        # Get matching files/dirs
+        pattern = File.join(dir, "#{prefix}*")
+        matches = Dir.glob(pattern, File::FNM_DOTMATCH).select do |path|
+          # Filter out . and .. entries
+          basename = File.basename(path)
+          basename != '.' && basename != '..'
+        end
+        
+        format_path_completions(matches, text)
+      rescue => e
+        # If path completion fails, return empty array
         []
       end
+      
+      def format_path_completions(matches, original_text)
+        # Format the completions based on how the user typed the path
+        matches.map do |path|
+          # Add trailing / for directories
+          display_path = File.directory?(path) && !path.end_with?('/') ? "#{path}/" : path
+          
+          # Handle paths with spaces by escaping them
+          display_path = display_path.gsub(' ', '\ ')
+          
+          # Return path as user would type it
+          if original_text.start_with?('~')
+            # Replace home directory with ~
+            home = ENV['HOME']
+            if display_path.start_with?(home)
+              "~#{display_path[home.length..-1]}"
+            else
+              display_path.sub(ENV['HOME'], '~')
+            end
+          elsif original_text.start_with?('./')
+            # Keep ./ prefix and make path relative
+            if display_path.start_with?(Dir.pwd)
+              rel_path = display_path.sub(/^#{Regexp.escape(Dir.pwd)}\//, '')
+              "./#{rel_path}"
+            else
+              # Already relative, just ensure ./ prefix
+              display_path.start_with?('./') ? display_path : "./#{File.basename(display_path)}"
+            end
+          elsif original_text.start_with?('/')
+            # Absolute path - return as is
+            display_path
+          else
+            # Relative path without ./ prefix
+            # If the matched path is in current dir, just return the basename
+            dir = File.dirname(display_path)
+            if dir == '.' || display_path.start_with?('./')
+              basename = File.basename(display_path)
+              basename += '/' if File.directory?(display_path.gsub('\ ', ' ')) && !basename.end_with?('/')
+              basename
+            else
+              display_path.sub(/^#{Regexp.escape(Dir.pwd)}\//, '')
+            end
+          end
+        end.sort
+      end
+      
+      def complete_option_names(task, text)
+        return [] unless task && task.options
+        
+        # Get all option names (long and short forms)
+        options = []
+        task.options.each do |name, option|
+          options << "--#{name}"
+          if option.aliases
+            # Aliases can be string or array
+            aliases = option.aliases.is_a?(Array) ? option.aliases : [option.aliases]
+            aliases.each { |a| options << a if a.start_with?('-') }
+          end
+        end
+        
+        # Filter by what user has typed
+        options.select { |opt| opt.start_with?(text) }.sort
+      end
 
       def process_input(input)
         # Handle completely empty input
@@ -205,8 +377,8 @@ class Thor
         if thor_command?(command_word)
           task = @thor_class.tasks[command_word]
           
-          if task && single_text_command?(task)
-            # Single text command - pass everything after command as one argument
+          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, [])
@@ -295,13 +467,32 @@ class Thor
         if command == "help"
           show_help(args.first)
         else
-          # Always use direct method calls to avoid Thor's invoke deduplication
-          # Thor's invoke method silently fails on subsequent calls to the same method
-          if @thor_instance.respond_to?(command)
-            @thor_instance.send(command, *args)
+          # 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
+            result = parse_thor_options(args, task)
+            return unless result # Parse failed, error already shown
+
+            parsed_args, parsed_options = result
+
+            # 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
-            # If method doesn't exist, this will raise a proper error
-            @thor_instance.send(command, *args)
+            # 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
@@ -320,9 +511,53 @@ class Thor
         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 = {}
+
+        begin
+          # Create a temporary parser using Thor's options
+          parser = Thor::Options.new(task.options)
+
+          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
+          # Show user-friendly error for option parsing failures (e.g. invalid numeric value)
+          puts "Option error: #{e.message}"
+          return nil
+        end
+
+        # Check for unknown options left in remaining args
+        unknown = remaining_args.select { |a| a.start_with?('--') || (a.start_with?('-') && a.length > 1 && !a.match?(/^-\d/)) }
+        unless unknown.empty?
+          puts "Unknown option#{'s' if unknown.length > 1}: #{unknown.join(', ')}"
+          puts "Run '/help #{task.name}' to see available options."
+          return nil
+        end
+
+        [remaining_args, parsed_options]
+      end
 
       def show_help(command = nil)
-        if command && @thor_class.tasks.key?(command)
+        if command && @thor_class.subcommand_classes.key?(command)
+          # Show help for a subcommand — list its available commands
+          subcommand_class = @thor_class.subcommand_classes[command]
+          puts "Commands for '#{command}':"
+          subcommand_class.tasks.each do |name, task|
+            puts "  /#{command} #{name.ljust(15)} #{task.description}"
+          end
+          puts
+        elsif command && @thor_class.tasks.key?(command)
           @thor_class.command_help(Thor::Base.shell.new, command)
         else
           puts "Available commands (prefix with /):"

data/lib/thor/interactive/version_constant.rb

@@ -4,5 +4,5 @@
 # This file is separate to avoid circular dependencies during gem installation
 
 module ThorInteractive
-  VERSION = "0.1.0.pre.3"
+  VERSION = "0.1.0.pre.5"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: thor-interactive
 version: !ruby/object:Gem::Version
-  version: 0.1.0.pre.3
+  version: 0.1.0.pre.5
 platform: ruby
 authors:
 - Chris Petersen
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2025-09-08 00:00:00.000000000 Z
+date: 2026-01-28 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: thor
@@ -54,8 +54,11 @@ files:
 - README.md
 - Rakefile
 - examples/README.md
+- examples/completion_demo.rb
 - examples/demo_session.rb
+- examples/edge_case_test.rb
 - examples/nested_example.rb
+- examples/options_demo.rb
 - examples/sample_app.rb
 - examples/signal_demo.rb
 - examples/test_interactive.rb