lex-mesh 0.4.3 → 0.4.5

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: b16d673e30a813f0fa38f61386eae0e9a72a35cc2b0eedc6b45ced88a4acadf7
-  data.tar.gz: dc7a12c1de2412117ac9ce56c7803626dba16604f9cbfba57ca41e72e55dc3b5
+  metadata.gz: 0bd1055e60b5e6c6d2e63c08f7aab32c7f03b294b8251da6b583516060e3fdec
+  data.tar.gz: aaee0b1ecd57d2e8673706de83ac842476b5aba0570a38ab57bce3ca6c17cee7
 SHA512:
-  metadata.gz: 7abe441618ba1fca371412adf3a2a48f16f54adc4130d060369e1fcdc7222a777fcc48e165576e74e4cf1892fdd9a42f4562242523bf2d9e8239cdb8af771b4c
-  data.tar.gz: 61e2b0e8aba072966d10e820db3708ff2c76ecfcda9fc73e99bcd61eff051323c81ea5c1cef0e1c56ce126604369983205f32e732376eab53ad1fae4af1857f5
+  metadata.gz: 7e350395459a7499684bdc844fbd81b4a628f58e2656c2d68031e4ac3688ad954be2486e83023dbe54d2da0eca88e748133b187d6c9d6a9efc431564a0d9e4c5
+  data.tar.gz: 1de8d318e631a5e31c2babb44a01424a0371332c05678dce832a55ac1e895963a6a571a3e7a78cf5b65d951c3f81f5b1ddd63fbf801edb078d46d13df5de6552

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

@@ -22,6 +22,8 @@ module Legion
           SOURCE_CONFIDENCE = {
             'explicit'            => 1.0,
             'preference_learning' => 0.75,
+            'llm_inference'       => 0.65,
+            'observation'         => 0.55,
             'personality'         => 0.4,
             'defaults'            => 0.0
           }.freeze
@@ -246,6 +248,86 @@ module Legion
           def personality_available?
             defined?(Legion::Extensions::Agentic::Self::Personality::Runners::Personality)
           end
+
+          OBSERVATION_THRESHOLD = 20
+
+          def update_from_observation(owner_id:, signals:)
+            @observation_counts  ||= {} # rubocop:disable ThreadSafety/ClassInstanceVariable
+            @observation_signals ||= {} # rubocop:disable ThreadSafety/ClassInstanceVariable
+
+            key = owner_id.to_s
+            @observation_counts[key] = (@observation_counts[key] || 0) + 1 # rubocop:disable ThreadSafety/ClassInstanceVariable
+            @observation_signals[key] ||= [] # rubocop:disable ThreadSafety/ClassInstanceVariable
+            @observation_signals[key] << signals # rubocop:disable ThreadSafety/ClassInstanceVariable
+
+            derive_and_store_observations(owner_id: key) if @observation_counts[key] >= OBSERVATION_THRESHOLD # rubocop:disable ThreadSafety/ClassInstanceVariable
+
+            { updated: true }
+          rescue StandardError => _e
+            { updated: false }
+          end
+
+          def observation_counts
+            @observation_counts ||= {} # rubocop:disable ThreadSafety/ClassInstanceVariable
+          end
+
+          def inferred_preferences(owner_id)
+            @inferred_preferences ||= {} # rubocop:disable ThreadSafety/ClassInstanceVariable
+            @inferred_preferences[owner_id.to_s] || [] # rubocop:disable ThreadSafety/ClassInstanceVariable
+          end
+
+          def clear_observations
+            @observation_counts    = {} # rubocop:disable ThreadSafety/ClassInstanceVariable
+            @observation_signals   = {} # rubocop:disable ThreadSafety/ClassInstanceVariable
+            @inferred_preferences  = {} # rubocop:disable ThreadSafety/ClassInstanceVariable
+          end
+
+          def derive_and_store_observations(owner_id:)
+            @observation_signals ||= {} # rubocop:disable ThreadSafety/ClassInstanceVariable
+            signals = @observation_signals[owner_id] || [] # rubocop:disable ThreadSafety/ClassInstanceVariable
+            return if signals.empty?
+
+            inferred = []
+            inferred << derive_verbosity(signals)
+            inferred << derive_tone(signals)
+            inferred << derive_format(signals)
+            inferred = inferred.compact
+
+            @inferred_preferences ||= {} # rubocop:disable ThreadSafety/ClassInstanceVariable
+            @inferred_preferences[owner_id] = inferred # rubocop:disable ThreadSafety/ClassInstanceVariable
+
+            inferred.each do |pref|
+              store_preference(
+                owner_id: owner_id,
+                domain:   pref[:domain],
+                value:    pref[:value],
+                source:   pref[:source]
+              )
+            end
+          end
+
+          def derive_verbosity(signals)
+            cli_count = signals.count { |s| s[:channel] == :cli }
+            cli_ratio = cli_count.to_f / signals.size
+            return nil unless cli_ratio >= 0.5
+
+            { domain: 'verbosity', value: 'concise', source: 'observation', confidence: 0.65 }
+          end
+
+          def derive_tone(signals)
+            da_count = signals.count { |s| s[:direct_address] }
+            da_ratio = da_count.to_f / signals.size
+            return nil unless da_ratio >= 0.5
+
+            { domain: 'tone', value: 'conversational', source: 'observation', confidence: 0.65 }
+          end
+
+          def derive_format(signals)
+            unique_channels = signals.map { |s| s[:channel] }.uniq
+            return nil unless unique_channels.size >= 3
+
+            { domain: 'format', value: 'adaptive', source: 'observation', confidence: 0.55 }
+          end
         end
       end
     end

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

@@ -3,7 +3,7 @@
 module Legion
   module Extensions
     module Mesh
-      VERSION = '0.4.3'
+      VERSION = '0.4.5'
     end
   end
 end

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

@@ -191,6 +191,81 @@ RSpec.describe Legion::Extensions::Mesh::Helpers::PreferenceProfile do
     end
   end
 
+  describe '.update_from_observation' do
+    before { described_class.clear_observations }
+
+    let(:cli_signal)   { { content_type: :text, channel: :cli, direct_address: false } }
+    let(:chat_signal)  { { content_type: :text, channel: :chat, direct_address: true } }
+    let(:mixed_signal) { { content_type: :text, channel: :api, direct_address: false } }
+
+    it 'returns { updated: true } on each call' do
+      result = described_class.update_from_observation(owner_id: 'user-obs', signals: cli_signal)
+      expect(result).to eq({ updated: true })
+    end
+
+    it 'accumulates signals per owner_id' do
+      5.times { described_class.update_from_observation(owner_id: 'user-obs', signals: cli_signal) }
+      counts = described_class.observation_counts
+      expect(counts['user-obs']).to eq(5)
+    end
+
+    it 'does not infer preferences before threshold (20)' do
+      19.times { described_class.update_from_observation(owner_id: 'user-obs', signals: cli_signal) }
+      inferred = described_class.inferred_preferences('user-obs')
+      expect(inferred).to be_empty
+    end
+
+    it 'derives :concise verbosity for CLI-heavy usage after threshold' do
+      20.times { described_class.update_from_observation(owner_id: 'user-cli', signals: cli_signal) }
+      inferred = described_class.inferred_preferences('user-cli')
+      verbosity = inferred.find { |p| p[:domain] == 'verbosity' }
+      expect(verbosity).not_to be_nil
+      expect(verbosity[:value]).to eq('concise')
+      expect(verbosity[:source]).to eq('observation')
+    end
+
+    it 'derives :conversational tone for high direct_address ratio after threshold' do
+      20.times { described_class.update_from_observation(owner_id: 'user-da', signals: chat_signal) }
+      inferred = described_class.inferred_preferences('user-da')
+      tone = inferred.find { |p| p[:domain] == 'tone' }
+      expect(tone).not_to be_nil
+      expect(tone[:value]).to eq('conversational')
+      expect(tone[:source]).to eq('observation')
+    end
+
+    it 'derives :adaptive 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]
+        described_class.update_from_observation(
+          owner_id: 'user-mix',
+          signals:  { content_type: :text, channel: ch, direct_address: false }
+        )
+      end
+      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[:source]).to eq('observation')
+    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) }
+      counts = described_class.observation_counts
+      expect(counts['user-a']).to eq(3)
+      expect(counts['user-b']).to eq(7)
+    end
+
+    it 'calls store_preference for each inferred preference after threshold' do
+      allow(described_class).to receive(:store_preference).and_call_original
+      20.times { described_class.update_from_observation(owner_id: 'user-store', signals: cli_signal) }
+      expect(described_class).to have_received(:store_preference).with(
+        hash_including(owner_id: 'user-store', source: 'observation')
+      ).at_least(:once)
+    end
+  end
+
   describe '.preference_instructions' do
     it 'generates natural language prompt instructions from profile' do
       profile = {
@@ -211,4 +286,25 @@ RSpec.describe Legion::Extensions::Mesh::Helpers::PreferenceProfile do
       expect(instructions).to be_nil
     end
   end
+
+  describe 'SOURCE_CONFIDENCE' do
+    it 'includes observation source' do
+      expect(described_class::SOURCE_CONFIDENCE).to have_key('observation')
+      expect(described_class::SOURCE_CONFIDENCE['observation']).to eq(0.55)
+    end
+
+    it 'includes llm_inference source' do
+      expect(described_class::SOURCE_CONFIDENCE).to have_key('llm_inference')
+      expect(described_class::SOURCE_CONFIDENCE['llm_inference']).to eq(0.65)
+    end
+
+    it 'maintains descending confidence order for all sources' do
+      conf = described_class::SOURCE_CONFIDENCE
+      expect(conf['explicit']).to be > conf['preference_learning']
+      expect(conf['preference_learning']).to be > conf['llm_inference']
+      expect(conf['llm_inference']).to be > conf['observation']
+      expect(conf['observation']).to be > conf['personality']
+      expect(conf['personality']).to be > conf['defaults']
+    end
+  end
 end

metadata

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