pattern-ruby 0.1.0 → 0.1.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 76b9f40922a19e84b9da9c7a0ccb8027b6a3d99f75782a248c8edd3111bf063f
-  data.tar.gz: b7d845a9dff5e5e479d3f74e5268d118da67cbe821450be6bb5e32586402a333
+  metadata.gz: f811da9c8851dd1ac42ed24ab7db8b93a05bcefd61d9c76a66676e3c97cbdf15
+  data.tar.gz: 3b282051dfbd99a38a5960d6ce46e7637b5ba63a1c2d9bbcae908ba58af7e558
 SHA512:
-  metadata.gz: de646d6f5b0c9a8924a835986b55c4c33ae10da4b96040ce53e5ba6392ecf40520879d66f39f2655f88d84745a41ea7856f6d5a42b4653483eaa53080ce7aed9
-  data.tar.gz: 3fea24e0b08f2620e4b3da933a60d44abc9371283feab5648b2c8630f5fd69b41a0bf8e37c5c18065e678f491ee2f5f5c5cc2bc804c92437de46a412ad167512
+  metadata.gz: 13de001ca6e9657cf5faa5ec36bf5ffc5522d957fd54b92c7b13a7d72e0748582f566208dc8b93307d78aa44aa5607ec0234a73443a36bb8ec75a8eb763544dc
+  data.tar.gz: db8cd6c927e091c6bbdacc9a50e75e454041342fb2cfd9378ffc9687715435aafa9e01544d2be9b20a09f617c7522283e028dd3b6f4b5e90dde189b7cb865c11

data/README.md

@@ -2,6 +2,8 @@
 
 A deterministic pattern detection and intent matching engine for Ruby. Built for chatbots and conversational AI where you need fast, predictable, rule-based matching — no API calls, no model inference, no latency.
 
+**Why pattern-ruby?** LLMs are great but slow, expensive, and unpredictable. For the 80% of user inputs that follow predictable patterns ("track my order", "reset password", "what are your hours"), you don't need an LLM. Handle those deterministically in microseconds, and route the rest to your LLM.
+
 ## Installation
 
 ```ruby
@@ -32,72 +34,71 @@ router = PatternRuby::Router.new do
     entity :city, type: :string
   end
 
-  fallback { |input| puts "Unknown: #{input}" }
+  intent :order_status do
+    pattern "track order {order_id:\\d+}"
+    pattern "where is my order {order_id:\\d+}"
+    pattern(/order\s*#?\s*(?<order_id>\d{5,})/i)
+  end
+
+  fallback { |input| puts "Route to LLM: #{input}" }
 end
 
 result = router.match("weather in Tokyo")
 result.intent    # => :weather
 result.entities  # => { city: "Tokyo" }
 result.matched?  # => true
+result.score     # => 0.9
 ```
 
 ## Pattern Syntax
 
-```
-hello                        Literal match (case-insensitive)
-{name}                       Named entity capture
-{name:\d+}                   Entity with regex constraint
-{name:opt1|opt2|opt3}        Entity with enum constraint
-[optional words]             Optional section
-(alt1|alt2|alt3)             Alternatives
-*                            Wildcard (any text)
-```
+| Syntax | Meaning | Example |
+|---|---|---|
+| `hello` | Literal match (case-insensitive) | matches "Hello", "HELLO" |
+| `{name}` | Named entity capture | `{city}` captures any text |
+| `{name:\\d+}` | Entity with regex constraint | `{id:\\d+}` captures digits only |
+| `{name:a\|b\|c}` | Entity with enum constraint | `{time:today\|tomorrow}` |
+| `[optional]` | Optional section | `book [a] flight` |
+| `(a\|b\|c)` | Alternatives | `(fly\|travel\|go)` |
+| `*` | Wildcard | `tell me *` matches anything |
 
-### Examples
+### Combined Example
 
 ```ruby
-# Optional words
-"book [a] flight"              # matches "book a flight" and "book flight"
-
-# Entity with constraint
-"order {id:\d+}"               # captures only digits
-
-# Alternatives
-"i want to (fly|travel|go)"    # matches any of the three verbs
-
-# Combined
+# All of these match:
 "book [a] flight from {origin} to {destination} [on {date}]"
+
+# "book a flight from NYC to London on Friday"
+# "book flight from Paris to Berlin"
+# "book a flight from Tokyo to Seoul"
 ```
 
 ## Entity Types
 
-Built-in types: `:string`, `:number`, `:integer`, `:email`, `:phone`, `:url`, `:currency`
+Built-in: `:string`, `:number`, `:integer`, `:email`, `:phone`, `:url`, `:currency`
 
 ```ruby
-# Register custom entity types
 router = PatternRuby::Router.new do
+  # Custom entity types
   entity_type :zipcode, pattern: /\d{5}/, parser: ->(s) { s.to_i }
 
   intent :locate do
-    pattern "find stores near {zip}"
+    pattern "stores near {zip}"
     entity :zip, type: :zipcode
   end
-end
-```
 
-Entities support defaults:
-
-```ruby
-intent :weather do
-  pattern "weather in {city}"
-  entity :city, type: :string
-  entity :time, type: :string, default: "today"
+  # Default values
+  intent :weather do
+    pattern "weather in {city}"
+    entity :city, type: :string
+    entity :time, type: :string, default: "today"
+  end
 end
 ```
 
 ## Regex Patterns
 
-Use raw regex for complex matching:
+For complex matching, use raw regex with named captures:
 
 ```ruby
 intent :order_status do
@@ -108,43 +109,49 @@ result = router.match("Where is order #12345?")
 result.entities[:order_id]  # => "12345"
 ```
 
-## Multi-Intent Matching
-
-```ruby
-results = router.match_all("book a flight to Paris")
-results.each do |r|
-  puts "#{r.intent}: #{r.score}"
-end
-```
-
 ## Context-Aware Matching
 
+Route the same input differently based on conversation state:
+
 ```ruby
 router = PatternRuby::Router.new do
   intent :confirm do
     pattern "yes"
-    context :awaiting_confirmation
+    context :awaiting_confirmation  # only matches in this context
   end
 
-  intent :greeting do
-    pattern "yes"  # only matches without context
+  intent :affirmative_greeting do
+    pattern "yes"  # matches when no context
   end
 end
 
-router.match("yes")                                    # => :greeting
+router.match("yes")                                    # => :affirmative_greeting
 router.match("yes", context: :awaiting_confirmation)   # => :confirm
 ```
 
-## Conversation State
+## Multi-Intent Matching
+
+Get all matching intents ranked by score:
+
+```ruby
+results = router.match_all("book a flight to Paris")
+results.each { |r| puts "#{r.intent}: #{r.score}" }
+# book_flight: 0.92
+# book_generic: 0.65
+```
+
+## Conversation State & Slot Filling
+
+Track conversation context and fill missing entities across turns:
 
 ```ruby
 convo = PatternRuby::Conversation.new(router)
 
 result = convo.process("book a flight from NYC to London")
-# => { origin: "NYC", destination: "London" }
+# => entities: { origin: "NYC", destination: "London" }
 
-result = convo.process("tomorrow")
-# => fills missing date slot: { origin: "NYC", destination: "London", date: "tomorrow" }
+result = convo.process("Friday")
+# => fills missing slot: { origin: "NYC", destination: "London", date: "Friday" }
 
 convo.reset  # clear all state
 ```
@@ -161,26 +168,80 @@ pipeline = PatternRuby::Pipeline.new do
 end
 
 result = pipeline.process("Wether in Tokyo?")
-# => intent: :weather, entities: { city: "tokyo" }
+# normalize → "wether in tokyo"
+# correct   → "weather in tokyo"
+# match     → intent: :weather, entities: { city: "tokyo" }
 ```
 
+## Real-World Example: Support Bot
+
+```ruby
+router = PatternRuby::Router.new do
+  intent :order_status do
+    pattern "where is my order {order_id:\\d+}"
+    pattern "track order {order_id:\\d+}"
+    pattern(/order\s*#?\s*(?<order_id>\d{5,})/i)
+  end
+
+  intent :refund do
+    pattern "i want [a] refund"
+    pattern "refund [my] order {order_id:\\d+}"
+  end
+
+  intent :reset_password do
+    pattern "reset [my] password"
+    pattern "forgot [my] password"
+    pattern "can't log in"
+  end
+
+  intent :cancel do
+    pattern "cancel [my] (account|subscription|plan)"
+    pattern "i want to cancel"
+  end
+
+  intent :contact do
+    pattern "talk to [a] (human|person|agent)"
+    pattern "i need [to talk to] a human"
+  end
+
+  intent :complaint do
+    pattern "this is (terrible|awful|horrible)"
+    pattern "i'm (unhappy|frustrated|angry)"
+    pattern "i want to (complain|file a complaint)"
+  end
+
+  fallback { |input| route_to_llm(input) }
+end
+
+# In your controller/handler:
+result = router.match(user_input)
+case result.intent
+when :order_status then lookup_order(result.entities[:order_id])
+when :refund       then initiate_refund(result.entities[:order_id])
+when :complaint    then escalate_to_human(user_input)
+when nil           then ask_llm(user_input)  # fallback
+end
+```
+
+Try the interactive demo: `ruby -Ilib examples/support_bot.rb`
+
 ## Test Helpers
 
 ```ruby
 require "pattern_ruby/rails/test_helpers"
 
-class MyTest < Minitest::Test
+class ChatbotTest < Minitest::Test
   include PatternRuby::TestHelpers
 
   def test_greeting
     assert_matches_intent :greeting, "hello", router: @router
   end
 
-  def test_entity
+  def test_entity_extraction
     assert_extracts_entity :city, "Tokyo", "weather in Tokyo", router: @router
   end
 
-  def test_no_match
+  def test_unknown_input
     refute_matches "quantum physics", router: @router
   end
 end

data/examples/support_bot.rb

@@ -0,0 +1,252 @@
+#!/usr/bin/env ruby
+# A realistic customer support chatbot using pattern-ruby.
+# Run: ruby -Ilib examples/support_bot.rb
+
+require "pattern_ruby"
+
+# Simulated database
+ORDERS = {
+  "10001" => { status: "delivered", item: "Ruby Cookbook", date: "2026-03-01" },
+  "10002" => { status: "shipped", item: "Mechanical Keyboard", date: "2026-03-05", tracking: "1Z999AA10123456784" },
+  "10003" => { status: "processing", item: "USB-C Hub", date: "2026-03-07" },
+}
+
+PRODUCTS = {
+  "basic" => { price: "$9/mo", features: "5 projects, 1GB storage" },
+  "pro" => { price: "$29/mo", features: "Unlimited projects, 50GB storage, priority support" },
+  "enterprise" => { price: "$99/mo", features: "Everything in Pro + SSO, audit logs, SLA" },
+}
+
+HOURS = "Monday-Friday, 9am-5pm EST"
+
+# Build the router
+router = PatternRuby::Router.new do
+  # --- Greetings ---
+  intent :greeting do
+    pattern "hello"
+    pattern "hi"
+    pattern "hey"
+    pattern "good morning"
+    pattern "good afternoon"
+    pattern "good evening"
+    pattern "hi there"
+    pattern "hello there"
+    pattern "hey there"
+  end
+
+  intent :farewell do
+    pattern "bye"
+    pattern "goodbye"
+    pattern "see you"
+    pattern "thanks bye"
+    pattern "that's all"
+  end
+
+  # --- Order tracking ---
+  intent :order_status do
+    pattern "where is my order {order_id:\\d+}"
+    pattern "track order {order_id:\\d+}"
+    pattern "order status {order_id:\\d+}"
+    pattern "check order {order_id:\\d+}"
+    pattern(/order\s*#?\s*(?<order_id>\d{4,})/i)
+    entity :order_id, type: :string
+  end
+
+  # --- Product / pricing ---
+  intent :pricing do
+    pattern "how much does {plan:basic|pro|enterprise} cost"
+    pattern "price of {plan:basic|pro|enterprise}"
+    pattern "pricing"
+    pattern "plans"
+    pattern "what plans do you have"
+    entity :plan, type: :string
+  end
+
+  intent :compare_plans do
+    pattern "compare plans"
+    pattern "difference between plans"
+    pattern "which plan should i (choose|pick|get)"
+    pattern "compare {plan_a:basic|pro|enterprise} and {plan_b:basic|pro|enterprise}"
+  end
+
+  # --- Account ---
+  intent :reset_password do
+    pattern "reset [my] password"
+    pattern "forgot [my] password"
+    pattern "can't log in"
+    pattern "change [my] password"
+    pattern "locked out [of my account]"
+  end
+
+  intent :cancel_account do
+    pattern "cancel [my] (account|subscription|plan)"
+    pattern "i want to cancel"
+    pattern "delete [my] account"
+    pattern "unsubscribe"
+  end
+
+  # --- Refund ---
+  intent :refund do
+    pattern "i want [a] refund"
+    pattern "refund [my] order {order_id:\\d+}"
+    pattern "can i get [a] refund"
+    pattern "money back"
+    entity :order_id, type: :string
+  end
+
+  # --- Hours / contact ---
+  intent :business_hours do
+    pattern "what are your (hours|business hours)"
+    pattern "when are you open"
+    pattern "hours of operation"
+    pattern "are you open (today|tomorrow|on weekends)"
+  end
+
+  intent :contact do
+    pattern "how (can|do) i contact (you|support|a human)"
+    pattern "talk to [a] (human|person|agent|representative)"
+    pattern "phone number"
+    pattern "email address"
+    pattern "i need [to talk to] a human"
+  end
+
+  # --- Help ---
+  intent :help do
+    pattern "help"
+    pattern "what can you do"
+    pattern "what do you do"
+    pattern "menu"
+  end
+
+  # --- Complaint ---
+  intent :complaint do
+    pattern "this is (terrible|awful|horrible|unacceptable)"
+    pattern "i'm (unhappy|frustrated|angry|disappointed)"
+    pattern "your (service|product|app) is (bad|broken|terrible)"
+    pattern "i want to (complain|file a complaint)"
+    pattern "not working"
+  end
+
+  fallback { |_| }
+end
+
+# Build preprocessing pipeline
+pipeline = PatternRuby::Pipeline.new do
+  step(:normalize) do |input|
+    input.strip
+      .gsub(/[.!?]+$/, "")      # strip trailing punctuation
+      .gsub(/\s+/, " ")          # normalize whitespace
+  end
+
+  step(:correct) do |input|
+    input
+      .gsub(/\bpasword\b/i, "password")
+      .gsub(/\baccout\b/i, "account")
+      .gsub(/\bordrer\b/i, "order")
+      .gsub(/\bprcing\b/i, "pricing")
+      .gsub(/\bcansel\b/i, "cancel")
+  end
+end
+
+# Response handler
+def handle(result)
+  case result.intent
+  when :greeting
+    "Hello! Welcome to Acme Support. How can I help you today?\n  Type 'help' to see what I can do."
+
+  when :farewell
+    "Thanks for contacting Acme Support! Have a great day. 👋"
+
+  when :order_status
+    oid = result.entities[:order_id]
+    order = ORDERS[oid]
+    if order
+      msg = "Order ##{oid}: #{order[:item]}\n"
+      msg += "  Status: #{order[:status].upcase}\n"
+      msg += "  Ordered: #{order[:date]}\n"
+      msg += "  Tracking: #{order[:tracking]}" if order[:tracking]
+      msg
+    else
+      "I couldn't find order ##{oid}. Please check the order number and try again.\n  (Try: 10001, 10002, or 10003)"
+    end
+
+  when :pricing
+    plan = result.entities[:plan]
+    if plan
+      info = PRODUCTS[plan]
+      "#{plan.capitalize} Plan: #{info[:price]}\n  Features: #{info[:features]}"
+    else
+      PRODUCTS.map { |k, v| "  #{k.capitalize}: #{v[:price]} — #{v[:features]}" }.join("\n")
+    end
+
+  when :compare_plans
+    PRODUCTS.map { |k, v| "  #{k.capitalize}: #{v[:price]} — #{v[:features]}" }.join("\n") +
+      "\n  → Most popular: Pro plan"
+
+  when :reset_password
+    "To reset your password:\n  1. Go to acme.com/reset\n  2. Enter your email\n  3. Check your inbox for a reset link\n  Link expires in 1 hour."
+
+  when :cancel_account
+    "I'm sorry to hear that. To cancel:\n  1. Go to Settings → Billing\n  2. Click 'Cancel Plan'\n  Or reply with your reason and I'll connect you with our retention team."
+
+  when :refund
+    oid = result.entities[:order_id]
+    if oid
+      "I've submitted a refund request for order ##{oid}. You'll receive a confirmation email within 24 hours."
+    else
+      "I can help with a refund. Could you provide your order number?\n  (e.g., 'refund order 10001')"
+    end
+
+  when :business_hours
+    "Our support hours are: #{HOURS}\n  For urgent issues outside hours, email urgent@acme.com"
+
+  when :contact
+    "You can reach us via:\n  Email: support@acme.com\n  Phone: 1-800-ACME-123\n  Live chat: acme.com/chat\n  Or I can connect you with a human agent now."
+
+  when :help
+    <<~HELP
+      I can help with:
+        • Order tracking — "track order 10001"
+        • Pricing & plans — "pricing" or "compare plans"
+        • Password reset — "reset password"
+        • Refunds — "refund order 10001"
+        • Business hours — "what are your hours"
+        • Contact support — "talk to a human"
+        • Cancel account — "cancel subscription"
+    HELP
+
+  when :complaint
+    "I'm really sorry you're having a bad experience. Let me connect you with a senior support agent who can help resolve this right away.\n  [Escalating to human agent...]"
+
+  else
+    "I'm not sure I understand. Could you rephrase that?\n  Type 'help' to see what I can assist with."
+  end
+end
+
+# --- Interactive REPL ---
+puts "╔══════════════════════════════════════╗"
+puts "║   Acme Support Bot (pattern-ruby)   ║"
+puts "║   Type 'quit' to exit               ║"
+puts "╚══════════════════════════════════════╝"
+puts
+
+convo = PatternRuby::Conversation.new(router)
+
+loop do
+  print "You: "
+  input = $stdin.gets
+  break unless input
+  input = input.strip
+  break if input.downcase == "quit" || input.downcase == "exit"
+  next if input.empty?
+
+  # Preprocess then match
+  cleaned = pipeline.process(input)
+  result = convo.process(cleaned)
+
+  response = handle(result)
+  puts "Bot: #{response}"
+  puts
+
+  break if result.intent == :farewell
+end

data/lib/pattern_ruby/conversation.rb

@@ -7,60 +7,65 @@ module PatternRuby
       @context = nil
       @history = []
       @slots = {}
+      @mutex = Mutex.new
     end
 
     def process(input)
-      result = @router.match(input, context: @context)
+      @mutex.synchronize do
+        result = @router.match(input, context: @context)
 
-      if result.matched?
-        # Merge new entities into accumulated slots
-        result.entities.each do |k, v|
-          @slots[k] = v unless v.nil?
-        end
+        if result.matched?
+          # Merge new entities into accumulated slots
+          result.entities.each do |k, v|
+            @slots[k] = v unless v.nil?
+          end
 
-        # Build enriched result with accumulated slots
-        result = MatchResult.new(
-          intent: result.intent,
-          entities: @slots.dup,
-          pattern: result.pattern,
-          score: result.score,
-          input: result.input,
-          response: result.response
-        )
-      elsif !@history.empty? && @slots.any?
-        # Try to fill a missing slot from context
-        last = @history.last
-        if last&.matched?
-          filled = try_slot_fill(input, last.intent)
-          if filled
-            result = MatchResult.new(
-              intent: last.intent,
-              entities: @slots.dup,
-              pattern: last.pattern,
-              score: last.score,
-              input: input,
-              response: last.response
-            )
+          # Build enriched result with accumulated slots
+          result = MatchResult.new(
+            intent: result.intent,
+            entities: @slots.dup,
+            pattern: result.pattern,
+            score: result.score,
+            input: result.input,
+            response: result.response
+          )
+        elsif !@history.empty? && @slots.any?
+          # Try to fill a missing slot from context
+          last = @history.last
+          if last&.matched?
+            filled = try_slot_fill(input, last.intent)
+            if filled
+              result = MatchResult.new(
+                intent: last.intent,
+                entities: @slots.dup,
+                pattern: last.pattern,
+                score: last.score,
+                input: input,
+                response: last.response
+              )
+            end
           end
         end
-      end
 
-      @history << result
-      result
+        @history << result
+        result
+      end
     end
 
     def set_context(ctx)
-      @context = ctx
+      @mutex.synchronize { @context = ctx }
     end
 
     def clear_context
-      @context = nil
+      @mutex.synchronize { @context = nil }
     end
 
     def reset
-      @context = nil
-      @history = []
-      @slots = {}
+      @mutex.synchronize do
+        @context = nil
+        @history = []
+        @slots = {}
+      end
     end
 
     private
@@ -74,7 +79,7 @@ module PatternRuby
       return false if unfilled.empty?
 
       # Try the input as a value for the first unfilled slot
-      name, defn = unfilled.first
+      name, _defn = unfilled.first
       @slots[name] = input.strip
       true
     end

data/lib/pattern_ruby/entity_types.rb

@@ -10,17 +10,44 @@ module PatternRuby
       currency: { pattern: /\$[\d,]+(?:\.\d{2})?/, parser: ->(s) { s.delete(",").delete("$").to_f } },
     }.freeze
 
+    # Standard NER entity types recognized in pattern constraints like {entity:PERSON}
+    STANDARD_NER_TYPES = %w[
+      PERSON PER
+      LOCATION LOC
+      ORGANIZATION ORG
+      DATE TIME
+      MONEY PERCENT
+      MISC
+    ].freeze
+
+    # Validates an entity type string used in pattern constraints (e.g., "PERSON" from {name:PERSON}).
+    # Returns true if the type is a standard NER type, a built-in type, or matches the custom type
+    # format (UPPER_SNAKE_CASE).
+    def self.valid_entity_type?(type_str)
+      return false if type_str.nil? || type_str.strip.empty?
+
+      normalized = type_str.strip
+      return true if STANDARD_NER_TYPES.include?(normalized)
+      return true if BUILT_IN.key?(normalized.downcase.to_sym)
+
+      # Allow custom types that follow UPPER_SNAKE_CASE or CamelCase convention
+      !!(normalized.match?(/\A[A-Z][A-Z0-9_]*\z/) || normalized.match?(/\A[A-Z][a-zA-Z0-9]*\z/))
+    end
+
     class Registry
       def initialize
         @types = BUILT_IN.dup
+        @mutex = Mutex.new
       end
 
       def register(name, pattern: nil, parser: nil)
-        @types[name.to_sym] = { pattern: pattern, parser: parser }
+        @mutex.synchronize do
+          @types[name.to_sym] = { pattern: pattern, parser: parser }
+        end
       end
 
       def get(name)
-        @types[name.to_sym]
+        @mutex.synchronize { @types[name.to_sym] }
       end
 
       def pattern_for(name)

data/lib/pattern_ruby/intent.rb

@@ -14,8 +14,11 @@ module PatternRuby
     def pattern(pat)
       if pat.is_a?(Regexp)
         @compiled_patterns << RegexPattern.new(pat)
-      else
+      elsif pat.is_a?(String)
+        raise ArgumentError, "pattern cannot be empty" if pat.strip.empty?
         @compiled_patterns << @compiler.compile(pat)
+      else
+        raise ArgumentError, "pattern must be a String or Regexp, got #{pat.class}"
       end
     end
 

data/lib/pattern_ruby/pattern_compiler.rb

@@ -17,11 +17,20 @@ module PatternRuby
   end
 
   class PatternCompiler
+    # Maximum pattern string length to prevent ReDoS / excessive compilation cost
+    MAX_PATTERN_LENGTH = 10_000
+
     def initialize(entity_registry: nil)
       @entity_registry = entity_registry
     end
 
     def compile(pattern_string)
+      raise ArgumentError, "pattern must be a String, got #{pattern_string.class}" unless pattern_string.is_a?(String)
+      raise ArgumentError, "pattern cannot be nil or empty" if pattern_string.nil? || pattern_string.strip.empty?
+      if pattern_string.length > MAX_PATTERN_LENGTH
+        raise ArgumentError, "pattern exceeds maximum length of #{MAX_PATTERN_LENGTH} characters"
+      end
+
       tokens = tokenize(pattern_string)
       entity_names = []
       literal_count = 0
@@ -131,6 +140,9 @@ module PatternRuby
           # Enum constraint: {time:today|tomorrow|this week}
           alts = token.constraint.split("|").map { |a| Regexp.escape(a.strip) }
           "(?<#{token.name}>#{alts.join('|')})"
+        elsif EntityTypes.valid_entity_type?(token.constraint)
+          # NER type constraint: {entity:PERSON} — treated as free-text capture
+          "(?<#{token.name}>.+?)"
         else
           # Regex constraint: {order_id:\\d+}
           "(?<#{token.name}>#{token.constraint})"

data/lib/pattern_ruby/router.rb

@@ -2,18 +2,32 @@ module PatternRuby
   class Router
     attr_reader :intents
 
+    # Maximum input length for matching (100 KB). Inputs beyond this are truncated.
+    MAX_INPUT_LENGTH = 100_000
+
     def initialize(&block)
       @intents = []
+      @intent_names = {}
       @fallback_handler = nil
       @entity_registry = EntityTypes::Registry.new
       @compiler = PatternCompiler.new(entity_registry: @entity_registry)
+      @mutex = Mutex.new
       instance_eval(&block) if block
     end
 
     def intent(name, &block)
+      name_sym = name.to_sym
+      if @intent_names.key?(name_sym)
+        # Duplicate registration: return existing intent (idempotent)
+        return @intent_names[name_sym]
+      end
+
       i = Intent.new(name, compiler: @compiler)
       i.instance_eval(&block) if block
-      @intents << i
+      @mutex.synchronize do
+        @intents << i
+        @intent_names[name_sym] = i
+      end
       i
     end
 
@@ -26,12 +40,12 @@ module PatternRuby
     end
 
     def match(input, context: nil)
-      input = input.to_s.strip
+      input = sanitize_input(input)
       return fallback_result(input) if input.empty?
 
       candidates = []
 
-      @intents.each do |i|
+      @mutex.synchronize { @intents.dup }.each do |i|
         # Skip intents that require a specific context
         if i.context_requirement
           next unless context == i.context_requirement
@@ -47,12 +61,12 @@ module PatternRuby
     end
 
     def match_all(input, context: nil)
-      input = input.to_s.strip
+      input = sanitize_input(input)
       return [] if input.empty?
 
       candidates = []
 
-      @intents.each do |i|
+      @mutex.synchronize { @intents.dup }.each do |i|
         if i.context_requirement
           next unless context == i.context_requirement
         end
@@ -66,6 +80,12 @@ module PatternRuby
 
     private
 
+    def sanitize_input(input)
+      text = input.to_s.strip
+      text = text[0, MAX_INPUT_LENGTH] if text.length > MAX_INPUT_LENGTH
+      text
+    end
+
     def fallback_result(input)
       @fallback_handler&.call(input)
 

data/lib/pattern_ruby/version.rb

@@ -1,3 +1,3 @@
 module PatternRuby
-  VERSION = "0.1.0"
+  VERSION = "0.1.1"
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: pattern-ruby
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.1.1
 platform: ruby
 authors:
 - Johannes Dwi Cahyo
@@ -50,6 +50,7 @@ files:
 - Rakefile
 - examples/chatbot.rb
 - examples/customer_service.rb
+- examples/support_bot.rb
 - examples/with_llm_fallback.rb
 - lib/pattern_ruby.rb
 - lib/pattern_ruby/conversation.rb