lex-agentic-inference 0.1.0

data/spec/legion/extensions/agentic/inference/magnet/helpers/pole_spec.rb

@@ -0,0 +1,211 @@
+# frozen_string_literal: true
+
+RSpec.describe Legion::Extensions::Agentic::Inference::Magnet::Helpers::Pole do
+  subject(:pole) { described_class.new(polarity: :positive, content: 'curiosity about X', domain: :cognition) }
+
+  describe '#initialize' do
+    it 'assigns a uuid id' do
+      expect(pole.id).to match(/\A[0-9a-f-]{36}\z/)
+    end
+
+    it 'sets polarity' do
+      expect(pole.polarity).to eq(:positive)
+    end
+
+    it 'sets content' do
+      expect(pole.content).to eq('curiosity about X')
+    end
+
+    it 'sets domain' do
+      expect(pole.domain).to eq(:cognition)
+    end
+
+    it 'sets default strength to 0.5' do
+      expect(pole.strength).to eq(0.5)
+    end
+
+    it 'accepts custom strength' do
+      p = described_class.new(polarity: :negative, content: 'x', strength: 0.8)
+      expect(p.strength).to eq(0.8)
+    end
+
+    it 'clamps strength to 0-1' do
+      p = described_class.new(polarity: :positive, content: 'x', strength: 2.0)
+      expect(p.strength).to eq(1.0)
+    end
+
+    it 'sets default material_type to :iron' do
+      expect(pole.material_type).to eq(:iron)
+    end
+
+    it 'accepts custom material_type' do
+      p = described_class.new(polarity: :positive, content: 'x', material_type: :cobalt)
+      expect(p.material_type).to eq(:cobalt)
+    end
+
+    it 'sets created_at' do
+      expect(pole.created_at).to be_a(Time)
+    end
+  end
+
+  describe '#magnetize!' do
+    it 'increases strength by default rate' do
+      pole.magnetize!
+      expect(pole.strength).to be_within(0.001).of(0.58)
+    end
+
+    it 'increases strength by custom rate' do
+      pole.magnetize!(0.2)
+      expect(pole.strength).to be_within(0.001).of(0.7)
+    end
+
+    it 'does not exceed 1.0' do
+      p = described_class.new(polarity: :positive, content: 'x', strength: 0.99)
+      p.magnetize!(0.5)
+      expect(p.strength).to eq(1.0)
+    end
+
+    it 'returns self for chaining' do
+      expect(pole.magnetize!).to eq(pole)
+    end
+  end
+
+  describe '#demagnetize!' do
+    it 'decreases strength by default decay rate' do
+      pole.demagnetize!
+      expect(pole.strength).to be_within(0.001).of(0.48)
+    end
+
+    it 'decreases strength by custom rate' do
+      pole.demagnetize!(0.3)
+      expect(pole.strength).to be_within(0.001).of(0.2)
+    end
+
+    it 'does not go below 0.0' do
+      p = described_class.new(polarity: :negative, content: 'x', strength: 0.01)
+      p.demagnetize!(0.5)
+      expect(p.strength).to eq(0.0)
+    end
+
+    it 'returns self for chaining' do
+      expect(pole.demagnetize!).to eq(pole)
+    end
+  end
+
+  describe '#attracts?' do
+    it 'positive attracts negative' do
+      pos = described_class.new(polarity: :positive, content: 'a')
+      neg = described_class.new(polarity: :negative, content: 'b')
+      expect(pos.attracts?(neg)).to be true
+    end
+
+    it 'negative attracts positive' do
+      neg = described_class.new(polarity: :negative, content: 'a')
+      pos = described_class.new(polarity: :positive, content: 'b')
+      expect(neg.attracts?(pos)).to be true
+    end
+
+    it 'positive does not attract positive' do
+      a = described_class.new(polarity: :positive, content: 'a')
+      b = described_class.new(polarity: :positive, content: 'b')
+      expect(a.attracts?(b)).to be false
+    end
+
+    it 'neutral does not attract anything' do
+      neutral = described_class.new(polarity: :neutral, content: 'n')
+      pos     = described_class.new(polarity: :positive, content: 'p')
+      expect(neutral.attracts?(pos)).to be false
+    end
+
+    it 'bipolar attracts everything non-neutral' do
+      bipolar = described_class.new(polarity: :bipolar, content: 'b')
+      pos     = described_class.new(polarity: :positive, content: 'p')
+      neg     = described_class.new(polarity: :negative, content: 'n')
+      expect(bipolar.attracts?(pos)).to be true
+      expect(bipolar.attracts?(neg)).to be true
+    end
+
+    it 'bipolar attracted to by positive' do
+      pos     = described_class.new(polarity: :positive, content: 'p')
+      bipolar = described_class.new(polarity: :bipolar, content: 'b')
+      expect(pos.attracts?(bipolar)).to be true
+    end
+  end
+
+  describe '#repels?' do
+    it 'positive repels positive' do
+      a = described_class.new(polarity: :positive, content: 'a')
+      b = described_class.new(polarity: :positive, content: 'b')
+      expect(a.repels?(b)).to be true
+    end
+
+    it 'negative repels negative' do
+      a = described_class.new(polarity: :negative, content: 'a')
+      b = described_class.new(polarity: :negative, content: 'b')
+      expect(a.repels?(b)).to be true
+    end
+
+    it 'positive does not repel negative' do
+      pos = described_class.new(polarity: :positive, content: 'a')
+      neg = described_class.new(polarity: :negative, content: 'b')
+      expect(pos.repels?(neg)).to be false
+    end
+
+    it 'neutral does not repel anything' do
+      neutral = described_class.new(polarity: :neutral, content: 'n')
+      pos     = described_class.new(polarity: :positive, content: 'p')
+      expect(neutral.repels?(pos)).to be false
+    end
+
+    it 'bipolar does not repel' do
+      bipolar = described_class.new(polarity: :bipolar, content: 'b')
+      pos     = described_class.new(polarity: :positive, content: 'p')
+      expect(bipolar.repels?(pos)).to be false
+    end
+  end
+
+  describe '#saturated?' do
+    it 'returns false for default strength' do
+      expect(pole.saturated?).to be false
+    end
+
+    it 'returns true when strength is 1.0' do
+      p = described_class.new(polarity: :positive, content: 'x', strength: 1.0)
+      expect(p.saturated?).to be true
+    end
+  end
+
+  describe '#weak?' do
+    it 'returns false for default strength' do
+      expect(pole.weak?).to be false
+    end
+
+    it 'returns true when strength is 0.05' do
+      p = described_class.new(polarity: :negative, content: 'x', strength: 0.05)
+      expect(p.weak?).to be true
+    end
+  end
+
+  describe '#strength_label' do
+    it 'returns a symbol' do
+      expect(pole.strength_label).to be_a(Symbol)
+    end
+
+    it 'returns :moderate for strength 0.5' do
+      expect(pole.strength_label).to eq(:moderate)
+    end
+  end
+
+  describe '#to_h' do
+    it 'returns a hash with all expected keys' do
+      h = pole.to_h
+      expect(h).to include(:id, :polarity, :strength, :material_type, :domain, :content,
+                           :saturated, :weak, :strength_label, :created_at)
+    end
+
+    it 'reflects current state' do
+      pole.magnetize!(0.3)
+      expect(pole.to_h[:strength]).to be_within(0.001).of(0.8)
+    end
+  end
+end

data/spec/legion/extensions/agentic/inference/magnet/runners/cognitive_magnet_spec.rb

@@ -0,0 +1,201 @@
+# frozen_string_literal: true
+
+require 'legion/extensions/agentic/inference/magnet/client'
+
+RSpec.describe Legion::Extensions::Agentic::Inference::Magnet::Runners::CognitiveMagnet do
+  let(:client) { Legion::Extensions::Agentic::Inference::Magnet::Client.new }
+  let(:engine) { Legion::Extensions::Agentic::Inference::Magnet::Helpers::MagnetEngine.new }
+
+  describe '#create_pole' do
+    it 'creates a pole with valid polarity and material' do
+      result = client.create_pole(polarity: :positive, content: 'new idea')
+      expect(result[:success]).to be true
+      expect(result[:pole][:polarity]).to eq(:positive)
+    end
+
+    it 'returns error for invalid polarity' do
+      result = client.create_pole(polarity: :zap, content: 'x')
+      expect(result[:success]).to be false
+      expect(result[:error]).to eq(:invalid_polarity)
+    end
+
+    it 'includes valid_polarities in error response' do
+      result = client.create_pole(polarity: :zap, content: 'x')
+      expect(result[:valid_polarities]).to eq(Legion::Extensions::Agentic::Inference::Magnet::Helpers::Constants::POLARITY_TYPES)
+    end
+
+    it 'returns error for invalid material' do
+      result = client.create_pole(polarity: :positive, content: 'x', material_type: :plastic)
+      expect(result[:success]).to be false
+      expect(result[:error]).to eq(:invalid_material)
+    end
+
+    it 'accepts injected engine' do
+      result = client.create_pole(polarity: :positive, content: 'injected', engine: engine)
+      expect(result[:success]).to be true
+      expect(engine.poles.size).to eq(1)
+    end
+
+    it 'accepts all polarity types' do
+      %i[positive negative neutral bipolar].each do |pol|
+        result = client.create_pole(polarity: pol, content: 'test', engine: engine)
+        expect(result[:success]).to be true
+      end
+    end
+
+    it 'includes pole hash with expected keys' do
+      result = client.create_pole(polarity: :negative, content: 'shadow')
+      expect(result[:pole]).to include(:id, :polarity, :strength, :material_type, :domain, :content)
+    end
+
+    it 'ignores extra keyword arguments' do
+      result = client.create_pole(polarity: :positive, content: 'test', extra_key: 'ignored')
+      expect(result[:success]).to be true
+    end
+  end
+
+  describe '#create_field' do
+    it 'creates a field with a name' do
+      result = client.create_field(name: 'reasoning_cluster')
+      expect(result[:success]).to be true
+      expect(result[:field][:name]).to eq('reasoning_cluster')
+    end
+
+    it 'accepts injected engine' do
+      result = client.create_field(name: 'test_field', engine: engine)
+      expect(result[:success]).to be true
+      expect(engine.fields.size).to eq(1)
+    end
+
+    it 'returns field hash with expected keys' do
+      result = client.create_field(name: 'my_field')
+      expect(result[:field]).to include(:id, :name, :pole_ids, :alignment, :flux_density)
+    end
+  end
+
+  describe '#magnetize' do
+    let(:pole_id) do
+      client.create_pole(polarity: :positive, content: 'energize')[:pole][:id]
+    end
+
+    it 'magnetizes an existing pole' do
+      result = client.magnetize(pole_id: pole_id)
+      expect(result[:success]).to be true
+      expect(result[:magnetized]).to be true
+    end
+
+    it 'returns error for unknown pole' do
+      result = client.magnetize(pole_id: 'nonexistent')
+      expect(result[:success]).to be false
+      expect(result[:error]).to eq(:not_found)
+    end
+
+    it 'accepts custom rate' do
+      result = client.magnetize(pole_id: pole_id, rate: 0.3)
+      expect(result[:strength]).to be_within(0.001).of(0.8)
+    end
+
+    it 'accepts injected engine' do
+      pole = engine.create_pole(polarity: :positive, content: 'x')
+      result = client.magnetize(pole_id: pole.id, engine: engine)
+      expect(result[:success]).to be true
+    end
+  end
+
+  describe '#interact' do
+    let(:pos_id) { client.create_pole(polarity: :positive, content: 'A')[:pole][:id] }
+    let(:neg_id) { client.create_pole(polarity: :negative, content: 'B')[:pole][:id] }
+
+    it 'returns attraction for opposite polarities' do
+      result = client.interact(pole_a_id: pos_id, pole_b_id: neg_id)
+      expect(result[:success]).to be true
+      expect(result[:type]).to eq(:attraction)
+    end
+
+    it 'returns repulsion for same-polarity' do
+      other_pos = client.create_pole(polarity: :positive, content: 'C')[:pole][:id]
+      result    = client.interact(pole_a_id: pos_id, pole_b_id: other_pos)
+      expect(result[:success]).to be true
+      expect(result[:type]).to eq(:repulsion)
+    end
+
+    it 'returns error for unknown pole_a' do
+      result = client.interact(pole_a_id: 'bad', pole_b_id: neg_id)
+      expect(result[:success]).to be false
+      expect(result[:error]).to eq(:pole_a_not_found)
+    end
+
+    it 'returns error for unknown pole_b' do
+      result = client.interact(pole_a_id: pos_id, pole_b_id: 'bad')
+      expect(result[:success]).to be false
+      expect(result[:error]).to eq(:pole_b_not_found)
+    end
+
+    it 'returns error for same pole id' do
+      result = client.interact(pole_a_id: pos_id, pole_b_id: pos_id)
+      expect(result[:success]).to be false
+      expect(result[:error]).to eq(:same_pole)
+    end
+
+    it 'accepts injected engine' do
+      pa = engine.create_pole(polarity: :positive, content: 'eng_a')
+      pb = engine.create_pole(polarity: :negative, content: 'eng_b')
+      result = client.interact(pole_a_id: pa.id, pole_b_id: pb.id, engine: engine)
+      expect(result[:success]).to be true
+    end
+
+    it 'includes force in result' do
+      result = client.interact(pole_a_id: pos_id, pole_b_id: neg_id)
+      expect(result[:force]).to be_a(Numeric)
+    end
+  end
+
+  describe '#list_poles' do
+    it 'returns empty list when no poles exist' do
+      result = client.list_poles
+      expect(result[:success]).to be true
+      expect(result[:poles]).to eq([])
+      expect(result[:count]).to eq(0)
+    end
+
+    it 'returns created poles' do
+      client.create_pole(polarity: :positive, content: 'x')
+      client.create_pole(polarity: :negative, content: 'y')
+      result = client.list_poles
+      expect(result[:count]).to eq(2)
+    end
+
+    it 'respects the limit' do
+      5.times { |i| client.create_pole(polarity: :positive, content: "p#{i}") }
+      result = client.list_poles(limit: 3)
+      expect(result[:count]).to eq(3)
+    end
+
+    it 'accepts injected engine' do
+      engine.create_pole(polarity: :positive, content: 'eng_pole')
+      result = client.list_poles(engine: engine)
+      expect(result[:poles].size).to eq(1)
+    end
+  end
+
+  describe '#magnetic_status' do
+    it 'returns a status report' do
+      result = client.magnetic_status
+      expect(result[:success]).to be true
+      expect(result[:report]).to include(:total_poles, :total_fields, :total_interactions)
+    end
+
+    it 'reflects created state' do
+      client.create_pole(polarity: :positive, content: 'a')
+      client.create_field(name: 'f1')
+      result = client.magnetic_status
+      expect(result[:report][:total_poles]).to eq(1)
+      expect(result[:report][:total_fields]).to eq(1)
+    end
+
+    it 'accepts injected engine' do
+      result = client.magnetic_status(engine: engine)
+      expect(result[:success]).to be true
+    end
+  end
+end

data/spec/legion/extensions/agentic/inference/momentum/cognitive_momentum_spec.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+RSpec.describe Legion::Extensions::Agentic::Inference::Momentum do
+  it 'has a version number' do
+    expect(Legion::Extensions::Agentic::Inference::Momentum::VERSION).not_to be_nil
+  end
+
+  it 'has a version that is a string' do
+    expect(Legion::Extensions::Agentic::Inference::Momentum::VERSION).to be_a(String)
+  end
+end

data/spec/legion/extensions/agentic/inference/momentum/helpers/idea_spec.rb

@@ -0,0 +1,152 @@
+# frozen_string_literal: true
+
+RSpec.describe Legion::Extensions::Agentic::Inference::Momentum::Helpers::Idea do
+  subject(:idea) { described_class.new(content: 'test idea', idea_type: :belief, domain: :general) }
+
+  describe '#initialize' do
+    it 'creates an idea with defaults' do
+      expect(idea.content).to eq('test idea')
+      expect(idea.idea_type).to eq(:belief)
+      expect(idea.domain).to eq(:general)
+      expect(idea.mass).to eq(0.5)
+      expect(idea.velocity).to eq(0.0)
+      expect(idea.reinforcement_count).to eq(0)
+      expect(idea.challenge_count).to eq(0)
+    end
+
+    it 'generates a uuid' do
+      expect(idea.id).to match(/\A[0-9a-f-]{36}\z/)
+    end
+
+    it 'clamps mass to valid range' do
+      heavy = described_class.new(content: 'x', idea_type: :goal, domain: :d, mass: 5.0)
+      expect(heavy.mass).to eq(1.0)
+    end
+  end
+
+  describe '#momentum' do
+    it 'returns mass * velocity' do
+      expect(idea.momentum).to eq(0.0)
+    end
+
+    it 'reflects velocity after reinforcement' do
+      idea.reinforce!
+      expect(idea.momentum).to be > 0
+    end
+  end
+
+  describe '#reinforce!' do
+    it 'increases mass and velocity' do
+      old_mass = idea.mass
+      old_velocity = idea.velocity
+      idea.reinforce!
+      expect(idea.mass).to be > old_mass
+      expect(idea.velocity).to be > old_velocity
+      expect(idea.reinforcement_count).to eq(1)
+    end
+
+    it 'clamps velocity to ceiling' do
+      20.times { idea.reinforce! }
+      expect(idea.velocity).to be <= 1.0
+    end
+  end
+
+  describe '#challenge!' do
+    it 'reduces velocity and slightly reduces mass' do
+      idea.reinforce!
+      idea.reinforce!
+      old_velocity = idea.velocity
+      old_mass = idea.mass
+      idea.challenge!
+      expect(idea.velocity).to be < old_velocity
+      expect(idea.mass).to be < old_mass
+      expect(idea.challenge_count).to eq(1)
+    end
+  end
+
+  describe '#apply_force' do
+    it 'accelerates inversely proportional to mass' do
+      idea.apply_force(force: 0.1)
+      expected_accel = 0.1 / 0.5
+      expect(idea.velocity).to be_within(0.001).of(expected_accel)
+    end
+
+    it 'heavier ideas accelerate less' do
+      heavy = described_class.new(content: 'x', idea_type: :belief, domain: :d, mass: 1.0)
+      light = described_class.new(content: 'x', idea_type: :belief, domain: :d, mass: 0.2)
+      heavy.apply_force(force: 0.1)
+      light.apply_force(force: 0.1)
+      expect(light.velocity).to be > heavy.velocity
+    end
+  end
+
+  describe '#apply_friction!' do
+    it 'reduces positive velocity toward zero' do
+      idea.reinforce!
+      old_velocity = idea.velocity
+      idea.apply_friction!
+      expect(idea.velocity).to be < old_velocity
+      expect(idea.velocity).to be >= 0.0
+    end
+
+    it 'reduces negative velocity toward zero' do
+      idea.challenge!
+      idea.challenge!
+      old_velocity = idea.velocity
+      idea.apply_friction!
+      expect(idea.velocity).to be > old_velocity
+      expect(idea.velocity).to be <= 0.0
+    end
+
+    it 'does nothing when velocity is zero' do
+      idea.apply_friction!
+      expect(idea.velocity).to eq(0.0)
+    end
+  end
+
+  describe '#momentum_label' do
+    it 'returns a symbol' do
+      expect(idea.momentum_label).to be_a(Symbol)
+    end
+
+    it 'returns :surging for high momentum' do
+      10.times { idea.reinforce! }
+      expect(idea.momentum_label).to eq(:surging)
+    end
+  end
+
+  describe '#inertia_label' do
+    it 'returns :moderate for default mass' do
+      expect(idea.inertia_label).to eq(:moderate)
+    end
+
+    it 'returns :immovable for high mass' do
+      heavy = described_class.new(content: 'x', idea_type: :belief, domain: :d, mass: 0.9)
+      expect(heavy.inertia_label).to eq(:immovable)
+    end
+  end
+
+  describe 'predicate methods' do
+    it '#at_rest? is true when velocity near zero' do
+      expect(idea.at_rest?).to be true
+    end
+
+    it '#surging? is true with high momentum' do
+      10.times { idea.reinforce! }
+      expect(idea.surging?).to be true
+    end
+
+    it '#entrenched? is true with high mass' do
+      10.times { idea.reinforce! }
+      expect(idea.entrenched?).to be true
+    end
+  end
+
+  describe '#to_h' do
+    it 'returns a complete hash' do
+      hash = idea.to_h
+      expect(hash).to include(:id, :content, :idea_type, :domain, :mass, :velocity,
+                              :momentum, :momentum_label, :inertia_label)
+    end
+  end
+end