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

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 9e51ddada105bae31b9bc637ed25fd88e4908c281c16779b46d023d16f31db4e
-  data.tar.gz: cbccf2e8dc47f73e7f1c101bd1a0dce0c2fa51cc21f9a26e24ed7f577245d2cf
+  metadata.gz: '049af6f0fedd7bda65c5845a878bd02afe8e9e5cf705ebad254c333e0151ecd7'
+  data.tar.gz: '049e366b5d3d1e4d0076c7c69d69240b00f0768b3b2687d23e9482dd7bf368dd'
 SHA512:
-  metadata.gz: 0ea62f18e17ab19662bd3c8fac62dce8dd69582adc857664901e69729670d8de690161a111151df1ab4ee7b403521b9e9254d9d67942bdc36f244278887d2b21
-  data.tar.gz: a566b97836f0a11b75e35e35692f0996d3817b5b34dfa2d3c169d84dd125cac453cbeac14bfb76cd99f3253d144b4b550fd3e7a939f7b711e27a114242df2997
+  metadata.gz: bc5ccc2b2765f3f5c4591c181445dbc4b0ef66982c982758fb6053fa79de968c7583f019be85a747c51474e6e2f55f8834b9c4fd3314b1186dd6185a9be9e092
+  data.tar.gz: cc284a24f5f2a24bb016651e4252a9230d89c84d0e86b382fb4b936d11063422f78338d4c0917aedcf0a6e6d9fe7dcb66f8e7fb22c479c2903f355265e00cc79

data/README.md

@@ -55,10 +55,11 @@ Now your app supports both modes:
 # Normal CLI usage (unchanged)
 ruby myapp.rb hello World
 
-# New interactive mode
+# New interactive mode with slash commands
 ruby myapp.rb interactive
-myapp> hello Alice
+myapp> /hello Alice
 Hello Alice!
+myapp> Natural language input goes to default handler
 myapp> exit
 ```
 
@@ -116,19 +117,25 @@ In interactive mode:
 ```bash
 ruby rag_app.rb interactive
 
-rag> ask "What is Ruby?"
-# LLM initializes once
+rag> /ask What is Ruby?
+# LLM initializes once  
 Ruby is a programming language...
 
-rag> ask "Tell me more"
+rag> /ask Tell me more
 # LLM client reused, conversation context maintained
 Based on our previous discussion about Ruby...
 
-rag> history
+rag> What's the difference between Ruby and Python?
+# Natural language goes directly to default handler (ask command)
+Ruby and Python differ in several ways...
+
+rag> /history  
 1. Q: What is Ruby?
    A: Ruby is a programming language...
 2. Q: Tell me more
    A: Based on our previous discussion about Ruby...
+3. Q: What's the difference between Ruby and Python?
+   A: Ruby and Python differ in several ways...
 ```
 
 ## Configuration
@@ -145,7 +152,10 @@ class MyApp < Thor
     nested_prompt_format: "[L%d] %s",    # Format for nested prompts (if allowed)
     default_handler: proc do |input, thor_instance|
       # Handle unrecognized input
-      thor_instance.invoke(:search, [input])
+      # IMPORTANT: Use direct method calls, NOT invoke(), to avoid Thor's
+      # silent failure on repeated calls to the same method
+      thor_instance.search(input)  # ✅ Works repeatedly
+      # thor_instance.invoke(:search, [input])  # ❌ Fails after first call
     end
   )
 
@@ -226,6 +236,28 @@ advanced> exit
 Goodbye!
 ```
 
+### ⚠️ Important: Default Handler Implementation
+
+**Always use direct method calls in default handlers, NOT `invoke()`:**
+
+```ruby
+# ✅ CORRECT - Works for repeated calls
+configure_interactive(
+  default_handler: proc do |input, thor_instance|
+    thor_instance.ask(input)  # Direct method call
+  end
+)
+
+# ❌ WRONG - Silent failure after first call  
+configure_interactive(
+  default_handler: proc do |input, thor_instance|
+    thor_instance.invoke(:ask, [input])  # Thor's invoke fails silently on repeat calls
+  end
+)
+```
+
+**Why:** Thor's `invoke` method has internal deduplication that prevents repeated calls to the same method on the same instance. This causes silent failures in interactive mode where users expect to be able to repeat commands.
+
 ## Advanced Usage
 
 ### Custom Options
@@ -303,13 +335,14 @@ After checking out the repo:
 
 ```bash
 bundle install           # Install dependencies
-bundle exec rspec        # Run full test suite
+bundle exec rspec        # Run full test suite with coverage
 bundle exec rake build   # Build gem
+open coverage/index.html # View coverage report (after running tests)
 ```
 
 ### Testing
 
-The gem includes comprehensive tests organized into unit and integration test suites:
+The gem includes comprehensive tests organized into unit and integration test suites with **72%+ code coverage**:
 
 ```bash
 # Run all tests
@@ -318,6 +351,9 @@ bundle exec rspec
 # Run with detailed output
 bundle exec rspec --format documentation
 
+# View coverage report
+open coverage/index.html      # Detailed HTML coverage report
+
 # Run specific test suites
 bundle exec rspec spec/unit/           # Unit tests only
 bundle exec rspec spec/integration/    # Integration tests only

data/examples/README.md

@@ -26,49 +26,55 @@ ruby sample_app.rb interactive
 Once in interactive mode:
 
 ```
-sample> hello Alice
+sample> /hello Alice
 Hello Alice!
 
-sample> count
+sample> /count
 Count: 1
 
-sample> count  
+sample> /count  
 Count: 2
 
-sample> add "First item"
+sample> /add First item
 Added 'First item'. Total items: 1
 
-sample> add "Second item"  
+sample> /add Second item  
 Added 'Second item'. Total items: 2
 
-sample> list
+sample> /list
 Items:
   1. First item
   2. Second item
 
-sample> status
+sample> /status
 Application Status:
   Counter: 2
   Items in list: 2
   Memory usage: 15234 KB
 
-sample> This is unrecognized text
-Echo: This is unrecognized text
+sample> This is unrecognized text that doesn't need quotes
+Echo: This is unrecognized text that doesn't need quotes
 
-sample> help
-Available commands:
-  hello                Say hello to NAME
-  count                Show and increment counter (demonstrates state persistence)
-  add                  Add item to list (demonstrates state persistence)
-  list                 Show all items
-  clear                Clear all items
-  echo                 Echo the text back (used as default handler)
-  status               Show application status
-  interactive          Start an interactive REPL for this application
+sample> What about text with "quotes" and apostrophes?
+Echo: What about text with "quotes" and apostrophes?
+
+sample> /help
+Available commands (prefix with /):
+  /hello               Say hello to NAME
+  /count               Show and increment counter (demonstrates state persistence)
+  /add                 Add item to list (demonstrates state persistence)
+  /list                Show all items
+  /clear               Clear all items
+  /echo                Echo the text back (used as default handler)
+  /status              Show application status
+  /interactive         Start an interactive REPL for this application
 
 Special commands:
-  help [COMMAND]       Show help for command
-  exit/quit/q          Exit the REPL
+  /help [COMMAND]      Show help for command
+  /exit, /quit, /q     Exit the REPL
+
+Natural language mode:
+  Type anything without / to use default handler
 
 sample> exit
 Goodbye!
@@ -81,16 +87,17 @@ Goodbye!
 - In normal CLI mode, each command starts fresh
 
 ### 2. Auto-completion
-- Tab completion works for command names
-- Try typing `h<TAB>` or `a<TAB>` to see completions
+- Tab completion works for command names with slash prefix
+- Try typing `/h<TAB>` or `/co<TAB>` to see completions
 
-### 3. Default Handler
-- Text that doesn't match a command gets sent to the `echo` command
-- This is configurable via the `default_handler` option
+### 3. Natural Language Mode
+- Text without `/` prefix gets sent to the configured default handler
+- No need to worry about quoting or escaping in natural language
+- Perfect for LLM interfaces and conversational commands
 
 ### 4. Built-in Help
-- `help` shows all available commands
-- `help COMMAND` shows help for a specific command
+- `/help` shows all available commands  
+- `/help COMMAND` shows help for a specific command
 
 ### 5. History
 - Up/down arrows navigate command history
@@ -98,7 +105,7 @@ Goodbye!
 
 ### 6. Graceful Exit
 - Ctrl+C interrupts current operation
-- Ctrl+D or `exit`/`quit`/`q` exits the REPL
+- Ctrl+D, `exit`, `quit`, `q`, `/exit`, `/quit`, or `/q` exits the REPL
 
 ## Integration Patterns
 

data/examples/sample_app.rb

@@ -15,7 +15,9 @@ class SampleApp < Thor
     allow_nested: false,  # Prevent nested interactive sessions by default
     default_handler: proc do |input, thor_instance|
       # Send unrecognized input to the 'echo' command
-      thor_instance.invoke(:echo, [input])
+      # IMPORTANT: Use direct method calls, NOT invoke(), to avoid Thor's
+      # silent deduplication that prevents repeated calls to the same method
+      thor_instance.echo(input)
     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/command.rb

@@ -38,6 +38,16 @@ class Thor
         def configure_interactive(**options)
           interactive_options.merge!(options)
         end
+
+        # Check if currently running in interactive mode
+        def interactive?
+          ENV['THOR_INTERACTIVE_SESSION'] == 'true'
+        end
+      end
+
+      # Instance method version for use in commands
+      def interactive?
+        self.class.interactive?
       end
     end
   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
@@ -41,6 +47,8 @@ class Thor
         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]
@@ -51,20 +59,46 @@ class Thor
         
         show_welcome(nesting_level)
         
+        puts "(Debug: Entering main loop)" if ENV["DEBUG"]
+        
         loop do
-          line = Reline.readline(display_prompt, true)
-          break if should_exit?(line)
-          
-          next if line.nil? || line.strip.empty?
-          
-          process_input(line.strip)
-        rescue Interrupt
-          puts "\n(Interrupted - press Ctrl+D or type 'exit' to quit)"
-        rescue => e
-          puts "Error: #{e.message}"
-          puts e.backtrace.first(3) if ENV["DEBUG"]
+          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
+            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: #{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
+          end
         end
         
+        puts "(Debug: Exited main loop)" if ENV["DEBUG"]
         save_history
         puts nesting_level > 0 ? "Exiting nested session..." : "Goodbye!"
         
@@ -88,12 +122,22 @@ class Thor
       end
 
       def complete_input(text, preposing)
-        # If we're at the start of the line, complete command names
-        if preposing.strip.empty?
-          complete_commands(text)
+        # 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
-          # Try to complete command options or let it fall back to file completion
-          complete_command_options(text, preposing)
+          # Natural language mode - no completion for now
+          []
         end
       end
 
@@ -114,25 +158,130 @@ class Thor
         # Handle completely empty input
         return if input.nil? || input.strip.empty?
 
-        args = parse_input(input)
-        return if args.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
 
-        command = args.shift
+      def handle_slash_command(command_input)
+        return if command_input.empty?
+        handle_command(command_input)
+      end
 
-        if thor_command?(command)
-          invoke_thor_command(command, args)
-        elsif @default_handler
-          @default_handler.call(input, @thor_instance)
+      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)
+            # Single text command - 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}'. Type 'help' for available commands."
+          puts "Unknown command: '#{command_word}'. Type '/help' for available commands."
         end
       end
 
-      def parse_input(input)
+      def safe_parse_input(input)
+        # Try proper shell parsing first
         Shellwords.split(input)
-      rescue ArgumentError => e
-        puts "Error parsing input: #{e.message}"
-        []
+      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)
@@ -146,14 +295,22 @@ class Thor
         if command == "help"
           show_help(args.first)
         else
-          # For simple commands, call directly for state persistence
-          # For complex options/subcommands, this is a basic implementation
+          # 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)
           else
-            @thor_instance.invoke(command, args)
+            # If method doesn't exist, this will raise a proper error
+            @thor_instance.send(command, *args)
           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
@@ -161,21 +318,36 @@ class Thor
         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 show_help(command = nil)
         if command && @thor_class.tasks.key?(command)
           @thor_class.command_help(Thor::Base.shell.new, command)
         else
-          puts "Available commands:"
+          puts "Available commands (prefix with /):"
           @thor_class.tasks.each do |name, task|
-            puts "  #{name.ljust(20)} #{task.description}"
+            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 "  /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
 
@@ -183,7 +355,39 @@ class Thor
         return true if line.nil? # Ctrl+D
         
         stripped = line.strip.downcase
-        EXIT_COMMANDS.include?(stripped)
+        # 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)

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.1"
+    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.3"
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: thor-interactive
 version: !ruby/object:Gem::Version
-  version: 0.1.0.pre.1
+  version: 0.1.0.pre.3
 platform: ruby
 authors:
 - Chris Petersen
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2025-09-06 00:00:00.000000000 Z
+date: 2025-09-08 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: thor
@@ -57,11 +57,13 @@ files:
 - examples/demo_session.rb
 - examples/nested_example.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: