llmemory 0.2.6 → 0.2.8

data/lib/llmemory/short_term/stores/postgres_store.rb

@@ -13,58 +13,103 @@ module Llmemory
           @database_url = database_url || Llmemory.configuration.database_url
           @connection = nil
           @cipher = cipher || Llmemory.build_cipher
+          @table_ready = false
+          @conn_mutex = Mutex.new
         end
 
         def save(user_id, session_id, state)
-          ensure_table!
-          conn.exec_params(
-            <<~SQL,
-              INSERT INTO llmemory_checkpoints (user_id, session_id, state, updated_at)
-              VALUES ($1, $2, $3, $4)
-              ON CONFLICT (user_id, session_id)
-              DO UPDATE SET state = $3, updated_at = $4
-            SQL
-            [user_id, session_id, serialize(state), Time.now.utc.iso8601]
-          )
+          with_conn do |connection|
+            ensure_table!(connection)
+            connection.exec_params(
+              <<~SQL,
+                INSERT INTO llmemory_checkpoints (user_id, session_id, state, updated_at)
+                VALUES ($1, $2, $3, $4)
+                ON CONFLICT (user_id, session_id)
+                DO UPDATE SET state = $3, updated_at = $4
+              SQL
+              [user_id, session_id, serialize(state), Time.now.utc.iso8601]
+            )
+          end
           true
         end
 
         def load(user_id, session_id)
-          ensure_table!
-          result = conn.exec_params(
-            "SELECT state FROM llmemory_checkpoints WHERE user_id = $1 AND session_id = $2",
-            [user_id, session_id]
-          )
-          row = result.first
-          row ? deserialize(row["state"]) : nil
+          with_conn do |connection|
+            ensure_table!(connection)
+            result = connection.exec_params(
+              "SELECT state FROM llmemory_checkpoints WHERE user_id = $1 AND session_id = $2",
+              [user_id, session_id]
+            )
+            row = result.first
+            row ? deserialize(row["state"]) : nil
+          end
         end
 
         def delete(user_id, session_id)
-          ensure_table!
-          conn.exec_params(
-            "DELETE FROM llmemory_checkpoints WHERE user_id = $1 AND session_id = $2",
-            [user_id, session_id]
-          )
+          with_conn do |connection|
+            ensure_table!(connection)
+            connection.exec_params(
+              "DELETE FROM llmemory_checkpoints WHERE user_id = $1 AND session_id = $2",
+              [user_id, session_id]
+            )
+          end
           true
         end
 
+        def update(user_id, session_id, &block)
+          with_conn do |connection|
+            ensure_table!(connection)
+            connection.transaction do
+              result = connection.exec_params(
+                "SELECT state FROM llmemory_checkpoints WHERE user_id = $1 AND session_id = $2 FOR UPDATE",
+                [user_id, session_id]
+              )
+              row = result.first
+              current = row ? deserialize(row["state"]) : nil
+              new_state = yield(current)
+              next new_state if new_state.nil?
+
+              connection.exec_params(
+                <<~SQL,
+                  INSERT INTO llmemory_checkpoints (user_id, session_id, state, updated_at)
+                  VALUES ($1, $2, $3, $4)
+                  ON CONFLICT (user_id, session_id)
+                  DO UPDATE SET state = $3, updated_at = $4
+                SQL
+                [user_id, session_id, serialize(new_state), Time.now.utc.iso8601]
+              )
+              new_state
+            end
+          end
+        end
+
         def list_users
-          ensure_table!
-          result = conn.exec("SELECT DISTINCT user_id FROM llmemory_checkpoints")
-          result.map { |r| r["user_id"] }
+          with_conn do |connection|
+            ensure_table!(connection)
+            result = connection.exec("SELECT DISTINCT user_id FROM llmemory_checkpoints")
+            result.map { |r| r["user_id"] }
+          end
         end
 
         def list_sessions(user_id:)
-          ensure_table!
-          result = conn.exec_params(
-            "SELECT session_id FROM llmemory_checkpoints WHERE user_id = $1",
-            [user_id]
-          )
-          result.map { |r| r["session_id"] }
+          with_conn do |connection|
+            ensure_table!(connection)
+            result = connection.exec_params(
+              "SELECT session_id FROM llmemory_checkpoints WHERE user_id = $1",
+              [user_id]
+            )
+            result.map { |r| r["session_id"] }
+          end
         end
 
         private
 
+        def with_conn
+          @conn_mutex.synchronize do
+            yield(conn)
+          end
+        end
+
         def conn
           @connection ||= begin
             require "pg"
@@ -72,8 +117,10 @@ module Llmemory
           end
         end
 
-        def ensure_table!
-          conn.exec(<<~SQL)
+        def ensure_table!(connection)
+          return if @table_ready
+
+          connection.exec(<<~SQL)
             CREATE TABLE IF NOT EXISTS llmemory_checkpoints (
               user_id TEXT NOT NULL,
               session_id TEXT NOT NULL,
@@ -82,6 +129,7 @@ module Llmemory
               PRIMARY KEY (user_id, session_id)
             )
           SQL
+          @table_ready = true
         end
 
         def serialize(state)

data/lib/llmemory/short_term/stores/redis_store.rb

@@ -2,6 +2,8 @@
 
 require_relative "base"
 require_relative "../../crypto/field_helpers"
+require_relative "key_codec"
+require_relative "../session_lifecycle"
 
 module Llmemory
   module ShortTerm
@@ -9,39 +11,96 @@ module Llmemory
       class RedisStore < Base
         include Llmemory::Crypto::FieldHelpers
 
+        KEY_PREFIX = "llmemory:checkpoint"
+        MAX_CAS_RETRIES = 5
+
         def initialize(redis_url: nil, cipher: nil)
           @redis_url = redis_url || Llmemory.configuration.redis_url
           @redis = nil
           @cipher = cipher || Llmemory.build_cipher
+          @conn_mutex = Mutex.new
         end
 
         def save(user_id, session_id, state)
-          redis.set(key_for(user_id, session_id), serialize(state), ex: 86400 * 7) # 7 days TTL
+          with_redis do |client|
+            key = key_for(user_id, session_id)
+            payload = serialize(state)
+            if pseudo_session?(session_id)
+              client.set(key, payload)
+            else
+              client.set(key, payload, ex: session_ttl_seconds)
+            end
+          end
           true
         end
 
         def load(user_id, session_id)
-          data = redis.get(key_for(user_id, session_id))
-          data ? deserialize(data) : nil
+          with_redis do |client|
+            data = client.get(key_for(user_id, session_id))
+            data ? deserialize(data) : nil
+          end
         end
 
         def delete(user_id, session_id)
-          redis.del(key_for(user_id, session_id))
+          with_redis { |client| client.del(key_for(user_id, session_id)) }
           true
         end
 
+        def update(user_id, session_id, &block)
+          key = key_for(user_id, session_id)
+          retries = 0
+
+          loop do
+            result = with_redis do |client|
+              client.watch(key) do
+                raw = client.get(key)
+                current = raw ? deserialize(raw) : nil
+                new_state = yield(current)
+                next new_state if new_state.nil?
+
+                payload = serialize(new_state)
+                if pseudo_session?(session_id)
+                  client.multi { |multi| multi.set(key, payload) }
+                else
+                  client.multi { |multi| multi.set(key, payload, ex: session_ttl_seconds) }
+                end
+                new_state
+              end
+            end
+            return result unless result.nil?
+
+            retries += 1
+            raise Llmemory::StoreError, "Redis CAS update failed after #{MAX_CAS_RETRIES} retries" if retries >= MAX_CAS_RETRIES
+          end
+        end
+
         def list_users
-          keys = redis.keys("llmemory:checkpoint:*:*")
-          keys.map { |k| k.split(":")[2] }.uniq
+          scan_keys("#{KEY_PREFIX}:*").filter_map do |k|
+            parts = k.split(":", 4)
+            next unless parts.size >= 4
+
+            KeyCodec.decode(parts[2])
+          end.uniq
         end
 
         def list_sessions(user_id:)
-          keys = redis.keys("llmemory:checkpoint:#{user_id}:*")
-          keys.map { |k| k.split(":", 4).last }
+          encoded_user = KeyCodec.encode(user_id)
+          scan_keys("#{KEY_PREFIX}:#{encoded_user}:*").filter_map do |k|
+            parts = k.split(":", 4)
+            next unless parts.size >= 4
+
+            KeyCodec.decode(parts[3])
+          end
         end
 
         private
 
+        def with_redis
+          @conn_mutex.synchronize do
+            yield(redis)
+          end
+        end
+
         def redis
           @redis ||= begin
             require "redis"
@@ -49,8 +108,16 @@ module Llmemory
           end
         end
 
+        def scan_keys(match)
+          keys = []
+          with_redis do |client|
+            client.scan_each(match: match) { |key| keys << key }
+          end
+          keys
+        end
+
         def key_for(user_id, session_id)
-          "llmemory:checkpoint:#{user_id}:#{session_id}"
+          "#{KEY_PREFIX}:#{KeyCodec.encode(user_id)}:#{KeyCodec.encode(session_id)}"
         end
 
         def serialize(state)
@@ -60,6 +127,15 @@ module Llmemory
         def deserialize(data)
           deserialize_state(data)
         end
+
+        def pseudo_session?(session_id)
+          SessionLifecycle.pseudo_session?(session_id)
+        end
+
+        def session_ttl_seconds
+          ttl = Llmemory.configuration.redis_session_ttl_seconds
+          ttl.positive? ? ttl : 86_400 * 30
+        end
       end
     end
   end

data/lib/llmemory/short_term/stores.rb

@@ -1,5 +1,6 @@
 # frozen_string_literal: true
 
+require_relative "stores/key_codec"
 require_relative "stores/base"
 require_relative "stores/memory_store"
 require_relative "stores/redis_store"
@@ -12,8 +13,14 @@ module Llmemory
       # Shared by Checkpoint, SessionLifecycle and WorkingMemory.
       def self.build(store_type = nil, cipher: nil)
         resolved_cipher = cipher || Llmemory.build_cipher
-        case (store_type || Llmemory.configuration.short_term_store).to_sym
-        when :memory then MemoryStore.new(cipher: resolved_cipher)
+        type = (store_type || Llmemory.configuration.short_term_store).to_sym
+        case type
+        when :memory
+          if Llmemory.configuration.shared_memory_stores
+            shared_memory_store(resolved_cipher)
+          else
+            MemoryStore.new(cipher: resolved_cipher)
+          end
         when :redis then RedisStore.new(cipher: resolved_cipher)
         when :postgres then PostgresStore.new(cipher: resolved_cipher)
         when :active_record, :activerecord
@@ -23,6 +30,14 @@ module Llmemory
           MemoryStore.new(cipher: resolved_cipher)
         end
       end
+
+      def self.shared_memory_store(cipher)
+        @shared_memory_store ||= MemoryStore.new(cipher: cipher)
+      end
+
+      def self.reset_shared_singletons!
+        @shared_memory_store = nil
+      end
     end
   end
 end

data/lib/llmemory/vector_store/active_record_store.rb

@@ -1,12 +1,14 @@
 # frozen_string_literal: true
 
 require_relative "base"
+require_relative "../active_record_helpers"
 
 module Llmemory
   module VectorStore
     # Persists embeddings in llmemory_embeddings (pgvector).
     # Use when long_term_store is :active_record so hybrid search finds persisted embeddings.
     class ActiveRecordStore < Base
+      include Llmemory::ActiveRecordHelpers
       def initialize(embedding_provider: nil, source_type: "edge", cipher: nil)
         self.class.load_model!
         @embedding_provider = embedding_provider
@@ -35,14 +37,16 @@ module Llmemory
       def store(id:, embedding:, metadata: {}, user_id: nil)
         return id if user_id.nil? || user_id.to_s.empty?
         text_content = (metadata || {}).dig("text") || (metadata || {}).dig(:text)
-        rec = Llmemory::VectorStore::ActiveRecordEmbedding.find_or_initialize_by(
-          user_id: user_id.to_s,
-          source_type: @source_type,
-          source_id: id.to_s
-        )
-        rec.embedding = embedding.to_a.map(&:to_f)
-        rec.text_content = encrypt_text_content(text_content)
-        rec.save!
+        with_unique_retry do
+          rec = Llmemory::VectorStore::ActiveRecordEmbedding.find_or_initialize_by(
+            user_id: user_id.to_s,
+            source_type: @source_type,
+            source_id: id.to_s
+          )
+          rec.embedding = embedding.to_a.map(&:to_f)
+          rec.text_content = encrypt_text_content(text_content)
+          rec.save!
+        end
         id
       end
 
@@ -81,6 +85,17 @@ module Llmemory
         search(query_embedding, top_k: top_k, user_id: user_id)
       end
 
+      def delete(id:, user_id: nil)
+        return false if user_id.nil? || user_id.to_s.empty?
+
+        Llmemory::VectorStore::ActiveRecordEmbedding.where(
+          user_id: user_id.to_s,
+          source_type: @source_type,
+          source_id: id.to_s
+        ).delete_all
+        true
+      end
+
       private
 
       def encrypt_text_content(text)

data/lib/llmemory/vector_store/base.rb

@@ -14,6 +14,10 @@ module Llmemory
       def search(query_embedding, top_k: 10)
         raise NotImplementedError, "#{self.class}#search must be implemented"
       end
+
+      def delete(id:, user_id: nil)
+        raise NotImplementedError, "#{self.class}#delete must be implemented"
+      end
     end
   end
 end

data/lib/llmemory/vector_store/memory_store.rb

@@ -55,6 +55,15 @@ module Llmemory
         search(query_embedding, top_k: top_k, user_id: user_id)
       end
 
+      def delete(id:, user_id: nil)
+        if user_id
+          @entries.delete("#{user_id}:#{id}")
+        else
+          @entries.delete_if { |_key, data| data[:source_id].to_s == id.to_s }
+        end
+        true
+      end
+
       private
 
       def decrypt_metadata(meta)

data/lib/llmemory/vector_store/openai_embeddings.rb

@@ -5,18 +5,21 @@ require "json"
 require "digest"
 require_relative "base"
 require_relative "../llm/usage"
+require_relative "../llm/http_client"
 
 module Llmemory
   module VectorStore
     class OpenAIEmbeddings < Base
+      include Llmemory::LLM::HttpClient
       DEFAULT_MODEL = "text-embedding-3-small"
       DEFAULT_DIMS = 1536
 
       attr_reader :last_usage
 
-      def initialize(api_key: nil, model: nil)
+      def initialize(api_key: nil, model: nil, base_url: nil)
         @api_key = api_key || Llmemory.configuration.llm_api_key
         @model = model || DEFAULT_MODEL
+        @base_url = base_url || Llmemory.configuration.llm_base_url || "https://api.openai.com/v1"
         @cache = {}
         @cache_order = []
         @last_usage = Llmemory::LLM::Usage.zero
@@ -64,7 +67,7 @@ module Llmemory
         result = nil
         payload = { provider: :openai, model: @model, text_chars: text.to_s.length }
         Llmemory::Instrumentation.instrument(:llm_embed, payload) do
-          response = connection.post("embeddings") do |req|
+          response = post_with_resilience(connection, "embeddings") do |req|
             req.headers["Authorization"] = "Bearer #{@api_key}"
             req.headers["Content-Type"] = "application/json"
             req.body = { input: text.to_s.strip, model: @model }.to_json
@@ -90,11 +93,7 @@ module Llmemory
       end
 
       def connection
-        @connection ||= Faraday.new(url: "https://api.openai.com/v1") do |f|
-          f.request :json
-          f.response :json
-          f.adapter Faraday.default_adapter
-        end
+        @connection ||= build_faraday_connection(@base_url)
       end
 
       def store(id:, embedding:, metadata: {})

data/lib/llmemory/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Llmemory
-  VERSION = "0.2.6"
+  VERSION = "0.2.8"
 end

data/lib/llmemory/working_memory.rb

@@ -36,18 +36,21 @@ module Llmemory
     end
 
     def set(slot, value)
-      state = read
-      state[slot.to_sym] = value
-      persist(state)
+      @store.update(@user_id, @store_key) do |state|
+        state = symbolize(state || {})
+        state[slot.to_sym] = value
+        state
+      end
       value
     end
 
     # Bulk update in a single write.
     def update(**slots)
-      state = read
-      slots.each { |k, v| state[k.to_sym] = v }
-      persist(state)
-      state
+      @store.update(@user_id, @store_key) do |state|
+        state = symbolize(state || {})
+        slots.each { |k, v| state[k.to_sym] = v }
+        state
+      end
     end
 
     # Slots set by the caller beyond the predefined typed ones.

data/lib/tasks/release.rake

@@ -1,22 +1,77 @@
 # frozen_string_literal: true
 
 namespace :release do
-  desc "Bump version (patch|minor|major). Checks: branch=main, no uncommitted changes, tests pass. Then: Gemfile.lock, CHANGELOG, commit, push, tag"
-  task :bump, [:bump_type] => [] do |_t, args|
+  RELEASE_FILES = %w[lib/llmemory/version.rb Gemfile.lock CHANGELOG.txt].freeze
+  DEFAULT_NOTES_PATH = File.expand_path("../../tmp/release_notes.txt", __dir__)
+
+  def self.resolve_notes_path(arg)
+    path = arg.to_s.strip
+    path = DEFAULT_NOTES_PATH if path.empty?
+    File.expand_path(path)
+  end
+
+  def self.build_changelog_entry(version, date, notes_body)
+    body = notes_body.strip
+    body = body.sub(/\A#+\s*[^\n]*\n+/, "") # drop optional leading markdown title
+
+    <<~ENTRY
+
+      ## [#{version}] - #{date}
+
+      #{body}
+    ENTRY
+  end
+
+  desc "Show commits and diff stat since the last tag (helper before writing release notes)"
+  task :since_tag do
+    last_tag = `git describe --tags --abbrev=0 2>/dev/null`.strip
+    range = last_tag.empty? ? "HEAD" : "#{last_tag}..HEAD"
+    puts "Last tag: #{last_tag.empty? ? '(none)' : last_tag}"
+    puts "Range: #{range}\n\n"
+    puts "Commits:"
+    puts(`git log #{range} --oneline`.strip)
+    puts "\nDiff stat:"
+    puts(`git diff #{range} --stat`.strip)
+  end
+
+  desc "Bump version (patch|minor|major). Requires tmp/release_notes.txt or notes path. Checks: branch=main, clean tree, tests pass. Then: version, CHANGELOG, commit, push, tag"
+  task :bump, [:bump_type, :notes_file] => [] do |_t, args|
     require_relative "../llmemory/version"
 
-    # Pre-flight checks
     current_branch = `git rev-parse --abbrev-ref HEAD`.strip
     abort "Current branch must be main (got: #{current_branch})" unless current_branch == "main"
 
-    # Allow only release-related files to be modified (we'll commit them)
-    release_files = %w[lib/llmemory/version.rb Gemfile.lock CHANGELOG.txt]
-    status_lines = `git status --porcelain`.strip.lines
+    status_lines = `git status --porcelain --untracked-files=normal`.strip.lines
     other_changes = status_lines.reject do |line|
-      path = line.sub(/\A..\s+/, "").strip
-      release_files.include?(path)
+      path = line.sub(/\A..\s+/, "").strip.split(" -> ").last
+      RELEASE_FILES.include?(path)
+    end
+    unless other_changes.empty?
+      abort "Working tree has uncommitted changes outside release files. Commit or stash them first.\n#{other_changes.join}"
     end
-    abort "Working tree has uncommitted changes outside release files. Commit or stash them first." unless other_changes.empty?
+
+    notes_path = Release.resolve_notes_path(args[:notes_file])
+    unless File.exist?(notes_path)
+      abort <<~MSG
+        Release notes file not found: #{notes_path}
+
+        1. Inspect changes since the last tag:
+             bundle exec rake release:since_tag
+
+        2. Write a changelog entry (user-visible changes, not raw commits) to:
+             tmp/release_notes.txt
+
+           Use sections such as Added / Changed / Fixed / Removed / Notes.
+           Follow the style of recent entries in CHANGELOG.txt (e.g. v0.2.7).
+
+        3. Re-run:
+             bundle exec rake release:bump[#{args[:bump_type] || 'patch'}]
+             bundle exec rake release:bump[#{args[:bump_type] || 'patch'},path/to/notes.txt]
+      MSG
+    end
+
+    notes_body = File.read(notes_path).strip
+    abort "Release notes file is empty: #{notes_path}" if notes_body.empty?
 
     puts "Running tests..."
     sh "bundle exec rspec"
@@ -36,41 +91,21 @@ namespace :release do
     new_version_s = new_version.to_s
 
     puts "Bumping #{Llmemory::VERSION} -> #{new_version_s} (#{bump_type})"
+    puts "  Release notes: #{notes_path}"
 
-    # 1. Update version.rb
     version_file = File.expand_path("../llmemory/version.rb", __dir__)
     content = File.read(version_file)
     content = content.sub(/VERSION = "[^"]+"/, %(VERSION = "#{new_version_s}"))
     File.write(version_file, content)
     puts "  Updated lib/llmemory/version.rb"
 
-    # 2. bundle install
     sh "bundle install"
     puts "  Updated Gemfile.lock"
 
-    # 3. Update CHANGELOG.txt
     changelog_path = File.expand_path("../../CHANGELOG.txt", __dir__)
-    changelog_content = if File.exist?(changelog_path)
-      File.read(changelog_path)
-    else
-      ""
-    end
-
+    changelog_content = File.exist?(changelog_path) ? File.read(changelog_path) : ""
     today = Time.now.strftime("%Y-%m-%d")
-    last_tag = `git describe --tags --abbrev=0 2>/dev/null`.strip
-    commits = if last_tag.empty?
-      `git log --oneline`.strip
-    else
-      `git log #{last_tag}..HEAD --oneline`.strip
-    end
-
-    new_entry = <<~CHANGELOG
-
-      ## [#{new_version_s}] - #{today}
-
-      ### Changes
-      #{commits.lines.map { |l| "- #{l.strip}" }.join("\n")}
-    CHANGELOG
+    new_entry = Release.build_changelog_entry(new_version_s, today, notes_body)
 
     header = "# Changelog\n\n"
     if changelog_content.empty?
@@ -82,19 +117,13 @@ namespace :release do
     File.write(changelog_path, changelog_content)
     puts "  Updated CHANGELOG.txt"
 
-    # 4. Commit
     sh "git add lib/llmemory/version.rb Gemfile.lock CHANGELOG.txt"
     sh "git commit -m 'Release v#{new_version_s}'"
-
-    # 5. Push
     sh "git push"
-
-    # 6. Tag
     sh "git tag v#{new_version_s}"
-
-    # 7. Push tag
     sh "git push origin v#{new_version_s}"
 
+    File.delete(notes_path) if File.expand_path(notes_path) == File.expand_path(DEFAULT_NOTES_PATH) && File.exist?(notes_path)
     puts "\nDone. Released v#{new_version_s}"
   end
 end