lex-agentic-affect 0.1.0

data/spec/legion/extensions/agentic/affect/resonance/helpers/category_spec.rb

@@ -0,0 +1,146 @@
+# frozen_string_literal: true
+
+RSpec.describe Legion::Extensions::Agentic::Affect::Resonance::Helpers::Category do
+  let(:prototype) { [0.8, 0.6, 0.4] }
+  subject(:category) { described_class.new(prototype: prototype) }
+
+  describe '#initialize' do
+    it 'assigns a UUID id' do
+      expect(category.id).to match(/\A[0-9a-f-]{36}\z/)
+    end
+
+    it 'normalizes prototype values to [0, 1]' do
+      cat = described_class.new(prototype: [1.5, -0.2, 0.5])
+      expect(cat.prototype).to eq([1.0, 0.0, 0.5])
+    end
+
+    it 'starts with match_count of 0' do
+      expect(category.match_count).to eq(0)
+    end
+
+    it 'starts with last_matched_at nil' do
+      expect(category.last_matched_at).to be_nil
+    end
+
+    it 'stores prototype as floats' do
+      expect(category.prototype).to all(be_a(Float))
+    end
+  end
+
+  describe '#match_quality' do
+    it 'returns 1.0 for identical input' do
+      quality = category.match_quality(input: prototype)
+      expect(quality).to be_within(0.001).of(1.0)
+    end
+
+    it 'returns 0.0 for empty prototype' do
+      cat = described_class.new(prototype: [])
+      expect(cat.match_quality(input: [0.5, 0.5])).to eq(0.0)
+    end
+
+    it 'returns 0.0 for empty input' do
+      expect(category.match_quality(input: [])).to eq(0.0)
+    end
+
+    it 'returns a value between 0 and 1 for partial matches' do
+      quality = category.match_quality(input: [0.2, 0.1, 0.9])
+      expect(quality).to be_between(0.0, 1.0)
+    end
+
+    it 'returns lower quality for orthogonal vectors' do
+      cat = described_class.new(prototype: [1.0, 0.0])
+      quality = cat.match_quality(input: [0.0, 1.0])
+      expect(quality).to be < 0.3
+    end
+
+    it 'handles inputs shorter than prototype' do
+      quality = category.match_quality(input: [0.8])
+      expect(quality).to be_between(0.0, 1.0)
+    end
+
+    it 'handles inputs longer than prototype' do
+      quality = category.match_quality(input: [0.8, 0.6, 0.4, 0.9])
+      expect(quality).to be_within(0.001).of(1.0)
+    end
+
+    it 'clamps input values before computing' do
+      quality_normal = category.match_quality(input: [0.8, 0.6, 0.4])
+      quality_clamped = category.match_quality(input: [2.0, 1.5, 0.4])
+      expect(quality_clamped).to be_between(0.0, 1.0)
+      expect(quality_normal).to be_within(0.001).of(1.0)
+    end
+  end
+
+  describe '#update_prototype!' do
+    it 'returns self' do
+      result = category.update_prototype!(input: [0.9, 0.7, 0.5])
+      expect(result).to be(category)
+    end
+
+    it 'increments match_count' do
+      category.update_prototype!(input: [0.9, 0.7, 0.5])
+      expect(category.match_count).to eq(1)
+    end
+
+    it 'sets last_matched_at' do
+      before = Time.now.utc
+      category.update_prototype!(input: [0.9, 0.7, 0.5])
+      expect(category.last_matched_at).to be >= before
+    end
+
+    it 'moves prototype toward input with default learning rate' do
+      original = category.prototype.dup
+      category.update_prototype!(input: [1.0, 1.0, 1.0])
+      expect(category.prototype[0]).to be > original[0]
+    end
+
+    it 'uses provided learning rate' do
+      category.update_prototype!(input: [1.0, 1.0, 1.0], learning_rate: 1.0)
+      expect(category.prototype).to eq([1.0, 1.0, 1.0])
+    end
+
+    it 'clamps learning rate to [0, 1]' do
+      expect { category.update_prototype!(input: [0.5, 0.5, 0.5], learning_rate: 2.0) }.not_to raise_error
+      expect(category.prototype).to all(be_between(0.0, 1.0))
+    end
+
+    it 'clamps prototype values to [0, 1] after update' do
+      cat = described_class.new(prototype: [0.95, 0.95])
+      cat.update_prototype!(input: [1.5, 1.5], learning_rate: 1.0)
+      expect(cat.prototype).to all(be <= 1.0)
+    end
+
+    it 'expands prototype if input is longer' do
+      cat = described_class.new(prototype: [0.5, 0.5])
+      cat.update_prototype!(input: [0.5, 0.5, 0.8])
+      expect(cat.prototype.size).to eq(3)
+    end
+  end
+
+  describe '#to_h' do
+    it 'includes id' do
+      expect(category.to_h[:id]).to eq(category.id)
+    end
+
+    it 'includes prototype' do
+      expect(category.to_h[:prototype]).to eq(category.prototype)
+    end
+
+    it 'includes match_count' do
+      expect(category.to_h[:match_count]).to eq(0)
+    end
+
+    it 'includes last_matched_at' do
+      expect(category.to_h).to have_key(:last_matched_at)
+    end
+
+    it 'includes dimensions' do
+      expect(category.to_h[:dimensions]).to eq(3)
+    end
+
+    it 'reflects updated match_count after update' do
+      category.update_prototype!(input: [0.5, 0.5, 0.5])
+      expect(category.to_h[:match_count]).to eq(1)
+    end
+  end
+end

data/spec/legion/extensions/agentic/affect/resonance/helpers/constants_spec.rb

@@ -0,0 +1,104 @@
+# frozen_string_literal: true
+
+RSpec.describe Legion::Extensions::Agentic::Affect::Resonance::Helpers::Constants do
+  describe 'DEFAULT_VIGILANCE' do
+    it 'is 0.7' do
+      expect(described_class::DEFAULT_VIGILANCE).to eq(0.7)
+    end
+  end
+
+  describe 'MAX_CATEGORIES' do
+    it 'is 200' do
+      expect(described_class::MAX_CATEGORIES).to eq(200)
+    end
+  end
+
+  describe 'RESONANCE_THRESHOLD' do
+    it 'is 0.6' do
+      expect(described_class::RESONANCE_THRESHOLD).to eq(0.6)
+    end
+  end
+
+  describe 'DEFAULT_LEARNING_RATE' do
+    it 'is 0.2' do
+      expect(described_class::DEFAULT_LEARNING_RATE).to eq(0.2)
+    end
+  end
+
+  describe 'MATCH_LABELS' do
+    it 'is a frozen array' do
+      expect(described_class::MATCH_LABELS).to be_frozen
+    end
+
+    it 'has 5 entries' do
+      expect(described_class::MATCH_LABELS.size).to eq(5)
+    end
+
+    it 'includes a :perfect entry for high quality' do
+      entry = described_class::MATCH_LABELS.find { |e| e[:label] == :perfect }
+      expect(entry[:range]).to cover(0.95)
+    end
+  end
+
+  describe 'VIGILANCE_LABELS' do
+    it 'is a frozen array' do
+      expect(described_class::VIGILANCE_LABELS).to be_frozen
+    end
+
+    it 'has 4 entries' do
+      expect(described_class::VIGILANCE_LABELS.size).to eq(4)
+    end
+  end
+
+  describe '.match_label' do
+    it 'returns :perfect for quality >= 0.9' do
+      expect(described_class.match_label(0.95)).to eq(:perfect)
+    end
+
+    it 'returns :strong for quality in 0.75..0.9' do
+      expect(described_class.match_label(0.8)).to eq(:strong)
+    end
+
+    it 'returns :moderate for quality in 0.6..0.75' do
+      expect(described_class.match_label(0.65)).to eq(:moderate)
+    end
+
+    it 'returns :weak for quality in 0.4..0.6' do
+      expect(described_class.match_label(0.5)).to eq(:weak)
+    end
+
+    it 'returns :mismatch for quality below 0.4' do
+      expect(described_class.match_label(0.2)).to eq(:mismatch)
+    end
+
+    it 'returns :mismatch for quality = 0.0' do
+      expect(described_class.match_label(0.0)).to eq(:mismatch)
+    end
+
+    it 'returns :perfect for quality = 1.0' do
+      expect(described_class.match_label(1.0)).to eq(:perfect)
+    end
+  end
+
+  describe '.vigilance_label' do
+    it 'returns :fine for vigilance >= 0.85' do
+      expect(described_class.vigilance_label(0.9)).to eq(:fine)
+    end
+
+    it 'returns :medium for vigilance in 0.65..0.85' do
+      expect(described_class.vigilance_label(0.7)).to eq(:medium)
+    end
+
+    it 'returns :coarse for vigilance in 0.4..0.65' do
+      expect(described_class.vigilance_label(0.5)).to eq(:coarse)
+    end
+
+    it 'returns :very_coarse for vigilance below 0.4' do
+      expect(described_class.vigilance_label(0.2)).to eq(:very_coarse)
+    end
+
+    it 'returns :very_coarse for vigilance = 0.0' do
+      expect(described_class.vigilance_label(0.0)).to eq(:very_coarse)
+    end
+  end
+end

data/spec/legion/extensions/agentic/affect/resonance/helpers/resonance_engine_spec.rb

@@ -0,0 +1,189 @@
+# frozen_string_literal: true
+
+RSpec.describe Legion::Extensions::Agentic::Affect::Resonance::Helpers::ResonanceEngine do
+  subject(:engine) { described_class.new }
+
+  describe '#initialize' do
+    it 'starts with default vigilance' do
+      expect(engine.vigilance).to eq(Legion::Extensions::Agentic::Affect::Resonance::Helpers::Constants::DEFAULT_VIGILANCE)
+    end
+
+    it 'starts with zero categories' do
+      expect(engine.category_count).to eq(0)
+    end
+
+    it 'accepts custom vigilance' do
+      e = described_class.new(vigilance: 0.9)
+      expect(e.vigilance).to eq(0.9)
+    end
+
+    it 'clamps vigilance to [0, 1]' do
+      e = described_class.new(vigilance: 1.5)
+      expect(e.vigilance).to eq(1.0)
+    end
+  end
+
+  describe '#present_input' do
+    let(:input) { [0.8, 0.6, 0.4] }
+
+    it 'creates a new category for the first input' do
+      result = engine.present_input(input: input)
+      expect(result[:outcome]).to eq(:new_category)
+      expect(result[:created]).to be(true)
+      expect(result[:category_id]).to be_a(String)
+    end
+
+    it 'increments category count after first input' do
+      engine.present_input(input: input)
+      expect(engine.category_count).to eq(1)
+    end
+
+    it 'resonates with an identical second input' do
+      engine.present_input(input: input)
+      result = engine.present_input(input: input)
+      expect(result[:outcome]).to eq(:resonance)
+      expect(result[:created]).to be(false)
+    end
+
+    it 'creates a new category for dissimilar input at high vigilance' do
+      high_engine = described_class.new(vigilance: 0.99)
+      high_engine.present_input(input: [1.0, 0.0, 0.0])
+      result = high_engine.present_input(input: [0.0, 1.0, 0.0])
+      expect(result[:outcome]).to eq(:new_category)
+    end
+
+    it 'resonates with similar input at low vigilance' do
+      low_engine = described_class.new(vigilance: 0.1)
+      low_engine.present_input(input: [0.8, 0.6, 0.4])
+      result = low_engine.present_input(input: [0.7, 0.5, 0.3])
+      expect(result[:outcome]).to eq(:resonance)
+    end
+
+    it 'returns a quality score' do
+      engine.present_input(input: input)
+      result = engine.present_input(input: input)
+      expect(result[:quality]).to be_between(0.0, 1.0)
+    end
+
+    it 'returns a match label' do
+      engine.present_input(input: input)
+      result = engine.present_input(input: input)
+      expect(result[:label]).to be_a(Symbol)
+    end
+
+    it 'returns :new for label when creating a category' do
+      result = engine.present_input(input: input)
+      expect(result[:label]).to eq(:new)
+    end
+  end
+
+  describe '#best_match' do
+    it 'returns nil when no categories exist' do
+      expect(engine.best_match([0.5, 0.5])).to be_nil
+    end
+
+    it 'returns a match hash with id and quality' do
+      engine.present_input(input: [0.8, 0.6])
+      match = engine.best_match([0.8, 0.6])
+      expect(match).to include(:id, :quality)
+    end
+
+    it 'returns best quality match when multiple categories exist' do
+      engine.present_input(input: [1.0, 0.0])
+      engine.present_input(input: [0.0, 1.0])
+      match = engine.best_match([1.0, 0.0])
+      expect(match[:quality]).to be_within(0.01).of(1.0)
+    end
+  end
+
+  describe '#adjust_vigilance' do
+    it 'increases vigilance' do
+      original = engine.vigilance
+      engine.adjust_vigilance(amount: 0.1)
+      expect(engine.vigilance).to be_within(0.001).of(original + 0.1)
+    end
+
+    it 'decreases vigilance' do
+      original = engine.vigilance
+      engine.adjust_vigilance(amount: -0.1)
+      expect(engine.vigilance).to be_within(0.001).of(original - 0.1)
+    end
+
+    it 'clamps vigilance at 1.0' do
+      engine.adjust_vigilance(amount: 999.0)
+      expect(engine.vigilance).to eq(1.0)
+    end
+
+    it 'clamps vigilance at 0.0' do
+      engine.adjust_vigilance(amount: -999.0)
+      expect(engine.vigilance).to eq(0.0)
+    end
+
+    it 'returns the new vigilance value' do
+      result = engine.adjust_vigilance(amount: 0.05)
+      expect(result).to eq(engine.vigilance)
+    end
+  end
+
+  describe '#category_count' do
+    it 'returns 0 initially' do
+      expect(engine.category_count).to eq(0)
+    end
+
+    it 'increments when new categories are created' do
+      engine.present_input(input: [1.0, 0.0])
+      engine.present_input(input: [0.0, 1.0])
+      expect(engine.category_count).to eq(2)
+    end
+  end
+
+  describe '#resonance_report' do
+    before do
+      engine.present_input(input: [0.8, 0.6])
+      engine.present_input(input: [0.2, 0.4])
+    end
+
+    it 'includes category_count' do
+      expect(engine.resonance_report[:category_count]).to eq(engine.category_count)
+    end
+
+    it 'includes vigilance' do
+      expect(engine.resonance_report[:vigilance]).to eq(engine.vigilance)
+    end
+
+    it 'includes vigilance_label' do
+      expect(engine.resonance_report[:vigilance_label]).to be_a(Symbol)
+    end
+
+    it 'includes categories array' do
+      report = engine.resonance_report
+      expect(report[:categories]).to be_an(Array)
+      expect(report[:categories].size).to eq(engine.category_count)
+    end
+
+    it 'returns each category as a hash with id and prototype' do
+      report = engine.resonance_report
+      report[:categories].each do |cat|
+        expect(cat).to include(:id, :prototype, :match_count)
+      end
+    end
+  end
+
+  describe '#to_h' do
+    it 'includes vigilance and category_count' do
+      expect(engine.to_h).to include(:vigilance, :category_count)
+    end
+  end
+
+  describe 'MAX_CATEGORIES pruning' do
+    let(:max) { Legion::Extensions::Agentic::Affect::Resonance::Helpers::Constants::MAX_CATEGORIES }
+
+    it 'does not exceed MAX_CATEGORIES' do
+      high_engine = described_class.new(vigilance: 1.0)
+      (max + 10).times do |i|
+        high_engine.present_input(input: [i.to_f / (max + 10), 0.0])
+      end
+      expect(high_engine.category_count).to be <= max
+    end
+  end
+end

data/spec/legion/extensions/agentic/affect/resonance/runners/cognitive_resonance_spec.rb

@@ -0,0 +1,197 @@
+# frozen_string_literal: true
+
+require 'legion/extensions/agentic/affect/resonance/client'
+
+RSpec.describe Legion::Extensions::Agentic::Affect::Resonance::Runners::CognitiveResonance do
+  let(:client) { Legion::Extensions::Agentic::Affect::Resonance::Client.new }
+  let(:engine) { Legion::Extensions::Agentic::Affect::Resonance::Helpers::ResonanceEngine.new }
+
+  describe '#present_input' do
+    it 'returns success: true for valid input' do
+      result = client.present_input(input: [0.8, 0.6, 0.4])
+      expect(result[:success]).to be(true)
+    end
+
+    it 'returns the outcome' do
+      result = client.present_input(input: [0.8, 0.6, 0.4])
+      expect(result[:outcome]).to be_a(Symbol)
+    end
+
+    it 'returns a category_id' do
+      result = client.present_input(input: [0.8, 0.6, 0.4])
+      expect(result[:category_id]).to be_a(String)
+    end
+
+    it 'returns a quality score' do
+      result = client.present_input(input: [0.8, 0.6, 0.4])
+      expect(result[:quality]).to be_between(0.0, 1.0)
+    end
+
+    it 'returns success: false for empty input' do
+      result = client.present_input(input: [])
+      expect(result[:success]).to be(false)
+      expect(result[:error]).to eq(:empty_input)
+    end
+
+    it 'returns success: false for nil input' do
+      result = client.present_input(input: nil)
+      expect(result[:success]).to be(false)
+    end
+
+    it 'uses injected engine when provided' do
+      result = client.present_input(input: [0.5, 0.5], engine: engine)
+      expect(result[:success]).to be(true)
+      expect(engine.category_count).to be >= 1
+    end
+
+    it 'resonates on second identical input' do
+      client.present_input(input: [0.8, 0.6, 0.4])
+      result = client.present_input(input: [0.8, 0.6, 0.4])
+      expect(result[:outcome]).to eq(:resonance)
+    end
+
+    it 'creates new category on first input' do
+      result = client.present_input(input: [0.8, 0.6, 0.4])
+      expect(result[:outcome]).to eq(:new_category)
+    end
+  end
+
+  describe '#classify' do
+    it 'returns success: false for empty input' do
+      result = client.classify(input: [])
+      expect(result[:success]).to be(false)
+    end
+
+    it 'returns found: false when no categories exist' do
+      result = client.classify(input: [0.5, 0.5], engine: engine)
+      expect(result[:found]).to be(false)
+    end
+
+    it 'returns found: true when a category exists' do
+      client.present_input(input: [0.8, 0.6], engine: engine)
+      result = client.classify(input: [0.8, 0.6], engine: engine)
+      expect(result[:found]).to be(true)
+    end
+
+    it 'returns category_id and quality when found' do
+      client.present_input(input: [0.8, 0.6], engine: engine)
+      result = client.classify(input: [0.8, 0.6], engine: engine)
+      expect(result[:category_id]).to be_a(String)
+      expect(result[:quality]).to be_between(0.0, 1.0)
+    end
+
+    it 'returns a label' do
+      client.present_input(input: [0.8, 0.6], engine: engine)
+      result = client.classify(input: [0.8, 0.6], engine: engine)
+      expect(result[:label]).to be_a(Symbol)
+    end
+
+    it 'returns :none label when not found' do
+      result = client.classify(input: [0.5, 0.5], engine: engine)
+      expect(result[:label]).to eq(:none)
+    end
+
+    it 'returns quality: 0.0 and category_id: nil when not found' do
+      result = client.classify(input: [0.5, 0.5], engine: engine)
+      expect(result[:quality]).to eq(0.0)
+      expect(result[:category_id]).to be_nil
+    end
+  end
+
+  describe '#adjust_vigilance' do
+    it 'returns success: true' do
+      result = client.adjust_vigilance(amount: 0.1)
+      expect(result[:success]).to be(true)
+    end
+
+    it 'returns the new vigilance value' do
+      result = client.adjust_vigilance(amount: 0.1, engine: engine)
+      expect(result[:vigilance]).to be_between(0.0, 1.0)
+    end
+
+    it 'returns the vigilance_label' do
+      result = client.adjust_vigilance(amount: 0.0, engine: engine)
+      expect(result[:vigilance_label]).to be_a(Symbol)
+    end
+
+    it 'returns the clamped adjustment amount' do
+      result = client.adjust_vigilance(amount: 0.05, engine: engine)
+      expect(result[:adjustment]).to eq(0.05)
+    end
+
+    it 'clamps amount to [-1.0, 1.0]' do
+      result = client.adjust_vigilance(amount: 999.0, engine: engine)
+      expect(result[:adjustment]).to eq(1.0)
+    end
+
+    it 'increases vigilance' do
+      original = engine.vigilance
+      client.adjust_vigilance(amount: 0.1, engine: engine)
+      expect(engine.vigilance).to be > original
+    end
+
+    it 'decreases vigilance' do
+      original = engine.vigilance
+      client.adjust_vigilance(amount: -0.1, engine: engine)
+      expect(engine.vigilance).to be < original
+    end
+  end
+
+  describe '#resonance_report' do
+    before { client.present_input(input: [0.8, 0.6, 0.4]) }
+
+    it 'returns success: true' do
+      expect(client.resonance_report[:success]).to be(true)
+    end
+
+    it 'includes category_count' do
+      expect(client.resonance_report[:category_count]).to be >= 1
+    end
+
+    it 'includes vigilance' do
+      expect(client.resonance_report[:vigilance]).to be_between(0.0, 1.0)
+    end
+
+    it 'includes vigilance_label' do
+      expect(client.resonance_report[:vigilance_label]).to be_a(Symbol)
+    end
+
+    it 'includes categories array' do
+      expect(client.resonance_report[:categories]).to be_an(Array)
+    end
+
+    it 'uses injected engine' do
+      engine2 = Legion::Extensions::Agentic::Affect::Resonance::Helpers::ResonanceEngine.new
+      report = client.resonance_report(engine: engine2)
+      expect(report[:category_count]).to eq(0)
+    end
+  end
+
+  describe '#category_count' do
+    it 'returns success: true' do
+      expect(client.category_count[:success]).to be(true)
+    end
+
+    it 'returns 0 for fresh engine' do
+      expect(client.category_count(engine: engine)[:count]).to eq(0)
+    end
+
+    it 'returns the correct count after adding categories' do
+      client.present_input(input: [0.8, 0.6], engine: engine)
+      client.present_input(input: [0.1, 0.9], engine: engine)
+      expect(client.category_count(engine: engine)[:count]).to eq(2)
+    end
+  end
+
+  describe '#reset_engine' do
+    it 'returns success: true' do
+      expect(client.reset_engine[:success]).to be(true)
+    end
+
+    it 'resets the default engine' do
+      client.present_input(input: [0.8, 0.6, 0.4])
+      client.reset_engine
+      expect(client.category_count[:count]).to eq(0)
+    end
+  end
+end

data/spec/legion/extensions/agentic/affect/reward/client_spec.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+RSpec.describe Legion::Extensions::Agentic::Affect::Reward::Client do
+  describe '#initialize' do
+    it 'creates a default reward store' do
+      client = described_class.new
+      expect(client.reward_store).to be_a(Legion::Extensions::Agentic::Affect::Reward::Helpers::RewardStore)
+    end
+
+    it 'accepts an injected reward store' do
+      store = Legion::Extensions::Agentic::Affect::Reward::Helpers::RewardStore.new
+      client = described_class.new(reward_store: store)
+      expect(client.reward_store).to be(store)
+    end
+
+    it 'ignores unknown kwargs' do
+      expect { described_class.new(unknown: true) }.not_to raise_error
+    end
+  end
+
+  describe 'runner integration' do
+    let(:client) { described_class.new }
+
+    it { expect(client).to respond_to(:compute_reward) }
+    it { expect(client).to respond_to(:reward_status) }
+    it { expect(client).to respond_to(:reward_for) }
+    it { expect(client).to respond_to(:reward_history) }
+    it { expect(client).to respond_to(:domain_rewards) }
+    it { expect(client).to respond_to(:reward_stats) }
+  end
+
+  describe 'shared state' do
+    it 'accumulates across multiple compute calls' do
+      client = described_class.new
+      tick = { prediction_engine: { rolling_accuracy: 0.7, error_rate: 0.2 } }
+      15.times { client.compute_reward(tick_results: tick) }
+      expect(client.reward_history[:total]).to eq(15)
+    end
+  end
+end