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

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 9e51ddada105bae31b9bc637ed25fd88e4908c281c16779b46d023d16f31db4e
-  data.tar.gz: cbccf2e8dc47f73e7f1c101bd1a0dce0c2fa51cc21f9a26e24ed7f577245d2cf
+  metadata.gz: 04a0318e910fee2ac10a134b2a9514ceef72921c2b1525d29face4c46a306ad8
+  data.tar.gz: 1376543ed73e25721cb220893cb62fbe0fb6bc18d94ea38ecf00df60878fd4d1
 SHA512:
-  metadata.gz: 0ea62f18e17ab19662bd3c8fac62dce8dd69582adc857664901e69729670d8de690161a111151df1ab4ee7b403521b9e9254d9d67942bdc36f244278887d2b21
-  data.tar.gz: a566b97836f0a11b75e35e35692f0996d3817b5b34dfa2d3c169d84dd125cac453cbeac14bfb76cd99f3253d144b4b550fd3e7a939f7b711e27a114242df2997
+  metadata.gz: '05909f8f5c99a783831eec436ee94236b279b883c2cda0c62379081c28cc7258d8ab8317dfa4d3aba36c942f763767eed1dc08d45427ee05c00b7513f8488af9'
+  data.tar.gz: 16a55871f6754affc2450703f3de24ecfee977ca372566b93dc44537cd3599bf305ecd988ec7f06349c786df9f0f7ab2e5bfed7d608390e53fedc6bdeb05f1cb

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/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

@@ -41,6 +41,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 +53,37 @@ 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)
+          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?
           
-          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
+            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)"
+          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 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 +107,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 +143,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 +280,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 +303,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 +340,8 @@ 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 show_welcome(nesting_level = 0)

data/lib/thor/interactive/version.rb

@@ -4,6 +4,6 @@ require "thor"
 
 class Thor
   module Interactive
-    VERSION = "0.1.0.pre.1"
+    VERSION = "0.1.0.pre.2"
   end
 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.2
 platform: ruby
 authors:
 - Chris Petersen
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2025-09-06 00:00:00.000000000 Z
+date: 2025-09-07 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: thor