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

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 04a0318e910fee2ac10a134b2a9514ceef72921c2b1525d29face4c46a306ad8
-  data.tar.gz: 1376543ed73e25721cb220893cb62fbe0fb6bc18d94ea38ecf00df60878fd4d1
+  metadata.gz: c927c297d565d278a09334334217dca98c5e05e72277f7fec4f5d07568f19c30
+  data.tar.gz: 353b4acde28a2a780a2b7a1ce85d7fb6e510f20d2862dd3dc4b2505140e2c014
 SHA512:
-  metadata.gz: '05909f8f5c99a783831eec436ee94236b279b883c2cda0c62379081c28cc7258d8ab8317dfa4d3aba36c942f763767eed1dc08d45427ee05c00b7513f8488af9'
-  data.tar.gz: 16a55871f6754affc2450703f3de24ecfee977ca372566b93dc44537cd3599bf305ecd988ec7f06349c786df9f0f7ab2e5bfed7d608390e53fedc6bdeb05f1cb
+  metadata.gz: 77f42909ede7bb049ea1675bc2ccc4f486437be713bc2dd9c16cb5bfdd98b8723b77cacb87147335cb85d439f79c57b0ae18f0bbb0d874f80dd56b27a39bd5c9
+  data.tar.gz: 11f5c9a01fa32839b669d968c7cb154827bfd4cbe910c272094403280193c5115bef46fa4eb430ad476f9437d75fe13a515f12eadaa1d91080e48d4724c4866d

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/examples/signal_demo.rb

@@ -0,0 +1,203 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+require "bundler/setup"
+require "thor/interactive"
+
+class SignalDemo < Thor
+  include Thor::Interactive::Command
+  
+  configure_interactive(
+    prompt: "signal> ",
+    ctrl_c_behavior: :clear_prompt,  # Default
+    double_ctrl_c_timeout: 0.5        # 500ms window for double Ctrl-C
+  )
+  
+  desc "slow", "Simulate a slow command"
+  def slow
+    puts "Starting slow operation..."
+    5.times do |i|
+      puts "Step #{i + 1}/5"
+      sleep(1)
+    end
+    puts "Done!"
+  rescue Interrupt
+    puts "\nOperation cancelled!"
+  end
+  
+  desc "loop", "Run an infinite loop (test Ctrl-C)"
+  def loop
+    puts "Starting infinite loop (press Ctrl-C to stop)..."
+    counter = 0
+    while true
+      print "\rCounter: #{counter}"
+      counter += 1
+      sleep(0.1)
+    end
+  rescue Interrupt
+    puts "\nLoop stopped at #{counter}"
+  end
+  
+  desc "input", "Test input with special text"
+  def input
+    puts "Type something with Ctrl chars:"
+    puts "  - Ctrl-C to clear and start over"
+    puts "  - Ctrl-D to cancel"
+    puts "  - Enter to submit"
+    
+    print "input> "
+    begin
+      text = $stdin.gets
+      if text
+        puts "You entered: #{text.inspect}"
+      else
+        puts "Cancelled with Ctrl-D"
+      end
+    rescue Interrupt
+      puts "\nInterrupted - input cancelled"
+    end
+  end
+  
+  desc "behaviors", "Demo different Ctrl-C behaviors"
+  def behaviors
+    puts "\n=== Ctrl-C Behavior Options ==="
+    puts
+    puts "1. :clear_prompt (default)"
+    puts "   - Shows ^C and hint message"
+    puts "   - Clear and friendly"
+    
+    puts "\n2. :show_help"
+    puts "   - Shows help reminder"
+    puts "   - Good for new users"
+    
+    puts "\n3. :silent"
+    puts "   - Just clears the line"
+    puts "   - Minimal interruption"
+    
+    puts "\nYou can configure with:"
+    puts "  configure_interactive(ctrl_c_behavior: :show_help)"
+  end
+  
+  desc "test_clear", "Test with clear_prompt behavior"
+  def test_clear
+    puts "Starting new shell with :clear_prompt behavior"
+    puts "Try pressing Ctrl-C..."
+    puts
+    
+    SignalDemo.new.interactive
+  end
+  
+  desc "test_help", "Test with show_help behavior"
+  def test_help
+    puts "Starting new shell with :show_help behavior"
+    puts "Try pressing Ctrl-C..."
+    puts
+    
+    test_app = Class.new(Thor) do
+      include Thor::Interactive::Command
+      configure_interactive(
+        prompt: "help> ",
+        ctrl_c_behavior: :show_help
+      )
+      
+      desc "test", "Test command"
+      def test
+        puts "Test executed"
+      end
+    end
+    
+    test_app.new.interactive
+  end
+  
+  desc "test_silent", "Test with silent behavior"
+  def test_silent
+    puts "Starting new shell with :silent behavior"
+    puts "Try pressing Ctrl-C..."
+    puts
+    
+    test_app = Class.new(Thor) do
+      include Thor::Interactive::Command
+      configure_interactive(
+        prompt: "silent> ",
+        ctrl_c_behavior: :silent
+      )
+      
+      desc "test", "Test command"
+      def test
+        puts "Test executed"
+      end
+    end
+    
+    test_app.new.interactive
+  end
+  
+  desc "help_signals", "Explain signal handling"
+  def help_signals
+    puts <<~HELP
+    
+    === Signal Handling in thor-interactive ===
+    
+    CTRL-C (SIGINT):
+      Single Press:
+        - Clears current input line
+        - Shows hint about double Ctrl-C
+        - Returns to fresh prompt
+        
+      Double Press (within 500ms):
+        - Exits the interactive shell
+        - Same as typing 'exit'
+    
+    CTRL-D (EOF):
+      - Exits immediately
+      - Standard Unix EOF behavior
+      - Same as typing 'exit'
+    
+    EXIT COMMANDS:
+      - exit
+      - quit  
+      - q
+      - /exit, /quit, /q (with slash)
+    
+    CONFIGURATION:
+      configure_interactive(
+        ctrl_c_behavior: :clear_prompt,  # or :show_help, :silent
+        double_ctrl_c_timeout: 0.5        # seconds
+      )
+    
+    BEHAVIOR OPTIONS:
+      :clear_prompt (default)
+        Shows "^C" and hint message
+        
+      :show_help
+        Shows help reminder on Ctrl-C
+        
+      :silent
+        Just clears the line, no message
+    
+    WHY THIS DESIGN?
+      - Matches behavior of Python, Node.js REPLs
+      - Prevents accidental exit
+      - Clear feedback to user
+      - Configurable for different preferences
+    
+    HELP
+  end
+  
+  default_task :help_signals
+end
+
+if __FILE__ == $0
+  puts "Signal Handling Demo"
+  puts "==================="
+  puts
+  puts "Try these:"
+  puts "  1. Press Ctrl-C once (clears prompt)"
+  puts "  2. Press Ctrl-C twice quickly (exits)"
+  puts "  3. Press Ctrl-D (exits immediately)"
+  puts "  4. Type 'exit', 'quit', or 'q' (exits)"
+  puts
+  puts "Starting interactive shell..."
+  puts
+  
+  SignalDemo.new.interactive
+end

data/lib/thor/interactive/shell.rb

@@ -29,6 +29,12 @@ class Thor
         @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) ? 
+                                merged_options[:double_ctrl_c_timeout] : 0.5
+        @last_interrupt_time = nil
+        
         setup_completion
         load_history
       end
@@ -56,27 +62,36 @@ class Thor
         puts "(Debug: Entering main loop)" if ENV["DEBUG"]
         
         loop do
-          line = Reline.readline(display_prompt, true)
-          puts "(Debug: Got input: #{line.inspect})" if ENV["DEBUG"]
-          
-          if should_exit?(line)
-            puts "(Debug: Exit condition met)" if ENV["DEBUG"]
-            break
-          end
-          
-          next if line.nil? || line.strip.empty?
-          
           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
-            puts "\n(Interrupted - press Ctrl+D or type 'exit' to quit)"
+            # Handle Ctrl-C
+            if handle_interrupt
+              break  # Exit on double Ctrl-C
+            end
+            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"]
           rescue => e
-            puts "Error in main loop: #{e.message}"
+            puts "Error: #{e.message}"
             puts e.backtrace.first(5) if ENV["DEBUG"]
             puts "(Debug: Error handled, continuing loop)" if ENV["DEBUG"]
             # Continue the loop - don't let errors break the session
@@ -190,8 +205,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, [])
@@ -280,13 +295,29 @@ 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
+            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
-            # 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
@@ -305,6 +336,36 @@ 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 = {}
+        
+        # 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)
@@ -343,6 +404,37 @@ class Thor
         # 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
+        end
+        
+        @last_interrupt_time = current_time
+        
+        # Single Ctrl-C behavior
+        case @ctrl_c_behavior
+        when :clear_prompt
+          puts "^C"
+          puts "(Press Ctrl-C again quickly or Ctrl-D to exit)"
+        when :show_help
+          puts "\n^C - Interrupt"
+          puts "Press Ctrl-C again to exit, or type 'help' for commands"
+        when :silent
+          # Just clear the line, no message
+          print "\r#{' ' * 80}\r"
+        else
+          # Default behavior
+          puts "^C"
+        end
+        
+        false  # Don't exit, just clear prompt
+      end
 
       def show_welcome(nesting_level = 0)
         if nesting_level > 0

data/lib/thor/interactive/version.rb

@@ -1,9 +1,10 @@
 # frozen_string_literal: true
 
 require "thor"
+require_relative "version_constant"
 
 class Thor
   module Interactive
-    VERSION = "0.1.0.pre.2"
+    VERSION = ThorInteractive::VERSION
   end
 end

data/lib/thor/interactive/version_constant.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+# Version constant for thor-interactive gem
+# This file is separate to avoid circular dependencies during gem installation
+
+module ThorInteractive
+  VERSION = "0.1.0.pre.4"
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: thor-interactive
 version: !ruby/object:Gem::Version
-  version: 0.1.0.pre.2
+  version: 0.1.0.pre.4
 platform: ruby
 authors:
 - Chris Petersen
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2025-09-07 00:00:00.000000000 Z
+date: 2025-09-08 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: thor
@@ -55,13 +55,17 @@ files:
 - Rakefile
 - examples/README.md
 - 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
 - lib/thor/interactive.rb
 - lib/thor/interactive/command.rb
 - lib/thor/interactive/shell.rb
 - lib/thor/interactive/version.rb
+- lib/thor/interactive/version_constant.rb
 - sig/thor/interactive.rbs
 homepage: https://github.com/scientist-labs/thor-interactive
 licenses: