lex-agentic-memory 0.1.31 → 0.1.33

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: d9ec98fbb5ad987564ae50bc87572aa2d23eb3c0011dfa2c5c2a000926286eed
-  data.tar.gz: 318bae8b3abd84f2ec9e1b8101a0aed4e4f8656822356d1a9ef65557984234e9
+  metadata.gz: 01630a8c5fd981fb85c69337d299f71dc215b79b9ce3dca7a9b0aef57545fde3
+  data.tar.gz: 6eb6bd8f8e924aacb9a805561f9f39c0ac18b5d1f559faa7f58a1af3a6d3ad8a
 SHA512:
-  metadata.gz: be83bf5dd3d3d283f00ab26f16f2159f01d12bb0e2f561d956ff6039902baacb5cbce96d61fb2becfd34b83f282daa0f63b7581770d204728629d088dda6cfcf
-  data.tar.gz: 36af01ed5dc06602f8233667623f53f067f11a19ef01b350f1bd8d6aaf08af4ff44dbde0987a10add8b015dd14115a74005a04e237b527e83076979a42743bb5
+  metadata.gz: 69c12558b2cb6d7a883a9f0bd345ad0934273847b1a44f2dcaed02682a347d9a88dfddbbf6b2ab48d91a418c83f137eb585723dc3aecf19c0a2fb2e1454e7bd3
+  data.tar.gz: 8200e4e37b770d4afa344153cd6dc95b9bd047dd55d34079b1bfc6c87c7f261e0049ee2c6f77e4f2b04bf7455745f88eb06160ad006eb81dda7ee0d2053093f9

data/CHANGELOG.md

@@ -1,5 +1,16 @@
 # Changelog
 
+## [0.1.33] - 2026-05-07
+### Fixed
+- `PostgresStore#parse_json_or_raw` no longer attempts JSON parse on plain-text content — checks for `{`/`[` prefix before parsing, eliminating ERROR log spam during bulk reads with mixed content types
+- `PostgresStore#parse_json_array` now guards against nil/empty strings before parsing
+- `Store#parse_db_json` now short-circuits on nil/empty columns (domain_tags, associations, child_ids, emotional_valence) before attempting parse, fixing ERROR spam on traces with sparse optional fields
+
+## [0.1.32] - 2026-05-07
+### Fixed
+- Trace association retrieval now snapshots associated traces under the store mutex before filtering.
+- Local trace restore preserves symbol keys for JSON fields that are consumed as symbol-keyed hashes.
+
 ## [0.1.31] - 2026-04-27
 ### Added
 - Add a heuristic pre-compaction memory save path and synchronous pre-compaction event listeners for `chat.pre_compact`, `context.pre_compact`, and `conversation.pre_compact`.

data/lib/legion/extensions/agentic/memory/trace/helpers/postgres_store.rb

@@ -394,15 +394,18 @@ module Legion
               def parse_json_or_raw(raw)
                 return raw unless raw.is_a?(String)
 
-                parsed = Legion::JSON.load(raw)
-                parsed.is_a?(Hash) ? parsed : raw
+                stripped = raw.strip
+                return raw unless stripped.start_with?('{', '[')
+
+                parsed = Legion::JSON.load(stripped)
+                parsed.is_a?(Hash) || parsed.is_a?(Array) ? parsed : raw
               rescue StandardError => e
                 log.error "[trace_persistence] parse_json_or_raw: #{e.message}"
                 raw
               end
 
               def parse_json_array(raw)
-                return [] unless raw.is_a?(String)
+                return [] if raw.nil? || !raw.is_a?(String) || raw.strip.empty?
 
                 result = Legion::JSON.load(raw)
                 result.is_a?(Array) ? result : []

data/lib/legion/extensions/agentic/memory/trace/helpers/store.rb

@@ -70,11 +70,14 @@ module Legion
               end
 
               def retrieve_associated(trace_id, min_strength: 0.0, limit: 20)
-                trace = @traces[trace_id]
-                return [] unless trace
+                associated = @mutex.synchronize do
+                  trace = @traces[trace_id]
+                  next [] unless trace
 
-                trace[:associated_traces]
-                  .filter_map { |id| @traces[id] }
+                  trace[:associated_traces].filter_map { |id| @traces[id]&.dup }
+                end
+
+                associated
                   .select { |t| t[:strength] >= min_strength }
                   .sort_by { |t| -t[:strength] }
                   .first(limit)
@@ -354,13 +357,29 @@ module Legion
                 raw
               end
 
-              def parse_db_json(raw, field, **_opts, &default)
-                Legion::JSON.load(raw.to_s)
+              def parse_db_json(raw, field, symbolize: false, &default)
+                return default&.call if raw.nil? || raw.to_s.strip.empty?
+
+                parsed = Legion::JSON.load(raw.to_s)
+                symbolize ? symbolize_keys(parsed) : parsed
               rescue StandardError => e
                 log.error "[trace_persistence] deserialize_trace_from_db #{field}: #{e.message}"
                 default&.call
               end
 
+              def symbolize_keys(value)
+                case value
+                when Hash
+                  value.each_with_object({}) do |(key, nested), memo|
+                    memo[key.to_sym] = symbolize_keys(nested)
+                  end
+                when Array
+                  value.map { |nested| symbolize_keys(nested) }
+                else
+                  value
+                end
+              end
+
               def link_traces(id_a, id_b)
                 trace_a = @traces[id_a]
                 trace_b = @traces[id_b]

data/lib/legion/extensions/agentic/memory/version.rb

@@ -4,7 +4,7 @@ module Legion
   module Extensions
     module Agentic
       module Memory
-        VERSION = '0.1.31'
+        VERSION = '0.1.33'
       end
     end
   end

data/spec/legion/extensions/agentic/memory/trace/helpers/postgres_store_spec.rb

@@ -556,4 +556,61 @@ RSpec.describe Legion::Extensions::Agentic::Memory::Trace::Helpers::PostgresStor
       expect(store.flush).to be_nil
     end
   end
+
+  # --- plain-text content round-trip (log spam regression) ---
+
+  describe 'plain-text content deserialization' do
+    it 'returns plain-text content as-is without logging errors' do
+      trace = trace_helper.new_trace(type: :episodic, content_payload: 'It appears the service is down.')
+      store.store(trace)
+
+      expect(store).not_to receive(:log)
+      result = store.retrieve(trace[:trace_id])
+      expect(result[:content]).to eq('It appears the service is down.')
+    end
+
+    it 'parses JSON object content into a hash' do
+      trace = trace_helper.new_trace(type: :semantic, content_payload: { fact: 'ruby' })
+      store.store(trace)
+
+      result = store.retrieve(trace[:trace_id])
+      expect(result[:content]).to be_a(Hash)
+    end
+
+    it 'does not log errors when domain_tags column is nil' do
+      trace = trace_helper.new_trace(type: :episodic, content_payload: 'hello')
+      store.store(trace)
+
+      db[:memory_traces].where(trace_id: trace[:trace_id]).update(domain_tags: nil)
+
+      expect(store).not_to receive(:log)
+      result = store.retrieve(trace[:trace_id])
+      expect(result[:domain_tags]).to eq([])
+    end
+
+    it 'does not log errors when associations column is nil' do
+      trace = trace_helper.new_trace(type: :episodic, content_payload: 'hello')
+      store.store(trace)
+
+      db[:memory_traces].where(trace_id: trace[:trace_id]).update(associations: nil)
+
+      expect(store).not_to receive(:log)
+      result = store.retrieve(trace[:trace_id])
+      expect(result[:associated_traces]).to eq([])
+    end
+
+    it 'generates no ERROR log lines during a bulk read with mixed content types' do
+      plain_trace = trace_helper.new_trace(type: :episodic, content_payload: 'Hello, I am plain text')
+      json_trace  = trace_helper.new_trace(type: :semantic, content_payload: { fact: 'structured' })
+      store.store(plain_trace)
+      store.store(json_trace)
+
+      log_double = double('log', debug: nil, info: nil, warn: nil)
+      allow(store).to receive(:log).and_return(log_double)
+      expect(log_double).not_to receive(:error)
+
+      results = store.all_traces
+      expect(results.size).to eq(2)
+    end
+  end
 end

data/spec/legion/extensions/agentic/memory/trace/helpers/store_spec.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require 'sequel'
+
 RSpec.describe Legion::Extensions::Agentic::Memory::Trace::Helpers::Store do
   let(:store) { described_class.new }
   let(:trace_helper) { Legion::Extensions::Agentic::Memory::Trace::Helpers::Trace }
@@ -95,6 +97,18 @@ RSpec.describe Legion::Extensions::Agentic::Memory::Trace::Helpers::Store do
       associated = store.retrieve_associated(semantic_trace[:trace_id])
       expect(associated.size).to eq(0)
     end
+
+    it 'snapshots associated traces while holding the store mutex' do
+      store.store(semantic_trace)
+      store.store(episodic_trace)
+      semantic_trace[:associated_traces] << episodic_trace[:trace_id]
+
+      mutex = store.instance_variable_get(:@mutex)
+      expect(mutex).to receive(:synchronize).and_call_original
+
+      associated = store.retrieve_associated(semantic_trace[:trace_id])
+      expect(associated.map { |trace| trace[:trace_id] }).to eq([episodic_trace[:trace_id]])
+    end
   end
 
   describe '#all_traces' do
@@ -223,6 +237,78 @@ RSpec.describe Legion::Extensions::Agentic::Memory::Trace::Helpers::Store do
     end
   end
 
+  describe 'parse_db_json nil/empty guard (log spam regression)' do
+    let(:local_db) do
+      d = Sequel.sqlite
+      d.create_table(:memory_traces) do
+        primary_key :id
+        String   :trace_id, size: 36, null: false, unique: true
+        String   :trace_type, null: false, default: 'episodic'
+        String   :content, text: true, null: false, default: ''
+        Float    :strength, default: 1.0
+        Float    :peak_strength, default: 1.0
+        Float    :base_decay_rate, default: 0.02
+        Float    :emotional_valence
+        Float    :emotional_intensity, default: 0.0
+        String   :domain_tags, text: true
+        String   :origin
+        String   :storage_tier, default: 'hot'
+        DateTime :created_at
+        DateTime :last_reinforced
+        DateTime :last_decayed
+        Integer  :reinforcement_count, default: 0
+        Float    :confidence, default: 0.5
+        String   :partition_id
+        String   :associated_traces, text: true
+        String   :parent_id
+        String   :child_ids, text: true
+        TrueClass :unresolved, default: false
+        TrueClass :consolidation_candidate, default: false
+      end
+      d.create_table(:memory_associations) do
+        primary_key :id
+        String :trace_id_a, size: 36, null: false
+        String :trace_id_b, size: 36, null: false
+        Integer :coactivation_count, default: 1, null: false
+        String :partition_id
+        unique %i[trace_id_a trace_id_b]
+      end
+      d
+    end
+
+    let(:data_local_stub) do
+      conn = local_db
+      Module.new do
+        define_singleton_method(:connected?) { true }
+        define_singleton_method(:connection) { conn }
+        define_singleton_method(:table_exists?) { |name| conn.table_exists?(name) }
+      end
+    end
+
+    before { stub_const('Legion::Data::Local', data_local_stub) }
+
+    it 'does not log errors when nil optional columns are deserialized on load' do
+      local_db[:memory_traces].insert(
+        trace_id:          SecureRandom.uuid,
+        trace_type:        'episodic',
+        content:           'plain text content',
+        partition_id:      'default',
+        strength:          1.0,
+        domain_tags:       nil,
+        associated_traces: nil,
+        child_ids:         nil,
+        emotional_valence: nil
+      )
+
+      fresh = described_class.new
+      expect(fresh.count).to eq(1)
+      trace = fresh.traces.values.first
+      expect(trace[:domain_tags]).to eq([])
+      expect(trace[:associated_traces]).to eq([])
+      expect(trace[:child_trace_ids]).to eq([])
+    end
+  end
+
   describe '#restore_traces' do
     it 'replaces existing traces and clears stale associations' do
       store.store(semantic_trace)

data/spec/legion/extensions/agentic/memory/trace/local_persistence_spec.rb

@@ -249,6 +249,23 @@ RSpec.describe 'lex-memory local SQLite persistence' do
       expect(fresh.get(episodic_trace[:trace_id])).not_to be_nil
     end
 
+    it 'honors symbolize parsing for JSON hash fields' do
+      trace = trace_helper.new_trace(
+        type:              :semantic,
+        content_payload:   { fact: 'symbolized' },
+        domain_tags:       ['json'],
+        emotional_valence: { joy: 0.8 }
+      )
+      store.store(trace)
+      store.save_to_local
+
+      fresh = Legion::Extensions::Agentic::Memory::Trace::Helpers::Store.new
+      restored = fresh.get(trace[:trace_id])
+
+      expect(restored[:emotional_valence]).to include(joy: 0.8)
+      expect(restored[:emotional_valence]).not_to have_key('joy')
+    end
+
     it 'restores associations from the database into a fresh store' do
       store.store(semantic_trace)
       store.store(episodic_trace)

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: lex-agentic-memory
 version: !ruby/object:Gem::Version
-  version: 0.1.31
+  version: 0.1.33
 platform: ruby
 authors:
 - Esity