lex-mesh 0.4.6 → 0.4.8

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 5e748e565682b21ecca099dff05a5192840b124d01697a572dcb34e4fd8ddf4b
-  data.tar.gz: 01ba8a7a0c658ef92be7bd39faa85e3d616e9b65ff8a05f8eb476816877a5e03
+  metadata.gz: 1de324c2997f1d71286302c373a002c92bde5a389cfc9baf9bdce04d373f4fc5
+  data.tar.gz: 365de50aed497f545fb7deb881c9c3b87156acf6f8e2a5d443393004868ae278
 SHA512:
-  metadata.gz: 5c13da093e85c3524da32a7415600c8e6f46376fa3b9c1f86fc64115ec9b44f375a304e799edf2bb0fcd19647fa9fadbb5bc669332cfc65d8094a2ed51cf8da2
-  data.tar.gz: f12094b18f644e91eca7fe9ac0cdd8d987ce41d910830d89bb149f9843368c76511f53a7e8aba0110d15918a0d7410053bf552bb0480101ab1227097bbe86011
+  metadata.gz: 506f44f20bec8e35b4b5fc3eb389796e4664511fa0feea50dd962ead40b10cb977a4c0ebc518d4ab20d5cdeaed2b1c2374e3a4ef5a9011121b4cb614b6540ce3
+  data.tar.gz: 188f168003f79c0ed067cc75f98888fa2ecb0dee5244ad79d76eeeb5f5f538ddbd414614be318137806ce69b2d87894b1ec0e479f46ab7d2238700f0286a7989

data/lib/legion/extensions/mesh/actors/gossip.rb

@@ -6,7 +6,7 @@ module Legion
   module Extensions
     module Mesh
       module Actor
-        class Gossip < Legion::Extensions::Actors::Every # rubocop:disable Legion/Extension/EveryActorRequiresTime
+        class Gossip < Legion::Extensions::Actors::Every
           def runner_class
             Legion::Extensions::Mesh::Runners::Mesh
           end

data/lib/legion/extensions/mesh/actors/heartbeat.rb

@@ -6,7 +6,7 @@ module Legion
   module Extensions
     module Mesh
       module Actor
-        class Heartbeat < Legion::Extensions::Actors::Every # rubocop:disable Legion/Extension/EveryActorRequiresTime
+        class Heartbeat < Legion::Extensions::Actors::Every
           def runner_class
             Legion::Extensions::Mesh::Runners::Mesh
           end

data/lib/legion/extensions/mesh/actors/pending_expiry.rb

@@ -6,7 +6,7 @@ module Legion
   module Extensions
     module Mesh
       module Actor
-        class PendingExpiry < Legion::Extensions::Actors::Every # rubocop:disable Legion/Extension/EveryActorRequiresTime
+        class PendingExpiry < Legion::Extensions::Actors::Every
           def runner_class
             Legion::Extensions::Mesh::Runners::Preferences
           end

data/lib/legion/extensions/mesh/actors/silence_watchdog.rb

@@ -6,7 +6,7 @@ module Legion
   module Extensions
     module Mesh
       module Actor
-        class SilenceWatchdog < Legion::Extensions::Actors::Every # rubocop:disable Legion/Extension/EveryActorRequiresTime
+        class SilenceWatchdog < Legion::Extensions::Actors::Every
           def runner_class
             Legion::Extensions::Mesh::Runners::Mesh
           end

data/lib/legion/extensions/mesh/helpers/preference_profile.rb

@@ -90,7 +90,7 @@ module Legion
             confidence = SOURCE_CONFIDENCE.fetch(source.to_s, 0.5)
             memory_runner.store_trace(
               type:            :semantic,
-              content_payload: { domain: domain, value: value, source: source }.to_s,
+              content_payload: pref_json_dump({ domain: domain, value: value, source: source }),
               domain_tags:     ['preference', "preference:#{domain}", "owner:#{owner_id}"],
               origin:          :direct_experience,
               confidence:      confidence
@@ -103,7 +103,34 @@ module Legion
           def clear_preferences(owner_id:, source: nil)
             return { cleared: false, reason: :memory_not_available } unless memory_available?
 
-            { cleared: true, owner_id: owner_id, source: source }
+            runner = memory_runner
+            result = runner.retrieve_by_domain(domain_tag: "owner:#{owner_id}")
+            traces = result[:traces] || []
+            traces.each { |t| runner.delete_trace(trace_id: t[:trace_id]) }
+            { cleared: true, owner_id: owner_id, source: source, count: traces.size }
+          rescue StandardError => e
+            { cleared: false, reason: :error, message: e.message }
+          end
+
+          def erase_partner!(identity:)
+            key = identity.to_s
+            @observation_counts&.delete(key)    # rubocop:disable ThreadSafety/ClassInstanceVariable
+            @observation_signals&.delete(key)   # rubocop:disable ThreadSafety/ClassInstanceVariable
+            @inferred_preferences&.delete(key)  # rubocop:disable ThreadSafety/ClassInstanceVariable
+            clear_mesh_cache(agent_id: key)
+
+            traces_deleted = 0
+            if memory_available?
+              runner = memory_runner
+              result = runner.retrieve_by_domain(domain_tag: "owner:#{key}")
+              traces = result[:traces] || []
+              traces.each { |t| runner.delete_trace(trace_id: t[:trace_id]) }
+              traces_deleted = traces.size
+            end
+
+            { erased: true, identity: key, traces_deleted: traces_deleted }
+          rescue StandardError => e
+            { erased: false, identity: key, reason: :error, message: e.message }
           end
 
           def preference_instructions(profile:)
@@ -224,14 +251,31 @@ module Legion
             payload = trace[:content_payload]
             return nil unless payload.is_a?(String)
 
-            match = payload.match(/domain.*?(\w+).*?value.*?(\w+).*?source.*?(\w+)/)
-            return nil unless match
+            parsed = parse_preference_payload_json(payload)
+            parsed ||= parse_preference_payload_legacy(payload)
+            return nil unless parsed
+
+            { domain: parsed[:domain], value: parsed[:value], source: parsed[:source], confidence: trace[:confidence] }
+          rescue StandardError => _e
+            nil
+          end
+
+          def parse_preference_payload_json(payload)
+            data = pref_json_load(payload)
+            return nil unless data.is_a?(Hash) && data[:domain] && data[:value] && data[:source]
 
-            { domain: match[1], value: match[2], source: match[3], confidence: trace[:confidence] }
+            data
           rescue StandardError => _e
             nil
           end
 
+          def parse_preference_payload_legacy(payload)
+            match = payload.match(/domain.*?(\w+).*?value.*?(\w+).*?source.*?(\w+)/)
+            return nil unless match
+
+            { domain: match[1], value: match[2], source: match[3] }
+          end
+
           def compute_compatibility(profile)
             return nil unless profile.is_a?(Hash) && profile[:personality]
             return nil unless personality_available?
@@ -326,7 +370,15 @@ module Legion
             unique_channels = signals.map { |s| s[:channel] }.uniq
             return nil unless unique_channels.size >= 3
 
-            { domain: 'format', value: 'adaptive', source: 'observation', confidence: 0.55 }
+            { domain: 'format', value: 'structured', source: 'observation', confidence: 0.55 }
+          end
+
+          def pref_json_dump(data)
+            Legion::JSON.dump(data) # rubocop:disable Legion/HelperMigration/DirectJson
+          end
+
+          def pref_json_load(payload)
+            Legion::JSON.load(payload) # rubocop:disable Legion/HelperMigration/DirectJson
           end
         end
       end

data/lib/legion/extensions/mesh/version.rb

@@ -3,7 +3,7 @@
 module Legion
   module Extensions
     module Mesh
-      VERSION = '0.4.6'
+      VERSION = '0.4.8'
     end
   end
 end

data/spec/legion/extensions/mesh/helpers/preference_profile_spec.rb

@@ -12,12 +12,16 @@ unless defined?(Legion::Extensions::Agentic::Memory::Trace::Runners::Traces)
             module Runners
               module Traces
                 def retrieve_by_domain(**)
-                  []
+                  { count: 0, traces: [] }
                 end
 
                 def store_trace(**)
                   { stored: true }
                 end
+
+                def delete_trace(trace_id:, **)
+                  { deleted: true, trace_id: trace_id }
+                end
               end
             end
           end
@@ -100,6 +104,24 @@ RSpec.describe Legion::Extensions::Mesh::Helpers::PreferenceProfile do
       expect(result[:stored]).to be false
       expect(result[:reason]).to eq(:memory_not_available)
     end
+
+    it 'serializes payload as JSON string' do
+      captured_payload = nil
+      runner_double = double('memory_runner')
+      allow(profile_mod).to receive(:memory_available?).and_return(true)
+      allow(profile_mod).to receive(:memory_runner).and_return(runner_double)
+      allow(runner_double).to receive(:store_trace) do |**args|
+        captured_payload = args[:content_payload]
+        { stored: true }
+      end
+
+      profile_mod.store_preference(owner_id: 'u1', domain: 'verbosity', value: 'concise', source: 'explicit')
+
+      parsed = Legion::JSON.load(captured_payload)
+      expect(parsed[:domain]).to eq('verbosity')
+      expect(parsed[:value]).to eq('concise')
+      expect(parsed[:source]).to eq('explicit')
+    end
   end
 
   describe '.clear_preferences' do
@@ -107,6 +129,122 @@ RSpec.describe Legion::Extensions::Mesh::Helpers::PreferenceProfile do
       result = profile_mod.clear_preferences(owner_id: 'user1', source: 'explicit')
       expect(result[:cleared]).to be true
     end
+
+    it 'actually deletes traces via memory runner when memory is available' do
+      trace = { trace_id: 'abc-123', domain_tags: ['preference', 'owner:user1'], confidence: 0.9 }
+      runner_double = double('memory_runner')
+      allow(profile_mod).to receive(:memory_available?).and_return(true)
+      allow(profile_mod).to receive(:memory_runner).and_return(runner_double)
+      allow(runner_double).to receive(:retrieve_by_domain).and_return({ traces: [trace] })
+      allow(runner_double).to receive(:delete_trace).and_return({ deleted: true })
+
+      result = profile_mod.clear_preferences(owner_id: 'user1')
+
+      expect(runner_double).to have_received(:retrieve_by_domain).with(hash_including(domain_tag: 'owner:user1'))
+      expect(runner_double).to have_received(:delete_trace).with(hash_including(trace_id: 'abc-123'))
+      expect(result[:cleared]).to be true
+      expect(result[:count]).to eq(1)
+    end
+
+    it 'returns not_available when memory is unavailable' do
+      allow(profile_mod).to receive(:memory_available?).and_return(false)
+      result = profile_mod.clear_preferences(owner_id: 'user1')
+      expect(result[:cleared]).to be false
+      expect(result[:reason]).to eq(:memory_not_available)
+    end
+  end
+
+  describe '.parse_preference_trace' do
+    it 'parses JSON-encoded payload and returns symbol-keyed hash' do
+      payload = Legion::JSON.dump({ domain: 'verbosity', value: 'concise', source: 'explicit' })
+      trace = { content_payload: payload, confidence: 0.9 }
+      result = profile_mod.parse_preference_trace(trace)
+      expect(result[:domain]).to eq('verbosity')
+      expect(result[:value]).to eq('concise')
+      expect(result[:source]).to eq('explicit')
+      expect(result[:confidence]).to eq(0.9)
+    end
+
+    it 'falls back to legacy regex for old .to_s hash format' do
+      legacy_payload = '{:domain=>"verbosity", :value=>"concise", :source=>"explicit"}'
+      trace = { content_payload: legacy_payload, confidence: 0.7 }
+      result = profile_mod.parse_preference_trace(trace)
+      expect(result[:domain]).to eq('verbosity')
+      expect(result[:value]).to eq('concise')
+      expect(result[:source]).to eq('explicit')
+      expect(result[:confidence]).to eq(0.7)
+    end
+
+    it 'returns nil for a non-string payload' do
+      trace = { content_payload: nil, confidence: 0.5 }
+      expect(profile_mod.parse_preference_trace(trace)).to be_nil
+    end
+
+    it 'returns nil for a payload that cannot be parsed by either method' do
+      trace = { content_payload: 'garbage data without structure', confidence: 0.5 }
+      expect(profile_mod.parse_preference_trace(trace)).to be_nil
+    end
+  end
+
+  describe '.erase_partner!' do
+    before do
+      described_class.clear_observations
+      described_class.clear_mesh_cache
+    end
+
+    it 'removes observation counts for the identity' do
+      5.times { described_class.update_from_observation(owner_id: 'partner-x', signals: { channel: :cli, direct_address: false }) }
+      described_class.erase_partner!(identity: 'partner-x')
+      expect(described_class.observation_counts['partner-x']).to be_nil
+    end
+
+    it 'removes inferred preferences for the identity' do
+      20.times { described_class.update_from_observation(owner_id: 'partner-x', signals: { channel: :cli, direct_address: false }) }
+      described_class.erase_partner!(identity: 'partner-x')
+      expect(described_class.inferred_preferences('partner-x')).to be_empty
+    end
+
+    it 'removes mesh cache entries for the identity' do
+      described_class.store_mesh_profile(
+        agent_id:        'partner-x',
+        profile:         { verbosity: :concise },
+        source_agent_id: 'partner-x'
+      )
+      described_class.erase_partner!(identity: 'partner-x')
+      expect(described_class.cached_mesh_profile(agent_id: 'partner-x')).to be_nil
+    end
+
+    it 'deletes memory traces tagged with the identity' do
+      trace = { trace_id: 'xyz-789', domain_tags: ['preference', 'owner:partner-x'], confidence: 0.8 }
+      runner_double = double('memory_runner')
+      allow(described_class).to receive(:memory_available?).and_return(true)
+      allow(described_class).to receive(:memory_runner).and_return(runner_double)
+      allow(runner_double).to receive(:retrieve_by_domain).and_return({ traces: [trace] })
+      allow(runner_double).to receive(:delete_trace).and_return({ deleted: true })
+
+      described_class.erase_partner!(identity: 'partner-x')
+
+      expect(runner_double).to have_received(:delete_trace).with(hash_including(trace_id: 'xyz-789'))
+    end
+
+    it 'leaves data for other identities untouched' do
+      3.times { described_class.update_from_observation(owner_id: 'partner-y', signals: { channel: :cli, direct_address: false }) }
+      described_class.store_mesh_profile(
+        agent_id:        'partner-y',
+        profile:         { verbosity: :detailed },
+        source_agent_id: 'partner-y'
+      )
+      described_class.erase_partner!(identity: 'partner-x')
+      expect(described_class.observation_counts['partner-y']).to eq(3)
+      expect(described_class.cached_mesh_profile(agent_id: 'partner-y')).not_to be_nil
+    end
+
+    it 'returns a result hash with erased identity and counts' do
+      result = described_class.erase_partner!(identity: 'partner-x')
+      expect(result).to be_a(Hash)
+      expect(result[:erased]).to be true
+      expect(result[:identity]).to eq('partner-x')
+    end
   end
 
   describe '.store_mesh_profile' do
@@ -233,7 +371,7 @@ RSpec.describe Legion::Extensions::Mesh::Helpers::PreferenceProfile do
       expect(tone[:source]).to eq('observation')
     end
 
-    it 'derives :adaptive format for mixed channel usage after threshold' do
+    it 'derives :structured format for mixed channel usage after threshold' do
       channels = %i[cli api chat rest]
       20.times.with_index do |i, _|
         ch = channels[i % channels.length]
@@ -245,10 +383,27 @@ RSpec.describe Legion::Extensions::Mesh::Helpers::PreferenceProfile do
       inferred = described_class.inferred_preferences('user-mix')
       format = inferred.find { |p| p[:domain] == 'format' }
       expect(format).not_to be_nil
-      expect(format[:value]).to eq('adaptive')
+      expect(format[:value]).to eq('structured')
       expect(format[:source]).to eq('observation')
     end
 
+    it 'derive_format never returns a value outside VALID_VALUES[:format]' do
+      channels = %i[cli api chat rest grpc websocket]
+      20.times.with_index do |i, _|
+        ch = channels[i % channels.length]
+        described_class.update_from_observation(
+          owner_id: 'user-valid',
+          signals:  { content_type: :text, channel: ch, direct_address: false }
+        )
+      end
+      inferred = described_class.inferred_preferences('user-valid')
+      format_pref = inferred.find { |p| p[:domain] == 'format' }
+      if format_pref
+        valid_format_values = described_class::VALID_VALUES['format'].map(&:to_s)
+        expect(valid_format_values).to include(format_pref[:value])
+      end
+    end
+
     it 'keeps separate observation counts per owner_id' do
       3.times { described_class.update_from_observation(owner_id: 'user-a', signals: cli_signal) }
       7.times { described_class.update_from_observation(owner_id: 'user-b', signals: cli_signal) }

data/spec/legion/extensions/mesh/runners/preferences_spec.rb

@@ -31,7 +31,7 @@ RSpec.describe Legion::Extensions::Mesh::Runners::Preferences do
         end)
         stub_const('Legion::Extensions::Mesh::Transport::Messages::PreferenceQuery',
                    Class.new do
-                     def initialize(**_opts); end
+                     def initialize(**opts); end
 
                      def publish; end
                    end)

data/spec/spec_helper.rb

@@ -35,8 +35,8 @@ module Legion
   end
 end
 
-Legion::Settings.loader.settings[:client] ||= {}
-Legion::Settings.loader.settings[:client][:name] = 'test-agent'
+Legion::Settings[:client] ||= {}
+Legion::Settings[:client][:name] = 'test-agent'
 
 require 'legion/extensions/mesh'
 

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: lex-mesh
 version: !ruby/object:Gem::Version
-  version: 0.4.6
+  version: 0.4.8
 platform: ruby
 authors:
 - Esity