phronomy 0.7.1 → 0.9.0

data/lib/phronomy/context/trigger_context.rb

@@ -1,39 +0,0 @@
-# frozen_string_literal: true
-
-module Phronomy
-  module Context
-    # Read-only context passed to the +on_compaction_trigger+ callback.
-    #
-    # The callback inspects the current message list and budget, then returns
-    # a truthy value to trigger compaction or a falsy value to skip it.
-    #
-    # No mutations are allowed through this object; use CompactionContext
-    # (passed to +on_compact+) for actual modifications.
-    #
-    # @example Trigger compaction when messages exceed 80% of the input budget
-    #   on_compaction_trigger do |ctx|
-    #     limit = ctx.budget&.available(used: 0) || Float::INFINITY
-    #     ctx.total_tokens > limit * 0.8
-    #   end
-    class TriggerContext
-      # @return [Array<Hash>] frozen snapshot of message elements
-      #   each element: { seq: Integer, message: Object, tokens: Integer, role: Symbol }
-      attr_reader :message_elements
-
-      # @return [Phronomy::Context::TokenBudget, nil] token budget for this invocation
-      attr_reader :budget
-
-      # @return [Integer] total estimated token count of all message elements
-      attr_reader :total_tokens
-
-      # @param message_elements [Array<Hash>]
-      # @param budget [Phronomy::Context::TokenBudget, nil]
-      # @api private
-      def initialize(message_elements:, budget:)
-        @message_elements = message_elements.dup.freeze
-        @budget = budget
-        @total_tokens = message_elements.sum { |e| e[:tokens] }
-      end
-    end
-  end
-end

data/lib/phronomy/context/trim_context.rb

@@ -1,75 +0,0 @@
-# frozen_string_literal: true
-
-module Phronomy
-  module Context
-    # Context object passed to the +on_trim+ callback registered on an agent class.
-    #
-    # The callback receives a TrimContext and may call #remove to drop specific
-    # messages from the conversation before the LLM is called. Changes affect
-    # only the current invocation; the underlying memory store is not modified.
-    #
-    # Message elements are identified by a +:seq+ integer that is assigned
-    # sequentially (0-based) when messages are loaded from memory each turn.
-    #
-    # @example Remove the oldest two messages when the budget is tight
-    #   on_trim do |ctx|
-    #     if ctx.total_tokens > ctx.budget.available(used: 0) * 0.9
-    #       seqs_to_drop = ctx.message_elements.first(2).map { |e| e[:seq] }
-    #       ctx.remove(seqs_to_drop)
-    #     end
-    #   end
-    class TrimContext
-      # @return [Phronomy::Context::TokenBudget, nil] token budget for this invocation
-      attr_reader :budget
-
-      # @return [Integer] total estimated token count of all current message elements
-      attr_reader :total_tokens
-
-      # @param message_elements [Array<Hash>]
-      #   each element: { seq: Integer, message: Object, tokens: Integer, role: Symbol }
-      # @param budget [Phronomy::Context::TokenBudget, nil]
-      # @api private
-      def initialize(message_elements:, budget:)
-        @message_elements = message_elements.dup
-        @budget = budget
-        recalculate!
-      end
-
-      # Returns a snapshot of the current message elements (defensive copy).
-      # Each element is a Hash with +:seq+, +:message+, +:tokens+, and +:role+.
-      #
-      # @return [Array<Hash>]
-      # @api private
-      def message_elements
-        @message_elements.dup
-      end
-
-      # Remove messages identified by seq numbers.
-      # Calling this multiple times accumulates removals.
-      #
-      # @param seqs [Integer, Array<Integer>] seq number(s) to remove
-      # @return [self]
-      # @api private
-      def remove(seqs)
-        seqs_set = Array(seqs).to_set
-        @message_elements.reject! { |e| seqs_set.include?(e[:seq]) }
-        recalculate!
-        self
-      end
-
-      # Convenience: returns the plain message objects (without element metadata).
-      #
-      # @return [Array]
-      # @api private
-      def messages
-        @message_elements.map { |e| e[:message] }
-      end
-
-      private
-
-      def recalculate!
-        @total_tokens = @message_elements.sum { |e| e[:tokens] }
-      end
-    end
-  end
-end

data/lib/phronomy/deadline.rb

@@ -1,63 +0,0 @@
-# frozen_string_literal: true
-
-module Phronomy
-  # A point in time used as an upper bound for an operation.
-  #
-  # Uses the monotonic clock (+Process::CLOCK_MONOTONIC+) internally to avoid
-  # skew from NTP adjustments or DST transitions.
-  #
-  # @example Create a 30-second deadline and check remaining time
-  #   deadline = Phronomy::Deadline.in(30)
-  #   sleep 1
-  #   deadline.remaining_seconds   # => ~29.0
-  #   deadline.expired?            # => false
-  class Deadline
-    # Creates a deadline that expires +seconds+ from now.
-    #
-    # @param seconds [Numeric] seconds from now until expiry
-    # @return [Deadline]
-    # @api private
-    def self.in(seconds)
-      new(Process.clock_gettime(Process::CLOCK_MONOTONIC) + seconds)
-    end
-
-    # @param monotonic_at [Float] absolute monotonic timestamp of expiry
-    # @api private
-    def initialize(monotonic_at)
-      @monotonic_at = monotonic_at
-    end
-
-    # Returns +true+ when the deadline has passed.
-    # @return [Boolean]
-    # @api private
-    def expired?
-      Process.clock_gettime(Process::CLOCK_MONOTONIC) >= @monotonic_at
-    end
-
-    # Seconds remaining until expiry.  Returns 0 when already expired.
-    # @return [Float]
-    # @api private
-    def remaining_seconds
-      remaining = @monotonic_at - Process.clock_gettime(Process::CLOCK_MONOTONIC)
-      [remaining, 0.0].max
-    end
-
-    # Attaches this deadline to a {CancellationToken} by cancelling the token
-    # when the deadline expires.  Uses the Runtime timer queue (a single
-    # background thread shared by all deadlines) instead of spawning one thread
-    # per deadline.
-    #
-    # @param token [CancellationToken]
-    # @param timer_queue [Runtime::TimerQueue, nil] queue to register with;
-    #   defaults to +Phronomy::Runtime.instance.timer_queue+
-    # @return [self]
-    # @api private
-    def attach_to(token, timer_queue: Phronomy::Runtime.instance.timer_queue)
-      seconds = remaining_seconds
-      return self if seconds <= 0
-
-      timer_queue.schedule(seconds: seconds) { token.cancel! }
-      self
-    end
-  end
-end

data/lib/phronomy/embeddings/base.rb

@@ -1,39 +0,0 @@
-# frozen_string_literal: true
-
-module Phronomy
-  module Embeddings
-    # Abstract interface for embedding adapters.
-    #
-    # Concrete implementations must override {#embed} and return a vector
-    # as an +Array<Float>+.
-    class Base
-      # Embed the given text and return a vector representation.
-      #
-      # @param text               [String]                         the text to embed
-      # @param cancellation_token [Phronomy::CancellationToken, nil] optional; raises CancellationError when cancelled
-      # @return [Array<Float>] the embedding vector
-      # @api public
-      def embed(text, cancellation_token = nil)
-        cancellation_token&.raise_if_cancelled!
-        raise NotImplementedError, "#{self.class}#embed is not implemented"
-      end
-
-      # Submits an {#embed} call to {BlockingAdapterPool} and returns a
-      # {BlockingAdapterPool::PendingOperation}.
-      #
-      # @param text               [String]
-      # @param cancellation_token [Phronomy::CancellationToken, nil]
-      # @param timeout            [Numeric, nil] seconds before the operation is abandoned
-      # @return [BlockingAdapterPool::PendingOperation]
-      # @api public
-      def embed_async(text, cancellation_token = nil, timeout: nil)
-        Phronomy::Runtime.instance.blocking_io.submit(
-          timeout: timeout,
-          cancellation_token: cancellation_token
-        ) do
-          embed(text, cancellation_token)
-        end
-      end
-    end
-  end
-end

data/lib/phronomy/embeddings/ruby_llm_embeddings.rb

@@ -1,45 +0,0 @@
-# frozen_string_literal: true
-
-module Phronomy
-  module Embeddings
-    # Embeddings adapter backed by RubyLLM.
-    #
-    # Delegates to +RubyLLM.embed+ and returns the resulting vector as an
-    # +Array<Float>+.
-    #
-    # @example Default model
-    #   embeddings = Phronomy::Embeddings::RubyLLMEmbeddings.new
-    #   vector = embeddings.embed("Hello, world!")
-    #
-    # @example Explicit model
-    #   embeddings = Phronomy::Embeddings::RubyLLMEmbeddings.new(model: "text-embedding-3-small")
-    #   vector = embeddings.embed("Hello, world!")
-    class RubyLLMEmbeddings < Base
-      # @param model               [String, nil] embedding model identifier; nil uses the RubyLLM default
-      # @param provider            [Symbol, nil] provider override (e.g. :openai); nil uses the RubyLLM default
-      # @param assume_model_exists [Boolean]     when true, skips RubyLLM model-registry validation
-      #                                          (useful for locally hosted models not in the registry)
-      # @api public
-      def initialize(model: nil, provider: nil, assume_model_exists: false)
-        @model = model
-        @provider = provider
-        @assume_model_exists = assume_model_exists
-      end
-
-      # Embed text via RubyLLM.
-      #
-      # @param text               [String]
-      # @param cancellation_token [Phronomy::CancellationToken, nil] optional; raises CancellationError when cancelled
-      # @return [Array<Float>]
-      # @api public
-      def embed(text, cancellation_token = nil)
-        cancellation_token&.raise_if_cancelled!
-        opts = {}
-        opts[:model] = @model if @model
-        opts[:provider] = @provider if @provider
-        opts[:assume_model_exists] = true if @assume_model_exists
-        RubyLLM.embed(text, **opts).vectors
-      end
-    end
-  end
-end

data/lib/phronomy/embeddings.rb

@@ -1,11 +0,0 @@
-# frozen_string_literal: true
-
-module Phronomy
-  # Embeddings adapters for converting text into vector representations.
-  #
-  # Sub-classes are auto-loaded by Zeitwerk:
-  #   Phronomy::Embeddings::Base
-  #   Phronomy::Embeddings::RubyLLMEmbeddings
-  module Embeddings
-  end
-end

data/lib/phronomy/fsm_session.rb

@@ -1,247 +0,0 @@
-# frozen_string_literal: true
-
-module Phronomy
-  # Event-driven execution wrapper for a single workflow run.
-  #
-  # Created by WorkflowRunner and registered with EventLoop. All public methods
-  # are called from the EventLoop thread — FSMSession is NOT thread-safe and must
-  # not be accessed concurrently from multiple threads.
-  #
-  # == Lifecycle
-  #
-  #   register(session) → EventLoop posts :start → session.start
-  #                                 ↓ (auto-transition present)
-  #                        EventLoop posts :state_completed → session.handle
-  #                                 ↓ (repeat)
-  #                        session posts :finished or :halted
-  #                                 ↓
-  #                        EventLoop pushes ctx to completion_queue → caller unblocks
-  #
-  # == Async IO pattern (EventLoop mode only)
-  #
-  # When a state has no auto-transition and is not a wait_state, but has an
-  # external event registered (e.g. +transition from: :fetching, on: :fetch_done+),
-  # the FSMSession stays registered in the EventLoop and waits for that event.
-  # The entry action is expected to spawn an IO thread that posts the event back:
-  #
-  #   entry :fetching, ->(ctx) {
-  #     Thread.new {
-  #       ctx.result = http.get(ctx.url)
-  #       Phronomy::EventLoop.instance.post(
-  #         Phronomy::Event.new(type: :fetch_done, target_id: ctx.thread_id, payload: nil)
-  #       )
-  #     }
-  #   }
-  #   transition from: :fetching, on: :fetch_done, to: :process
-  class FSMSession
-    FINISH = WorkflowRunner::FINISH
-
-    # @return [String] workflow thread_id (matches WorkflowContext#thread_id)
-    attr_reader :id
-
-    # @param id                  [String]
-    # @param context             [Object]        includes Phronomy::WorkflowContext
-    # @param entry_point         [Symbol]        initial state name
-    # @param entry_actions       [Hash]          { state_name => [callable, ...] }
-    # @param auto_state_set      [Hash]          { state_name => true }
-    # @param declared_states     [Array<Symbol>] all action state names
-    # @param wait_state_names    [Array<Symbol>]
-    # @param external_events     [Hash]          { event_name => [{from:, to:, guard:}] }
-    # @param phase_machine_class [Class]         state_machines-backed phase tracker class
-    # @param recursion_limit     [Integer]
-    # @param action_timeouts     [Hash]          { state_name => seconds }
-    # @param resume_event        [Symbol, nil]   external event to fire when resuming
-    # @param resume_phase        [Symbol, nil]   wait state name to resume from
-    # @api private
-    def initialize(id:, context:, entry_point:, entry_actions:, auto_state_set:,
-      declared_states:, wait_state_names:, external_events:, phase_machine_class:,
-      recursion_limit:, action_timeouts: {}, resume_event: nil, resume_phase: nil)
-      @id = id
-      @ctx = context
-      @entry_point = entry_point
-      @entry_actions = entry_actions
-      @auto_state_set = auto_state_set
-      @declared_states = declared_states
-      @wait_state_names = wait_state_names
-      @external_events = external_events
-      @phase_machine_class = phase_machine_class
-      @recursion_limit = recursion_limit
-      @action_timeouts = action_timeouts
-      @resume_event = resume_event
-      @resume_phase = resume_phase
-      @step = 0
-      @done = false
-      @current_state = nil
-      @tracker = nil
-    end
-
-    # Begins workflow execution. Called by EventLoop on :start event.
-    def start
-      if @resume_event
-        # Resume from wait state: position tracker at the wait state, then fire the
-        # external event. state_machines fires before_transition (exit) and
-        # after_transition (entry) callbacks, so both actions execute here.
-        @current_state = @resume_phase
-        @tracker = build_tracker(@current_state)
-        @tracker.context = @ctx
-        fire_and_advance!(@resume_event)
-      else
-        # Fresh start: state_machines does not fire callbacks on initialization,
-        # so we invoke the entry action for the initial state manually.
-        @current_state = @entry_point
-        @tracker = build_tracker(@current_state)
-        @tracker.context = @ctx
-        (@entry_actions[@current_state] || []).each do |c|
-          result = c.call(@ctx)
-          if result.is_a?(Phronomy::Task)
-            # Awaitable action: spawn a task to await without blocking EventLoop.
-            @tracker.async_pending = true
-            session_id = @id
-            current_state_name = @current_state
-            timeout_secs = @action_timeouts[current_state_name]
-            Phronomy::Runtime.instance.spawn(name: "fsm-await-#{session_id}") do
-              if timeout_secs
-                if result.join(timeout_secs).nil?
-                  result.cancel!
-                  raise Phronomy::ActionTimeoutError,
-                    "Action in state #{current_state_name.inspect} timed out after #{timeout_secs}s"
-                end
-              end
-              task_result = result.await
-              if task_result.is_a?(Phronomy::WorkflowContext)
-                event_loop.post(Event.new(type: :action_completed, target_id: session_id, payload: task_result))
-              else
-                event_loop.post(Event.new(type: :state_completed, target_id: session_id, payload: nil))
-              end
-            rescue => e
-              event_loop.post(Event.new(type: :error, target_id: session_id, payload: e))
-            end
-            break # Only one async action at a time per state
-          elsif result.is_a?(Phronomy::WorkflowContext)
-            @ctx = result
-          end
-        end
-        @tracker.context = @ctx
-        advance_or_halt unless @tracker.async_pending
-      end
-    rescue => e
-      finish_with_error(e)
-    end
-
-    # Processes an event dispatched from EventLoop.
-    # Called for :state_completed, :action_completed, and all user-defined external events.
-    #
-    # @param event [Phronomy::Event]
-    # @api private
-    def handle(event)
-      return if @done
-
-      if event.type == :action_completed
-        # An awaitable entry action completed: update context and advance.
-        @ctx = event.payload if event.payload.is_a?(Phronomy::WorkflowContext)
-        @tracker.context = @ctx
-        @tracker.async_pending = false  # Reset flag set by start or fire_and_advance!
-        advance_or_halt
-        return
-      end
-
-      fire_and_advance!(event.type)
-    rescue => e
-      finish_with_error(e)
-    end
-
-    private
-
-    # Fires event_name on the phase tracker, updates @current_state, then
-    # calls advance_or_halt to decide what to do next.
-    def fire_and_advance!(event_name)
-      if @step >= @recursion_limit
-        raise Phronomy::RecursionLimitError,
-          "Recursion limit (#{@recursion_limit}) exceeded"
-      end
-
-      fire_event!(@tracker, event_name, @current_state)
-      @ctx = @tracker.context
-      next_phase = @tracker.phase.to_sym
-      # When next_phase == @current_state, no transition matched → treat as terminal.
-      @current_state = (next_phase == @current_state) ? FINISH : next_phase
-      @step += 1
-
-      # If an entry action returned a Task, the after_transition callback set
-      # async_pending = true and spawned a thread. Skip advance_or_halt — the
-      # background thread will post :action_completed or :state_completed.
-      if @tracker.async_pending
-        @tracker.async_pending = false
-        return
-      end
-
-      advance_or_halt
-    end
-
-    # Determines the next action after the FSM has entered @current_state.
-    def advance_or_halt
-      return finish! if @current_state == FINISH
-
-      if @wait_state_names.include?(@current_state)
-        return halt!
-      end
-
-      if @auto_state_set.key?(@current_state)
-        event_loop.post(Event.new(type: :state_completed, target_id: @id, payload: nil))
-        return
-      end
-
-      if has_external_event_from?(@current_state)
-        # Async IO pattern: the entry action spawned an IO thread that will post
-        # an external event back. Stay registered; do nothing here.
-        return
-      end
-
-      # No transition declared — validate the state is known, then treat as terminal.
-      unless @declared_states.include?(@current_state)
-        raise ArgumentError, "State #{@current_state.inspect} is not defined"
-      end
-
-      finish!
-    end
-
-    def finish!
-      @done = true
-      @ctx.set_graph_metadata(thread_id: @id, phase: :__end__)
-      event_loop.post(Event.new(type: :finished, target_id: @id, payload: @ctx))
-    end
-
-    def halt!
-      @done = true
-      @ctx.set_graph_metadata(thread_id: @id, phase: @current_state)
-      event_loop.post(Event.new(type: :halted, target_id: @id, payload: @ctx))
-    end
-
-    def finish_with_error(err)
-      @done = true
-      event_loop.post(Event.new(type: :error, target_id: @id, payload: err))
-    end
-
-    def fire_event!(tracker, event_name, from_state)
-      return if tracker.send(event_name)
-
-      raise ArgumentError,
-        "Transition from #{from_state.inspect} via event #{event_name.inspect} failed. " \
-        "Ensure at least one guard matches or add a fallback (no-guard) transition."
-    end
-
-    def has_external_event_from?(state)
-      @external_events.any? { |_, transitions| transitions.any? { |t| t[:from] == state } }
-    end
-
-    def build_tracker(from_state)
-      machine = @phase_machine_class.new
-      machine.instance_variable_set(:@phase, from_state.to_s)
-      machine
-    end
-
-    def event_loop
-      Phronomy::EventLoop.instance
-    end
-  end
-end

data/lib/phronomy/knowledge_source/base.rb

@@ -1,54 +0,0 @@
-# frozen_string_literal: true
-
-module Phronomy
-  module KnowledgeSource
-    # Abstract base class for all KnowledgeSource implementations.
-    #
-    # Subclasses must implement #fetch(query:) and return an Array of chunk Hashes.
-    # Each chunk Hash must contain:
-    #   :content [String]  the text to inject into the context
-    #   :type    [Symbol]  semantic tag (e.g. :static, :rag, :entity)
-    class Base
-      # Retrieve knowledge chunks relevant to the given query.
-      #
-      # @param query              [String, nil]                    the current user input used to select relevant chunks
-      # @param cancellation_token [Phronomy::CancellationToken, nil] optional token; raises CancellationError when cancelled
-      # @return [Array<Hash>] array of { content: String, type: Symbol }
-      # @api public
-      def fetch(query: nil, cancellation_token: nil)
-        cancellation_token&.raise_if_cancelled!
-        raise NotImplementedError, "#{self.class}#fetch is not implemented"
-      end
-
-      # Submits a {#fetch} call to {BlockingAdapterPool} and returns a
-      # {BlockingAdapterPool::PendingOperation}.
-      # Callers can fan out multiple fetches in parallel and await them all.
-      #
-      # @param query              [String, nil]
-      # @param cancellation_token [Phronomy::CancellationToken, nil]
-      # @param timeout            [Numeric, nil] seconds before the operation is abandoned
-      # @return [BlockingAdapterPool::PendingOperation]
-      # @api public
-      def fetch_async(query: nil, cancellation_token: nil, timeout: nil)
-        Phronomy::Runtime.instance.blocking_io.submit(
-          timeout: timeout,
-          cancellation_token: cancellation_token
-        ) do
-          fetch(query: query, cancellation_token: cancellation_token)
-        end
-      end
-
-      # Returns true when this source's content is considered static (i.e. does
-      # not change between agent invocations). Static sources are eligible for
-      # fingerprint-based caching in ContextVersionCache.
-      #
-      # Override in subclasses that return fixed content.
-      #
-      # @return [Boolean]
-      # @api public
-      def static?
-        false
-      end
-    end
-  end
-end

data/lib/phronomy/knowledge_source/entity_knowledge.rb

@@ -1,96 +0,0 @@
-# frozen_string_literal: true
-
-module Phronomy
-  module KnowledgeSource
-    # A KnowledgeSource that extracts named-entity facts from conversation history.
-    #
-    # This is the knowledge-injection counterpart of the old EntityMemory.
-    # It scans saved user messages with a regex heuristic (no LLM call) and
-    # returns the discovered facts as a single knowledge chunk tagged :entity.
-    #
-    # EntityKnowledge is stateful: it accumulates extracted facts via #update(messages:)
-    # which should be called each time new messages are saved.
-    #
-    # Supported extraction patterns (case-insensitive):
-    #   "my name is Alice"          → { name: "Alice" }
-    #   "I am Alice"                → { identity: "Alice" }
-    #   "I'm a software engineer"   → { occupation: "software engineer" }
-    #   "I work at / for Acme"      → { workplace: "Acme" }
-    #   "I live in Tokyo"           → { location: "Tokyo" }
-    #   "I'm from Tokyo"            → { location: "Tokyo" }
-    #   "I like / love Ruby"        → { preference: "Ruby" }
-    #
-    # @example
-    #   ks = Phronomy::KnowledgeSource::EntityKnowledge.new
-    #   ks.update(messages: chat_messages)
-    #   agent.invoke("What is my name?", config: { knowledge_sources: [ks] })
-    class EntityKnowledge < Base
-      PATTERNS = [
-        [:name, /\bmy name is\s+([A-Za-z][A-Za-z0-9 \-']*)/i],
-        [:identity, /\bI\s+am\s+([A-Z][A-Za-z0-9 \-']+)/],
-        [:occupation, /\bI(?:'m| am) a(?:n)?\s+([A-Za-z][A-Za-z0-9 \-']*)/i],
-        [:workplace, /\bI (?:work|worked) (?:at|for|in)\s+([A-Za-z0-9][A-Za-z0-9 \-'.&,]*)/i],
-        [:location, /\bI live in\s+([A-Za-z][A-Za-z0-9 \-']*)/i],
-        [:location, /\bI(?:'m| am) from\s+([A-Za-z][A-Za-z0-9 \-']*)/i],
-        [:preference, /\bI (?:like|love|enjoy)\s+([A-Za-z][A-Za-z0-9 \-']*)/i]
-      ].freeze
-
-      def initialize
-        @entities = {}
-      end
-
-      # Scan messages and accumulate entity facts.
-      # Call this after saving a new set of messages (e.g. from a ConversationManager save hook).
-      #
-      # @param messages [Array] message objects responding to #role and #content
-      # @api public
-      def update(messages:)
-        messages.each do |msg|
-          next unless msg.role.to_sym == :user
-
-          extract(msg.content.to_s).each { |key, value| @entities[key] = value }
-        end
-      end
-
-      # Returns a single chunk containing all known entity facts in XML context format.
-      # Returns an empty array when no entities have been discovered.
-      #
-      # @param query              [String, nil]                    unused — entity knowledge is always fully injected
-      # @param cancellation_token [Phronomy::CancellationToken, nil] optional; raises CancellationError when cancelled
-      # @return [Array<Hash>]
-      # @api public
-      def fetch(query: nil, cancellation_token: nil)
-        cancellation_token&.raise_if_cancelled!
-        return [] if @entities.empty?
-
-        lines = @entities.map { |key, value| "- #{key}: #{value}" }.join("\n")
-        content = <<~CONTENT.chomp
-          Known facts about the user:
-          #{lines}
-        CONTENT
-        [{content: content, type: :entity}]
-      end
-
-      # Returns the current entity store (primarily for testing).
-      #
-      # @return [Hash]
-      # @api public
-      def entities
-        @entities.dup
-      end
-
-      private
-
-      def extract(text)
-        found = {}
-        PATTERNS.each do |key, pattern|
-          if (match = text.match(pattern))
-            value = match[1].strip.sub(/[.!?]\s+.*$/, "").gsub(/[.,;!?]+$/, "")
-            found[key] = value unless value.empty?
-          end
-        end
-        found
-      end
-    end
-  end
-end