active_harness 0.2.23 → 0.2.25

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 0bf8ac57d79582b07a2d82b29be4541fcaf10b3ee8492d362d6ac10f2843537d
-  data.tar.gz: cabffcc74dd594c5222a8e0233aa9d5f7276d65cfa06848d3e2684e19efe393e
+  metadata.gz: c2a3e44b6a9f63f595ee483620a0aac1080825ce3f1d585696930db1be0991f7
+  data.tar.gz: 28382baad847f75cfdc4613c143b325d9cd4b8b31913df2812e76ff33dbd80bf
 SHA512:
-  metadata.gz: '018677f5498399d22c2a1b497649e4676023eae7b2578b8b0c13962b1c443970f20e2af5e7ca15051f75d2903287ed9f12012407cf9a671ad1d5d688d8def153'
-  data.tar.gz: 5219e6c2a208ff1a2215a71d924c24ade46b6abebc94e9a21c7a36d931d9e32919e7ddc5b054ff7bb616b46057761138aa1a01ce21e66ef6978bb5802304cabe
+  metadata.gz: f0b0422ecb620e3d9749133d17dcfd66b0328cbaf60ebe17b8c835ceb8be94fdb7c94a3b980afa85a4251ba4b42acae05bb9ad5250c8ab3c9def0e92e9094ff6
+  data.tar.gz: 5e2502fbc8ad9cf559c9cd9aecb8ea8e78abc330f442991e99a21e8cf7a3b1aa4682f3e926b3632157932ee32f1549a3e5861764b4883f7271154d81ad4dbbdb

data/lib/active_harness/memory/adapter/{file.rb → json_file.rb}

@@ -4,7 +4,7 @@ require "fileutils"
 module ActiveHarness
   class Memory
     module Adapter
-      # Persists memory as JSON files on disk.
+      # File-backed memory adapter — stores turns as JSON on disk.
       #
       # Each session is stored in one file:
       #   <path>/<session_id>.json                   (no namespace)
@@ -19,21 +19,21 @@ module ActiveHarness
       #   storage_size     — max turns kept in file          (default: 1000)
       #   eviction_percent — % of oldest turns to drop       (default: 10)
       #   on_trim          — Proc called with trimmed turns  (default: nil)
-      class File < Base
-        DEFAULT_PATH             = "storage/ai/memory"
-        DEFAULT_STORAGE_SIZE     = 1000
+      class JsonFile < Base
+        DEFAULT_PATH         = "storage/ai/memory"
+        DEFAULT_STORAGE_SIZE = 1000
         DEFAULT_TRIM_PERCENT = 10
 
         def initialize(opts = {})
-          @path             = opts.fetch(:path, DEFAULT_PATH)
-          @filename_opt     = opts[:filename]
-          @pretty           = opts.fetch(:pretty, false)
-          @compact          = opts.fetch(:compact, false)
-          @encoding         = opts.fetch(:encoding, "UTF-8")
-          @storage_size     = opts.fetch(:storage_size, DEFAULT_STORAGE_SIZE)
+          @path         = opts.fetch(:path, DEFAULT_PATH)
+          @filename_opt = opts[:filename]
+          @pretty       = opts.fetch(:pretty, false)
+          @compact      = opts.fetch(:compact, false)
+          @encoding     = opts.fetch(:encoding, "UTF-8")
+          @storage_size = opts.fetch(:storage_size, DEFAULT_STORAGE_SIZE)
           @trim_percent = opts.fetch(:eviction_percent, DEFAULT_TRIM_PERCENT)
-          @on_trim          = opts[:on_trim]
-          @namespace        = opts[:namespace]
+          @on_trim      = opts[:on_trim]
+          @namespace    = opts[:namespace]
 
           @session_id = nil
           @turns      = []
@@ -55,13 +55,12 @@ module ActiveHarness
         end
 
         def close
-          # File adapter writes immediately on each write, nothing to flush.
+          # Writes immediately on each write — nothing to flush.
         end
 
         def delete
           path = file_path
           ::FileUtils.rm_f(path)
-          # remove parent dir only if it's a namespace dir and now empty
           dir = ::File.dirname(path)
           if @namespace && Dir.exist?(dir) && Dir.empty?(dir)
             Dir.rmdir(dir)
@@ -77,8 +76,6 @@ module ActiveHarness
           name = resolve_filename
           if @namespace
             ::File.join(@path, @session_id.to_s, "#{@namespace}.json")
-          elsif @filename_opt
-            ::File.join(@path, name)
           else
             ::File.join(@path, name)
           end
@@ -100,7 +97,6 @@ module ActiveHarness
           data = JSON.parse(raw, symbolize_names: true)
           turns = Array(data[:turns])
 
-          # Normalise compact format (q/a) to full format (request/response)
           turns.map do |t|
             if t.key?(:q)
               { request: t[:q], response: t[:a] }
@@ -137,5 +133,41 @@ module ActiveHarness
         end
       end
     end
+
+    # Convenience Memory subclass for file-backed storage.
+    #
+    #   file_name:    replaces session_id — may contain slashes to create
+    #                 subdirectories under storage_path, e.g. "users/42/chat"
+    #                 Final file is always <storage_path>/<file_name>.json
+    #   storage_path: base directory (default: "storage/ai/memory")
+    #
+    # Path traversal is rejected: segments equal to "." or ".." or containing
+    # null bytes raise ArgumentError before any file I/O happens.
+    # Missing directories are created automatically on the first write.
+    class JsonFile < Memory
+      def initialize(file_name:, storage_path: Adapter::JsonFile::DEFAULT_PATH, **opts)
+        super(
+          session_id: sanitize!(file_name),
+          adapter:    Adapter::JsonFile.new(opts.merge(path: storage_path)),
+          **opts
+        )
+      end
+
+      private
+
+      def sanitize!(raw)
+        parts = raw.to_s.split("/").map(&:strip).reject(&:empty?)
+        raise ArgumentError, "file_name must not be empty" if parts.empty?
+
+        parts.each do |part|
+          if part == ".." || part == "." || part.include?("\0")
+            raise ArgumentError, "Invalid file_name segment: #{part.inspect}"
+          end
+        end
+
+        parts.last.sub!(/\.json\z/i, "")
+        parts.join("/")
+      end
+    end
   end
 end

data/lib/active_harness/memory/adapter/postgresql.rb

@@ -0,0 +1,212 @@
+require "json"
+
+module ActiveHarness
+  class Memory
+    module Adapter
+      # PostgreSQL-backed memory adapter.
+      #
+      # Requires the 'pg' gem — add it to your Gemfile yourself:
+      #   gem 'pg'
+      #
+      # Connection options (one of):
+      #   connection:  — a PG::Connection instance you manage
+      #   url:         — connection string; adapter opens and closes the connection
+      #   host:, port:, dbname:, user:, password: — adapter opens and closes the connection
+      #
+      # Storage options:
+      #   table_name:      — default "active_harness_memory_turns"
+      #   storage_size:    — max turns per session kept in the table (default 1000)
+      #   eviction_percent — % of oldest turns to drop when limit is hit (default 10)
+      #   on_trim:         — Proc called with evicted turns
+      #   namespace:       — isolates turns within a session
+      class Postgresql < Base
+        DEFAULT_TABLE        = "active_harness_memory_turns"
+        DEFAULT_STORAGE_SIZE = 1000
+        DEFAULT_TRIM_PERCENT = 10
+
+        TABLE_NAME_RE = /\A[a-zA-Z_][a-zA-Z0-9_.]*\z/
+
+        def initialize(opts = {})
+          @table        = opts.fetch(:table_name, DEFAULT_TABLE).to_s
+          @storage_size = opts.fetch(:storage_size, DEFAULT_STORAGE_SIZE)
+          @trim_percent = opts.fetch(:eviction_percent, DEFAULT_TRIM_PERCENT)
+          @on_trim      = opts[:on_trim]
+          @namespace    = opts[:namespace]
+
+          unless @table.match?(TABLE_NAME_RE)
+            raise ArgumentError, "Invalid table_name: #{@table.inspect}"
+          end
+
+          # Connection source — one of: instance, url, keyword args.
+          @borrowed_conn = opts[:connection]
+          @conn_url      = opts[:url]
+          @conn_kwargs   = opts.slice(:host, :port, :dbname, :user, :password)
+
+          @owned_conn  = nil
+          @session_id  = nil
+          @turns       = []
+        end
+
+        def open(session_id)
+          @session_id = session_id
+          ensure_connection!
+          @turns = fetch_turns
+        end
+
+        def read
+          @turns.dup
+        end
+
+        def write(turn)
+          insert_turn(turn)
+          @turns << turn
+          trim_if_needed!
+        end
+
+        def close
+          if @owned_conn
+            @owned_conn.close rescue nil
+            @owned_conn = nil
+          end
+        end
+
+        def delete
+          conn.exec_params(
+            "DELETE FROM #{@table} " \
+            "WHERE session_id = $1 AND (namespace IS NOT DISTINCT FROM $2)",
+            [@session_id, @namespace]
+          )
+          @turns = []
+        end
+
+        # -----------------------------------------------------------------------
+        private
+        # -----------------------------------------------------------------------
+
+        def conn
+          @borrowed_conn || @owned_conn ||
+            raise("PostgreSQL connection not open — call open(session_id) first")
+        end
+
+        def ensure_connection!
+          return if @borrowed_conn || @owned_conn
+
+          load_pg!
+
+          @owned_conn =
+            if @conn_url
+              PG.connect(@conn_url)
+            elsif @conn_kwargs.any?
+              PG.connect(**@conn_kwargs)
+            else
+              raise ArgumentError,
+                "PostgreSQL adapter requires one of: connection:, url:, " \
+                "or connection keyword args (host:, port:, dbname:, user:, password:)"
+            end
+        end
+
+        def load_pg!
+          require "pg"
+        rescue LoadError
+          raise LoadError,
+            "The 'pg' gem is required for the PostgreSQL memory adapter. " \
+            "Add it to your Gemfile:  gem 'pg'"
+        end
+
+        def fetch_turns
+          result = conn.exec_params(
+            "SELECT request, response, meta " \
+            "FROM #{@table} " \
+            "WHERE session_id = $1 AND (namespace IS NOT DISTINCT FROM $2) " \
+            "ORDER BY id ASC",
+            [@session_id, @namespace]
+          )
+
+          result.map do |row|
+            turn = { request: row["request"], response: row["response"] }
+            meta = JSON.parse(row["meta"] || "{}", symbolize_names: true)
+            meta.empty? ? turn : turn.merge(meta)
+          end
+        end
+
+        def insert_turn(turn)
+          meta = turn.reject { |k, _| k == :request || k == :response }
+
+          conn.exec_params(
+            "INSERT INTO #{@table} (session_id, namespace, request, response, meta) " \
+            "VALUES ($1, $2, $3, $4, $5::jsonb)",
+            [
+              @session_id,
+              @namespace,
+              turn[:request].to_s,
+              turn[:response].to_s,
+              JSON.generate(meta)
+            ]
+          )
+        end
+
+        def trim_if_needed!
+          return unless @storage_size
+          return if @turns.size <= @storage_size
+
+          to_delete = [@turns.size * @trim_percent / 100, 1].max
+
+          if @on_trim
+            trimmed = @turns.first(to_delete)
+            @on_trim.call(trimmed)
+          end
+
+          conn.exec_params(
+            "DELETE FROM #{@table} WHERE id IN (" \
+            "  SELECT id FROM #{@table} " \
+            "  WHERE session_id = $1 AND (namespace IS NOT DISTINCT FROM $2) " \
+            "  ORDER BY id ASC LIMIT $3" \
+            ")",
+            [@session_id, @namespace, to_delete]
+          )
+
+          @turns.shift(to_delete)
+        end
+      end
+    end
+
+    # Convenience Memory subclass for PostgreSQL-backed storage.
+    #
+    # Requires the 'pg' gem installed by the application:
+    #   gem 'pg'
+    #
+    # Usage — plain Ruby (adapter owns the connection):
+    #   mem = ActiveHarness::Memory::Postgresql.new(
+    #     session_id: "user_42",
+    #     url:        ENV["DATABASE_URL"],
+    #     depth:      10
+    #   )
+    #   mem.load
+    #   # ... use ...
+    #   mem.close
+    #
+    # Usage — Rails (borrow the AR raw connection):
+    #   mem = ActiveHarness::Memory::Postgresql.new(
+    #     session_id: "user_42",
+    #     connection: ActiveRecord::Base.connection.raw_connection
+    #   )
+    class Postgresql < Memory
+      def initialize(session_id:, namespace: nil, on_trim: nil, **opts)
+        mem_keys = %i[depth enabled read_only async]
+        mem_opts = opts.slice(*mem_keys)
+        pg_opts  = opts.reject { |k, _| mem_keys.include?(k) }
+
+        pg_opts[:namespace] = namespace if namespace
+        pg_opts[:on_trim]   = on_trim   if on_trim
+
+        super(
+          session_id: session_id,
+          adapter:    Adapter::Postgresql.new(pg_opts),
+          namespace:  namespace,
+          on_trim:    on_trim,
+          **mem_opts
+        )
+      end
+    end
+  end
+end

data/lib/active_harness/memory/adapter/sqlite.rb

@@ -0,0 +1,233 @@
+require "json"
+
+module ActiveHarness
+  class Memory
+    module Adapter
+      # SQLite-backed memory adapter.
+      #
+      # Requires the 'sqlite3' gem — add it to your Gemfile yourself:
+      #   gem 'sqlite3'
+      #
+      # Connection options (one of):
+      #   database:   — path to the SQLite file; adapter opens and closes the connection
+      #               use ":memory:" for an in-process, non-persistent database
+      #   connection: — an existing SQLite3::Database instance you manage
+      #
+      # Storage options:
+      #   table_name:      — default "active_harness_memory_turns"
+      #   storage_size:    — max turns per session kept in the table (default 1000)
+      #   eviction_percent — % of oldest turns to drop when limit is hit (default 10)
+      #   on_trim:         — Proc called with evicted turns
+      #   namespace:       — isolates turns within a session
+      class Sqlite < Base
+        DEFAULT_TABLE        = "active_harness_memory_turns"
+        DEFAULT_STORAGE_SIZE = 1000
+        DEFAULT_TRIM_PERCENT = 10
+
+        TABLE_NAME_RE = /\A[a-zA-Z_][a-zA-Z0-9_.]*\z/
+
+        def initialize(opts = {})
+          @table        = opts.fetch(:table_name, DEFAULT_TABLE).to_s
+          @storage_size = opts.fetch(:storage_size, DEFAULT_STORAGE_SIZE)
+          @trim_percent = opts.fetch(:eviction_percent, DEFAULT_TRIM_PERCENT)
+          @on_trim      = opts[:on_trim]
+          @namespace    = opts[:namespace]
+
+          unless @table.match?(TABLE_NAME_RE)
+            raise ArgumentError, "Invalid table_name: #{@table.inspect}"
+          end
+
+          @borrowed_conn = opts[:connection]
+          @db_path       = opts[:database]
+          @owned_conn    = nil
+          @session_id    = nil
+          @turns         = []
+        end
+
+        def open(session_id)
+          @session_id = session_id
+          ensure_connection!
+          @turns = fetch_turns
+        end
+
+        def read
+          @turns.dup
+        end
+
+        def write(turn)
+          insert_turn(turn)
+          @turns << turn
+          trim_if_needed!
+        end
+
+        def close
+          if @owned_conn
+            @owned_conn.close rescue nil
+            @owned_conn = nil
+          end
+        end
+
+        def delete
+          db.execute(
+            "DELETE FROM #{@table} WHERE session_id = ? AND (namespace IS ?)",
+            [@session_id, @namespace]
+          )
+          @turns = []
+        end
+
+        # -----------------------------------------------------------------------
+        private
+        # -----------------------------------------------------------------------
+
+        def db
+          @borrowed_conn || @owned_conn ||
+            raise("SQLite connection not open — call open(session_id) first")
+        end
+
+        def ensure_connection!
+          return if @borrowed_conn || @owned_conn
+
+          load_sqlite3!
+
+          unless @db_path
+            raise ArgumentError,
+              "SQLite adapter requires database: (file path or ':memory:')"
+          end
+
+          conn = SQLite3::Database.new(@db_path)
+          conn.execute("PRAGMA journal_mode=WAL")
+          @owned_conn = conn
+        end
+
+        def load_sqlite3!
+          require "sqlite3"
+        rescue LoadError
+          raise LoadError,
+            "The 'sqlite3' gem is required for the SQLite memory adapter. " \
+            "Add it to your Gemfile:  gem 'sqlite3'"
+        end
+
+        def fetch_turns
+          rows = db.execute(
+            "SELECT request, response, meta " \
+            "FROM #{@table} " \
+            "WHERE session_id = ? AND (namespace IS ?) " \
+            "ORDER BY id ASC",
+            [@session_id, @namespace]
+          )
+          rows.map do |row|
+            # row is Array (default) or Hash (results_as_hash=true) — handle both
+            req, resp, meta_str =
+              row.is_a?(Hash) ? row.values_at("request", "response", "meta") : row
+            turn = { request: req, response: resp }
+            meta = JSON.parse(meta_str || "{}", symbolize_names: true)
+            meta.empty? ? turn : turn.merge(meta)
+          end
+        end
+
+        def insert_turn(turn)
+          meta = turn.reject { |k, _| k == :request || k == :response }
+          db.execute(
+            "INSERT INTO #{@table} (session_id, namespace, request, response, meta) " \
+            "VALUES (?, ?, ?, ?, ?)",
+            [
+              @session_id,
+              @namespace,
+              turn[:request].to_s,
+              turn[:response].to_s,
+              JSON.generate(meta)
+            ]
+          )
+        end
+
+        def trim_if_needed!
+          return unless @storage_size
+          return if @turns.size <= @storage_size
+
+          to_delete = [@turns.size * @trim_percent / 100, 1].max
+
+          if @on_trim
+            trimmed = @turns.first(to_delete)
+            @on_trim.call(trimmed)
+          end
+
+          db.execute(
+            "DELETE FROM #{@table} WHERE id IN (" \
+            "  SELECT id FROM #{@table} " \
+            "  WHERE session_id = ? AND (namespace IS ?) " \
+            "  ORDER BY id ASC LIMIT ?" \
+            ")",
+            [@session_id, @namespace, to_delete]
+          )
+
+          @turns.shift(to_delete)
+        end
+      end
+    end
+
+    # Convenience Memory subclass for SQLite-backed storage.
+    #
+    # Usage — plain Ruby (adapter owns the connection):
+    #   mem = ActiveHarness::Memory::Sqlite.new(
+    #     session_id: "user_42",
+    #     database:   "storage/ai/memory.sqlite3",
+    #     depth:      10
+    #   )
+    #   mem.load
+    #   # ... use ...
+    #   mem.close
+    #
+    # Usage — Rails (borrow AR raw connection for SQLite3 adapter):
+    #   mem = ActiveHarness::Memory::Sqlite.new(
+    #     session_id: "user_42",
+    #     connection: ActiveRecord::Base.connection.raw_connection
+    #   )
+    #
+    # Plain Ruby schema setup (run once before first use):
+    #   ActiveHarness::Memory::Sqlite.create_schema!("storage/ai/memory.sqlite3")
+    class Sqlite < Memory
+      # SQL to create the schema — run once before first use in plain Ruby.
+      SCHEMA_SQL = <<~SQL.freeze
+        CREATE TABLE IF NOT EXISTS active_harness_memory_turns (
+          id         INTEGER  PRIMARY KEY AUTOINCREMENT,
+          session_id TEXT     NOT NULL,
+          namespace  TEXT,
+          request    TEXT     NOT NULL,
+          response   TEXT     NOT NULL,
+          meta       TEXT     NOT NULL DEFAULT '{}',
+          created_at TEXT     NOT NULL DEFAULT (datetime('now'))
+        );
+        CREATE INDEX IF NOT EXISTS idx_ah_memory_turns_session
+          ON active_harness_memory_turns (session_id, namespace, id);
+      SQL
+
+      # Create the schema on an existing database or a file path.
+      # Safe to call multiple times — uses CREATE TABLE IF NOT EXISTS.
+      def self.create_schema!(db_or_path)
+        require "sqlite3"
+        conn = db_or_path.is_a?(String) ? SQLite3::Database.new(db_or_path) : db_or_path
+        SCHEMA_SQL.split(";").map(&:strip).reject(&:empty?).each { |sql| conn.execute(sql) }
+      rescue LoadError
+        raise LoadError,
+          "The 'sqlite3' gem is required. Add it to your Gemfile:  gem 'sqlite3'"
+      end
+
+      def initialize(session_id:, namespace: nil, on_trim: nil, **opts)
+        mem_keys = %i[depth enabled read_only async]
+        mem_opts = opts.slice(*mem_keys)
+        sq_opts  = opts.reject { |k, _| mem_keys.include?(k) }
+
+        sq_opts[:namespace] = namespace if namespace
+        sq_opts[:on_trim]   = on_trim   if on_trim
+
+        super(
+          session_id: session_id,
+          adapter:    Adapter::Sqlite.new(sq_opts),
+          namespace:  namespace,
+          on_trim:    on_trim,
+          **mem_opts
+        )
+      end
+    end
+  end
+end

data/lib/active_harness/memory.rb

@@ -1,5 +1,7 @@
 require_relative "memory/adapter/base"
-require_relative "memory/adapter/file"
+require_relative "memory/adapter/json_file"
+require_relative "memory/adapter/postgresql"
+require_relative "memory/adapter/sqlite"
 
 module ActiveHarness
   # Conversational memory for agents.
@@ -54,7 +56,7 @@ module ActiveHarness
   #
   class Memory
     ADAPTERS = {
-      file: ->(**opts) { Adapter::File.new(**opts) }
+      json_file: ->(**opts) { Adapter::JsonFile.new(**opts) }
     }.freeze
 
     attr_reader :session_id
@@ -64,7 +66,7 @@ module ActiveHarness
     # -------------------------------------------------------------------------
     #   session_id       — required; uniquely identifies this conversation
     #   depth            — how many past turns to inject into messages (nil = all)
-    #   adapter          — :file (default), or an adapter instance
+    #   adapter          — :json_file (default), or an adapter instance
     #   enabled          — false disables all reads and writes (no-op mode)
     #   read_only        — true: load history but never write new turns
     #   namespace        — isolates history per-agent within a session
@@ -74,7 +76,7 @@ module ActiveHarness
     def initialize(
       session_id:,
       depth:       nil,
-      adapter:     :file,
+      adapter:     :json_file,
       enabled:     true,
       read_only:   false,
       namespace:   nil,

data/lib/active_harness.rb

@@ -30,7 +30,7 @@ require_relative "active_harness/pipeline"
 require_relative "active_harness/railtie" if defined?(Rails::Railtie)
 
 module ActiveHarness
-  VERSION = "0.2.23"
+  VERSION = "0.2.25"
 
   class << self
     # Configure ActiveHarness.

data/lib/generators/active_harness/install/templates/memory/app_memory.rb

@@ -1,16 +1,16 @@
-class AppMemory < ActiveHarness::Memory
-  # Usage: AppMemory.new(session_id: "user_42")
+class AppMemory < ActiveHarness::Memory::JsonFile
+  # Usage: AppMemory.new(file_name: "users/42")
   #
-  # Wraps ActiveHarness::Memory with project defaults so callers
-  # only need to pass a session_id.
-  def initialize(session_id:)
+  # Wraps ActiveHarness::Memory::JsonFile with project defaults so callers
+  # only need to pass a file_name. Slashes create subdirectories.
+  def initialize(file_name:, **opts)
     super(
-      session_id:   session_id,
+      file_name:    file_name,
+      storage_path: Rails.root.join("storage", "ai", "memory").to_s,
       depth:        10,
-      adapter:      :file,
-      path:         Rails.root.join("storage", "ai", "memory").to_s,
       storage_size: 200,
-      pretty:       Rails.env.development?
+      pretty:       Rails.env.development?,
+      **opts
     )
   end
 end

data/lib/generators/active_harness/memory/templates/memory.rb.tt

@@ -1,12 +1,12 @@
-class <%= class_name %>Memory < ActiveHarness::Memory
-  def initialize(session_id:)
+class <%= class_name %>Memory < ActiveHarness::Memory::JsonFile
+  def initialize(file_name:, **opts)
     super(
-      session_id:   session_id,
+      file_name:    file_name,
+      storage_path: Rails.root.join("storage", "ai", "memory").to_s,
       depth:        10,
-      adapter:      :file,
-      path:         Rails.root.join("storage", "ai", "memory").to_s,
       storage_size: 200,
-      pretty:       Rails.env.development?
+      pretty:       Rails.env.development?,
+      **opts
     )
   end
 end

data/lib/generators/active_harness/memory_postgresql/memory_postgresql_generator.rb

@@ -0,0 +1,23 @@
+require "rails/generators"
+require "rails/generators/active_record"
+
+module ActiveHarness
+  module Generators
+    class MemoryPostgresqlGenerator < Rails::Generators::Base
+      include Rails::Generators::Migration
+
+      source_root File.expand_path("templates", __dir__)
+
+      desc "Creates the ActiveHarness PostgreSQL memory migration"
+
+      def self.next_migration_number(dirname)
+        ActiveRecord::Generators::Base.next_migration_number(dirname)
+      end
+
+      def create_migration_file
+        migration_template "create_active_harness_memory_turns.rb.tt",
+                           "db/migrate/create_active_harness_memory_turns.rb"
+      end
+    end
+  end
+end

data/lib/generators/active_harness/memory_postgresql/templates/create_active_harness_memory_turns.rb.tt

@@ -0,0 +1,16 @@
+class CreateActiveHarnessMemoryTurns < ActiveRecord::Migration[<%= ActiveRecord::Migration.current_version %>]
+  def change
+    create_table :active_harness_memory_turns do |t|
+      t.text     :session_id, null: false
+      t.text     :namespace
+      t.text     :request,    null: false
+      t.text     :response,   null: false
+      t.jsonb    :meta,       null: false, default: {}
+      t.datetime :created_at, null: false, default: -> { "NOW()" }
+    end
+
+    add_index :active_harness_memory_turns,
+              [:session_id, :namespace, :id],
+              name: "idx_ah_memory_turns_session"
+  end
+end

data/lib/generators/active_harness/memory_sqlite/memory_sqlite_generator.rb

@@ -0,0 +1,23 @@
+require "rails/generators"
+require "rails/generators/active_record"
+
+module ActiveHarness
+  module Generators
+    class MemorySqliteGenerator < Rails::Generators::Base
+      include Rails::Generators::Migration
+
+      source_root File.expand_path("templates", __dir__)
+
+      desc "Creates the ActiveHarness SQLite memory migration"
+
+      def self.next_migration_number(dirname)
+        ActiveRecord::Generators::Base.next_migration_number(dirname)
+      end
+
+      def create_migration_file
+        migration_template "create_active_harness_memory_turns.rb.tt",
+                           "db/migrate/create_active_harness_memory_turns.rb"
+      end
+    end
+  end
+end

data/lib/generators/active_harness/memory_sqlite/templates/create_active_harness_memory_turns.rb.tt

@@ -0,0 +1,16 @@
+class CreateActiveHarnessMemoryTurns < ActiveRecord::Migration[<%= ActiveRecord::Migration.current_version %>]
+  def change
+    create_table :active_harness_memory_turns do |t|
+      t.text     :session_id, null: false
+      t.text     :namespace
+      t.text     :request,    null: false
+      t.text     :response,   null: false
+      t.text     :meta,       null: false, default: "{}"
+      t.datetime :created_at, null: false, default: -> { "CURRENT_TIMESTAMP" }
+    end
+
+    add_index :active_harness_memory_turns,
+              [:session_id, :namespace, :id],
+              name: "idx_ah_memory_turns_session"
+  end
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: active_harness
 version: !ruby/object:Gem::Version
-  version: 0.2.23
+  version: 0.2.25
 platform: ruby
 authors:
 - the-teacher
@@ -50,7 +50,9 @@ files:
 - lib/active_harness/http/streaming_client.rb
 - lib/active_harness/memory.rb
 - lib/active_harness/memory/adapter/base.rb
-- lib/active_harness/memory/adapter/file.rb
+- lib/active_harness/memory/adapter/json_file.rb
+- lib/active_harness/memory/adapter/postgresql.rb
+- lib/active_harness/memory/adapter/sqlite.rb
 - lib/active_harness/pipeline.rb
 - lib/active_harness/pipeline/hooks.rb
 - lib/active_harness/pipeline/step.rb
@@ -91,6 +93,10 @@ files:
 - lib/generators/active_harness/install/templates/tribunals/support_guard_tribunal.rb
 - lib/generators/active_harness/memory/memory_generator.rb
 - lib/generators/active_harness/memory/templates/memory.rb.tt
+- lib/generators/active_harness/memory_postgresql/memory_postgresql_generator.rb
+- lib/generators/active_harness/memory_postgresql/templates/create_active_harness_memory_turns.rb.tt
+- lib/generators/active_harness/memory_sqlite/memory_sqlite_generator.rb
+- lib/generators/active_harness/memory_sqlite/templates/create_active_harness_memory_turns.rb.tt
 - lib/generators/active_harness/pipeline/pipeline_generator.rb
 - lib/generators/active_harness/pipeline/templates/pipeline.rb.tt
 - lib/generators/active_harness/prompt/prompt_generator.rb