phronomy 0.2.2 → 0.4.0

data/lib/phronomy/memory/storage/in_memory.rb

@@ -1,152 +0,0 @@
-# frozen_string_literal: true
-
-module Phronomy
-  module Memory
-    module Storage
-      # In-process storage for conversation messages backed by per-thread-id
-      # {Phronomy::Actor} instances from {Phronomy::ThreadActorRegistry}.
-      # Messages are lost when the process exits.
-      #
-      # @example
-      #   storage = Phronomy::Memory::Storage::InMemory.new
-      #   manager = Phronomy::Memory::ConversationManager.new(storage: storage, ...)
-      class InMemory < Base
-        # Thread-local key for per-thread-id storage data (namespaced by store
-        # instance object_id to support multiple independent InMemory stores).
-        THREAD_DATA_KEY = :phronomy_storage_in_memory_data
-
-        def initialize
-        end
-
-        # -----------------------------------------------------------------------
-        # Legacy interface
-        # -----------------------------------------------------------------------
-
-        # @param thread_id [String]
-        # @return [Array]
-        def load(thread_id:)
-          Phronomy::ThreadActorRegistry.for(thread_id).call { (thread_data.store || []).dup }
-        end
-
-        # @param thread_id [String]
-        # @param messages  [Array]
-        def save(thread_id:, messages:)
-          Phronomy::ThreadActorRegistry.for(thread_id).call { thread_data.store = messages.dup }
-        end
-
-        # @param thread_id [String]
-        def clear(thread_id:)
-          store_id = object_id
-          Phronomy::ThreadActorRegistry.for(thread_id).call do
-            (Thread.current[THREAD_DATA_KEY] ||= {}).delete(store_id)
-          end
-        end
-
-        # -----------------------------------------------------------------------
-        # Raw message interface
-        # -----------------------------------------------------------------------
-
-        # @param thread_id    [String]
-        # @param messages     [Array]
-        # @param starting_seq [Integer]
-        # @param recorded_at  [Time, nil] timestamp for test overrides; defaults to +Time.now+
-        def append_raw(thread_id:, messages:, starting_seq:, recorded_at: nil)
-          now = recorded_at || Time.now
-          Phronomy::ThreadActorRegistry.for(thread_id).call do
-            data = thread_data
-            messages.each_with_index do |msg, i|
-              seq = starting_seq + i
-              data.raw_messages << {seq: seq, message: msg, recorded_at: now}
-              data.hwm = [data.hwm, seq].max
-            end
-          end
-        end
-
-        # @param thread_id [String]
-        # @return [Integer]
-        def next_seq(thread_id:)
-          Phronomy::ThreadActorRegistry.for(thread_id).call { thread_data.hwm + 1 }
-        end
-
-        # Routes +block+ through the per-thread-id {Phronomy::Actor}, serialising
-        # all operations for the same thread.  Reentrant calls (the block itself
-        # calling storage methods that also route through the Actor) are safe
-        # because {Phronomy::Actor#call} detects the same-thread case and executes
-        # inline.
-        #
-        # @param thread_id [String]
-        def with_thread_lock(thread_id:, &block)
-          Phronomy::ThreadActorRegistry.for(thread_id).call(&block)
-        end
-
-        # @param thread_id [String]
-        # @return [Array<Hash>]
-        def load_raw(thread_id:)
-          Phronomy::ThreadActorRegistry.for(thread_id).call { thread_data.raw_messages.dup }
-        end
-
-        # @param thread_id [String]
-        def clear_raw(thread_id:)
-          Phronomy::ThreadActorRegistry.for(thread_id).call { thread_data.raw_messages.clear }
-        end
-
-        # -----------------------------------------------------------------------
-        # Compaction record interface
-        # -----------------------------------------------------------------------
-
-        # @param thread_id    [String]
-        # @param start_seq    [Integer]
-        # @param end_seq      [Integer]
-        # @param summary_text [String]
-        def save_compaction(thread_id:, start_seq:, end_seq:, summary_text:)
-          Phronomy::ThreadActorRegistry.for(thread_id).call do
-            thread_data.compactions << {start_seq: start_seq, end_seq: end_seq, summary_text: summary_text}
-          end
-        end
-
-        # @param thread_id [String]
-        # @return [Array<Hash>]
-        def load_compactions(thread_id:)
-          Phronomy::ThreadActorRegistry.for(thread_id).call { thread_data.compactions.dup }
-        end
-
-        # @param thread_id [String]
-        def clear_compactions(thread_id:)
-          Phronomy::ThreadActorRegistry.for(thread_id).call { thread_data.compactions.clear }
-        end
-
-        # Remove raw messages recorded before +older_than+ for this thread.
-        #
-        # @param thread_id  [String]
-        # @param older_than [Time]
-        def purge_older_than(thread_id:, older_than:)
-          Phronomy::ThreadActorRegistry.for(thread_id).call do
-            thread_data.raw_messages.reject! { |entry| entry[:recorded_at] && entry[:recorded_at] < older_than }
-          end
-        end
-
-        private
-
-        # Returns (or lazily initialises) the {ThreadData} for the current Actor
-        # thread and this storage instance.  Must only be called from within a
-        # {Phronomy::ThreadActorRegistry.for} block so that +Thread.current+ is
-        # the correct Actor thread.
-        def thread_data
-          (Thread.current[THREAD_DATA_KEY] ||= {})[object_id] ||= ThreadData.new
-        end
-
-        # Value object holding all per-thread-id storage state.
-        class ThreadData
-          attr_accessor :store, :raw_messages, :compactions, :hwm
-
-          def initialize
-            @store = nil
-            @raw_messages = []
-            @compactions = []
-            @hwm = -1
-          end
-        end
-      end
-    end
-  end
-end

data/lib/phronomy/memory/storage.rb

@@ -1,11 +0,0 @@
-# frozen_string_literal: true
-
-module Phronomy
-  module Memory
-    # Storage is the persistence axis of conversation management.
-    # Implementations are responsible only for saving and loading raw message arrays.
-    # Token budgeting, retrieval selection, and compression are handled by other axes.
-    module Storage
-    end
-  end
-end

data/lib/phronomy/memory.rb

@@ -1,21 +0,0 @@
-# frozen_string_literal: true
-
-module Phronomy
-  module Memory
-  end
-end
-
-require_relative "memory/storage"
-require_relative "memory/storage/base"
-require_relative "memory/storage/in_memory"
-require_relative "memory/storage/active_record"
-require_relative "memory/retrieval"
-require_relative "memory/retrieval/base"
-require_relative "memory/retrieval/recent"
-require_relative "memory/retrieval/semantic"
-require_relative "memory/retrieval/composite"
-require_relative "memory/compression"
-require_relative "memory/compression/base"
-require_relative "memory/compression/summary"
-require_relative "memory/compression/tool_output_pruner"
-require_relative "memory/conversation_manager"

data/lib/phronomy/rails/agent_job.rb

@@ -1,75 +0,0 @@
-# frozen_string_literal: true
-
-module Phronomy
-  module Rails
-    # ActiveJob-based job that runs a Phronomy agent in streaming mode and
-    # broadcasts each event to an ActionCable stream.
-    #
-    # Enqueue with +perform_later+ to run the agent asynchronously in a background
-    # worker. Every streaming event is forwarded to ActionCable subscribers in
-    # real time.
-    #
-    # @example Enqueueing a streaming agent job
-    #   Phronomy::Rails::AgentJob.perform_later(
-    #     "MyAgent",
-    #     "What is the weather today?",
-    #     channel: "AgentChannel",
-    #     stream: "agent_#{current_user.id}"
-    #   )
-    #
-    # Events broadcast to the ActionCable stream:
-    #   { type: "token",   content: "..." }  — each content delta from the LLM
-    #   { type: "done",    output:  "..." }  — final complete output
-    #   { type: "error",   message: "..." }  — when the agent or job raises
-    #
-    class AgentJob < ::ActiveJob::Base
-      # @param agent_class_name [String]
-      #   The constantize-able class name of the agent to run (e.g. "MyAgent").
-      #   **Security**: only classes that are subclasses of +Phronomy::Agent::Base+
-      #   are accepted. Never pass a value derived from user-controlled input.
-      # @param input [String, Hash]
-      #   User input forwarded unchanged to the agent's +#stream+ method.
-      # @param channel [String]
-      #   ActionCable channel name. Retained for documentation / future routing.
-      # @param stream [String]
-      #   ActionCable stream identifier passed to +ActionCable.server.broadcast+.
-      # @param config [Hash]
-      #   Configuration forwarded to the agent's +#stream+ call. Both symbol and
-      #   string keys are accepted; all keys are converted to symbols before use.
-      def perform(agent_class_name, input, channel:, stream:, config: {})
-        klass = resolve_agent_class!(agent_class_name)
-        agent = klass.new
-        agent.stream(input, config: config.transform_keys(&:to_sym)) do |event|
-          ActionCable.server.broadcast(stream, build_payload(event))
-        end
-      rescue => e
-        ::Rails.logger.error("[Phronomy::Rails::AgentJob] agent error (#{e.class}): #{e.message}")
-        ActionCable.server.broadcast(stream, {type: "error", message: "An error occurred while processing your request."})
-      end
-
-      private
-
-      # Resolves and validates the agent class name.
-      # Raises ArgumentError when the name does not resolve to a subclass of
-      # Phronomy::Agent::Base, preventing arbitrary class instantiation.
-      def resolve_agent_class!(class_name)
-        klass = Object.const_get(class_name.to_s)
-        unless klass.is_a?(Class) && klass < Phronomy::Agent::Base
-          raise ArgumentError, "#{class_name.inspect} is not a Phronomy::Agent::Base subclass"
-        end
-        klass
-      rescue NameError
-        raise ArgumentError, "Unknown agent class: #{class_name.inspect}"
-      end
-
-      def build_payload(event)
-        case event.type
-        when :token then {type: "token", content: event.payload[:content]}
-        when :done then {type: "done", output: event.payload[:output]}
-        when :error then {type: "error", message: "An error occurred while processing your request."}
-        else {type: event.type.to_s}
-        end
-      end
-    end
-  end
-end

data/lib/phronomy/state_store/active_record.rb

@@ -1,76 +0,0 @@
-# frozen_string_literal: true
-
-require "json"
-
-module Phronomy
-  module StateStore
-    # ActiveRecord-backed state store.
-    # Persists graph state to a relational database using an AR model.
-    #
-    # The model_class must respond to:
-    #   .find_by(thread_id:)
-    #   .find_or_initialize_by(thread_id:)
-    #   #state_json=, #save!
-    #   .where(thread_id:).delete_all
-    #
-    # Minimal migration:
-    #   create_table :phronomy_states do |t|
-    #     t.string  :thread_id, null: false, index: { unique: true }
-    #     t.text    :state_json, null: false
-    #     t.timestamps
-    #   end
-    #
-    # @example
-    #   Phronomy.configure do |c|
-    #     c.default_state_store = Phronomy::StateStore::ActiveRecord.new(
-    #       model_class: PhronomyState
-    #     )
-    #   end
-    class ActiveRecord < Base
-      # @param model_class [Class] ActiveRecord model with the schema above.
-      # @param encryptor [Phronomy::StateStore::Encryptor::Base, nil]
-      #   Optional encryption adapter. When supplied, the JSON payload is
-      #   encrypted before writing and decrypted after reading.
-      #   When nil (default), data is stored as plain JSON.
-      def initialize(model_class:, encryptor: nil)
-        @model_class = model_class
-        @encryptor = encryptor
-      end
-
-      # Serializes and upserts the state for the given thread_id.
-      # @param state [Object] includes Phronomy::WorkflowContext
-      # @return [self]
-      def save(state)
-        json = serialize_state(state)
-        payload = @encryptor ? @encryptor.encrypt(json) : json
-        # Use upsert to avoid a race condition where two concurrent saves for the
-        # same thread_id would both see "no record" and collide on the unique index.
-        @model_class.upsert(
-          {thread_id: state.thread_id, state_json: payload},
-          unique_by: :thread_id,
-          update_only: [:state_json]
-        )
-        self
-      end
-
-      # Loads and deserializes the state for the given thread_id.
-      # @param thread_id [String]
-      # @return [Object, nil] state instance or nil
-      def load(thread_id)
-        record = @model_class.find_by(thread_id: thread_id)
-        return nil unless record
-
-        payload = record.state_json
-        json = @encryptor ? @encryptor.decrypt(payload) : payload
-        deserialize_state(json)
-      end
-
-      # Deletes the state for the given thread_id.
-      # @return [self]
-      def clear(thread_id)
-        @model_class.where(thread_id: thread_id).delete_all
-        self
-      end
-    end
-  end
-end

data/lib/phronomy/state_store/base.rb

@@ -1,112 +0,0 @@
-# frozen_string_literal: true
-
-require "json"
-
-module Phronomy
-  module StateStore
-    # Abstract base class for state persistence backends.
-    # Subclasses must implement save, load, and clear.
-    #
-    # The state object passed to save must include Phronomy::WorkflowContext
-    # and have a non-nil thread_id (set automatically by WorkflowRunner#invoke).
-    class Base
-      # Persists the state. The thread_id is read from state.thread_id.
-      # @param state [Object] object including Phronomy::WorkflowContext
-      # @return [self]
-      def save(state)
-        raise NotImplementedError, "#{self.class}#save is not implemented"
-      end
-
-      # Loads the state for the given thread_id.
-      # @param thread_id [String]
-      # @return [Object, nil] state object or nil if not found
-      def load(thread_id)
-        raise NotImplementedError, "#{self.class}#load is not implemented"
-      end
-
-      # Removes the saved state for the given thread_id.
-      # @param thread_id [String]
-      # @return [self]
-      def clear(thread_id)
-        raise NotImplementedError, "#{self.class}#clear is not implemented"
-      end
-
-      private
-
-      # Serializes a state object to a JSON string.
-      # Includes user-defined fields and internal graph metadata.
-      def serialize_state(state)
-        JSON.generate(
-          state_class: state.class.name,
-          state_data: json_safe(state.to_h),
-          thread_id: state.thread_id,
-          phase: state.phase&.to_s
-        )
-      end
-
-      # Deserializes a JSON string back into a state object.
-      # @return [Object] state instance with graph metadata restored
-      def deserialize_state(json_str)
-        data = JSON.parse(json_str, symbolize_names: true)
-        state_class = safe_state_class(data[:state_class])
-        state_data = symbolize_keys(data[:state_data])
-        state = state_class.new(**state_data)
-        state.set_graph_metadata(
-          thread_id: data[:thread_id],
-          phase: data[:phase]&.to_sym
-        )
-        state
-      end
-
-      # Resolves and validates a context class name.
-      # When a registry has been configured via +Phronomy.register_workflow_context+,
-      # only registered classes are accepted — this prevents unintended autoloading
-      # of arbitrary files from an untrusted class name stored in Redis/DB.
-      # When no registry is configured, falls back to Object.const_get with a check
-      # that the resolved class includes Phronomy::WorkflowContext.
-      def safe_state_class(class_name)
-        registry = Phronomy.workflow_context_registry
-        if registry
-          klass = registry[class_name.to_s]
-          unless klass
-            raise ArgumentError,
-              "Unregistered context class: #{class_name.inspect}. " \
-              "Call Phronomy.register_workflow_context(#{class_name}) at startup."
-          end
-          return klass
-        end
-
-        klass = Object.const_get(class_name.to_s)
-        unless klass.is_a?(Class) && klass.include?(Phronomy::WorkflowContext)
-          raise ArgumentError, "Invalid context class: #{class_name.inspect}"
-        end
-        klass
-      rescue NameError
-        raise ArgumentError, "Unknown context class: #{class_name.inspect}"
-      end
-
-      # Recursively converts objects to JSON-safe primitives.
-      def json_safe(obj)
-        case obj
-        when Hash
-          obj.transform_keys(&:to_s).transform_values { |v| json_safe(v) }
-        when Array
-          obj.map { |v| json_safe(v) }
-        when String, Numeric, TrueClass, FalseClass, NilClass
-          obj
-        else
-          obj.respond_to?(:to_h) ? json_safe(obj.to_h) : obj.to_s
-        end
-      end
-
-      # Recursively symbolizes hash keys.
-      def symbolize_keys(obj)
-        case obj
-        when Hash then obj.transform_keys(&:to_sym).transform_values { |v| symbolize_keys(v) }
-        when Array then obj.map { |v| symbolize_keys(v) }
-        else obj
-        end
-      end
-    end
-  end
-end

data/lib/phronomy/state_store/encryptor/active_support.rb

@@ -1,49 +0,0 @@
-# frozen_string_literal: true
-
-module Phronomy
-  module StateStore
-    module Encryptor
-      # Encryptor backed by ActiveSupport::MessageEncryptor.
-      #
-      # Requires the +activesupport+ gem to be available in the host application.
-      # Does NOT require rails — any Ruby project that depends on activesupport can
-      # use this adapter.
-      #
-      # @example
-      #   encryptor = Phronomy::StateStore::Encryptor::ActiveSupport.new(
-      #     secret_key_base: ENV.fetch("SECRET_KEY_BASE")
-      #   )
-      #   store = Phronomy::StateStore::ActiveRecord.new(
-      #     model_class: PhronomyState,
-      #     encryptor: encryptor
-      #   )
-      class ActiveSupport < Base
-        # @param secret_key_base [String] secret used to derive the encryption key.
-        #   Must be at least 30 random bytes (use +SecureRandom.hex(64)+ to generate).
-        # @param cipher [String] OpenSSL cipher name (default: "aes-256-gcm").
-        # @raise [LoadError] when activesupport is not available.
-        def initialize(secret_key_base:, cipher: "aes-256-gcm")
-          require "active_support/message_encryptor"
-          key = ::ActiveSupport::KeyGenerator.new(secret_key_base)
-            .generate_key("phronomy state store", 32)
-          @encryptor = ::ActiveSupport::MessageEncryptor.new(key, cipher: cipher)
-        end
-
-        # Encrypts the plaintext using AES-256-GCM.
-        # @param plaintext [String]
-        # @return [String] Base64-encoded authenticated ciphertext
-        def encrypt(plaintext)
-          @encryptor.encrypt_and_sign(plaintext)
-        end
-
-        # Decrypts and verifies the ciphertext.
-        # @param ciphertext [String]
-        # @return [String] the original plaintext
-        # @raise [ActiveSupport::MessageEncryptor::InvalidMessage] on tampered data
-        def decrypt(ciphertext)
-          @encryptor.decrypt_and_verify(ciphertext)
-        end
-      end
-    end
-  end
-end

data/lib/phronomy/state_store/encryptor/base.rb

@@ -1,34 +0,0 @@
-# frozen_string_literal: true
-
-module Phronomy
-  module StateStore
-    module Encryptor
-      # Abstract base class for state encryption adapters.
-      #
-      # Subclass and implement {#encrypt} and {#decrypt} to integrate any
-      # symmetric encryption scheme. Pass an instance to
-      # {Phronomy::StateStore::ActiveRecord} via the +encryptor:+ argument.
-      #
-      # @example
-      #   class MyEncryptor < Phronomy::StateStore::Encryptor::Base
-      #     def encrypt(plaintext) = Base64.strict_encode64(plaintext.reverse)
-      #     def decrypt(ciphertext) = Base64.strict_decode64(ciphertext).reverse
-      #   end
-      class Base
-        # Encrypts a plaintext string.
-        # @param plaintext [String] the JSON string produced by the state store
-        # @return [String] the encrypted ciphertext
-        def encrypt(plaintext)
-          raise NotImplementedError, "#{self.class}#encrypt is not implemented"
-        end
-
-        # Decrypts a ciphertext string.
-        # @param ciphertext [String] previously produced by {#encrypt}
-        # @return [String] the original plaintext
-        def decrypt(ciphertext)
-          raise NotImplementedError, "#{self.class}#decrypt is not implemented"
-        end
-      end
-    end
-  end
-end

data/lib/phronomy/state_store/encryptor.rb

@@ -1,16 +0,0 @@
-# frozen_string_literal: true
-
-require_relative "encryptor/base"
-require_relative "encryptor/active_support"
-
-module Phronomy
-  module StateStore
-    # Namespace for state encryption adapters.
-    #
-    # Available adapters:
-    # - {Phronomy::StateStore::Encryptor::Base}       — abstract interface
-    # - {Phronomy::StateStore::Encryptor::ActiveSupport} — AES-256-GCM via ActiveSupport
-    module Encryptor
-    end
-  end
-end

data/lib/phronomy/state_store/file.rb

@@ -1,85 +0,0 @@
-# frozen_string_literal: true
-
-require "fileutils"
-require "json"
-
-module Phronomy
-  module StateStore
-    # File-system-backed state store.
-    # Persists graph state as a JSON file under a configurable directory.
-    # No additional server or database migration is required — it works with
-    # the local file system out of the box.
-    #
-    # Each thread_id is stored as a separate file named "<thread_id>.json".
-    # The thread_id is sanitised before use as a filename to prevent path
-    # traversal: only alphanumeric characters, hyphens, underscores, and dots
-    # are allowed; all other characters are replaced with underscores.
-    #
-    # @note This store is suitable for single-process use (development, CLI
-    #   tools, tests).  It is not safe for concurrent access across multiple
-    #   processes without external locking.
-    #
-    # @example
-    #   store = Phronomy::StateStore::File.new(dir: "tmp/workflow_states")
-    #   Phronomy::Workflow.define(MyContext, state_store: store) do
-    #     # ...
-    #   end
-    class File < Base
-      # @param dir [String] directory where state files are stored.
-      #   Created automatically if it does not exist.
-      def initialize(dir: ::File.join(::Dir.tmpdir, "phronomy_states"))
-        @dir = ::File.expand_path(dir)
-        ::FileUtils.mkdir_p(@dir)
-      end
-
-      # @param state [Object] includes Phronomy::WorkflowContext; must have a non-nil thread_id
-      # @return [self]
-      def save(state)
-        ::File.write(path(state.thread_id), serialize_state(state))
-        self
-      end
-
-      # @param thread_id [String]
-      # @return [Object, nil] state instance or nil if not found
-      def load(thread_id)
-        file = path(thread_id)
-        return nil unless ::File.exist?(file)
-
-        deserialize_state(::File.read(file))
-      end
-
-      # Removes the saved state file for the given thread_id.
-      # @param thread_id [String]
-      # @return [self]
-      def clear(thread_id)
-        file = path(thread_id)
-        ::File.delete(file) if ::File.exist?(file)
-        self
-      end
-
-      # Removes all state files managed by this store instance.
-      # @return [self]
-      def clear_all
-        ::Dir.glob(::File.join(@dir, "*.json")).each { |f| ::File.delete(f) }
-        self
-      end
-
-      # @return [String] the directory used by this store
-      def directory
-        @dir
-      end
-
-      private
-
-      # Converts a thread_id into a safe filename component.
-      # Characters outside [A-Za-z0-9._-] are replaced with underscores.
-      def sanitize(thread_id)
-        thread_id.to_s.gsub(/[^A-Za-z0-9._-]/, "_")
-      end
-
-      def path(thread_id)
-        ::File.join(@dir, "#{sanitize(thread_id)}.json")
-      end
-    end
-  end
-end

data/lib/phronomy/state_store/in_memory.rb

@@ -1,53 +0,0 @@
-# frozen_string_literal: true
-
-module Phronomy
-  module StateStore
-    # In-memory state store backed by per-thread-id {Phronomy::Actor} instances
-    # from {Phronomy::ThreadActorRegistry}. Suitable for single-process use only.
-    class InMemory < Base
-      # Thread-local key for per-thread-id state data (namespaced by store
-      # instance object_id to support multiple independent InMemory stores).
-      THREAD_DATA_KEY = :phronomy_state_store_in_memory_data
-
-      def initialize
-      end
-
-      # @param state [Object] includes Phronomy::WorkflowContext; must have a non-nil thread_id
-      # @return [self]
-      def save(state)
-        store_id = object_id
-        Phronomy::ThreadActorRegistry.for(state.thread_id).call do
-          (Thread.current[THREAD_DATA_KEY] ||= {})[store_id] = state
-        end
-        self
-      end
-
-      # @param thread_id [String]
-      # @return [Object, nil] state object or nil
-      def load(thread_id)
-        store_id = object_id
-        Phronomy::ThreadActorRegistry.for(thread_id).call do
-          (Thread.current[THREAD_DATA_KEY] ||= {})[store_id]
-        end
-      end
-
-      # @param thread_id [String]
-      # @return [self]
-      def clear(thread_id)
-        store_id = object_id
-        Phronomy::ThreadActorRegistry.for(thread_id).call do
-          (Thread.current[THREAD_DATA_KEY] ||= {}).delete(store_id)
-        end
-        self
-      end
-
-      def clear_all
-        store_id = object_id
-        Phronomy::ThreadActorRegistry.each_actor do |actor|
-          actor.call { (Thread.current[THREAD_DATA_KEY] ||= {}).delete(store_id) }
-        end
-        self
-      end
-    end
-  end
-end