lex-agentic-memory 0.1.32 → 0.1.33

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 07b491ea4b919f623905cf3fe0c651c6a462e46bfe096e06e4221e9eb9e6b801
-  data.tar.gz: b92fc5808525806e2dca50c86ea4382583adcbe5b6b9e84d0dd8e1c4add0f14b
+  metadata.gz: 01630a8c5fd981fb85c69337d299f71dc215b79b9ce3dca7a9b0aef57545fde3
+  data.tar.gz: 6eb6bd8f8e924aacb9a805561f9f39c0ac18b5d1f559faa7f58a1af3a6d3ad8a
 SHA512:
-  metadata.gz: ed8eb6cff096080b1435aab249896d4c473d1aab7b11ebec1f687081aa9494bc8671c029d3d7e2e80b4144b705b477e6d58fc796c412d2a6bf75a852fa02f27e
-  data.tar.gz: 834d02319dbf0c63722d8bc8e59e5f63d6c18c42c740a71a47ac5f1c6df0c1ad9b983e73b246f751bd24a784aa4e43c5d5f508ed516dbd7f94321fea220f2cf3
+  metadata.gz: 69c12558b2cb6d7a883a9f0bd345ad0934273847b1a44f2dcaed02682a347d9a88dfddbbf6b2ab48d91a418c83f137eb585723dc3aecf19c0a2fb2e1454e7bd3
+  data.tar.gz: 8200e4e37b770d4afa344153cd6dc95b9bd047dd55d34079b1bfc6c87c7f261e0049ee2c6f77e4f2b04bf7455745f88eb06160ad006eb81dda7ee0d2053093f9

data/CHANGELOG.md

@@ -1,5 +1,11 @@
 # 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.

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

@@ -358,6 +358,8 @@ module Legion
               end
 
               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

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

@@ -4,7 +4,7 @@ module Legion
   module Extensions
     module Agentic
       module Memory
-        VERSION = '0.1.32'
+        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 }
@@ -235,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)

metadata

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