lex-agentic-inference 0.1.0

data/spec/legion/extensions/agentic/inference/magnet/client_spec.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+require 'legion/extensions/agentic/inference/magnet/client'
+
+RSpec.describe Legion::Extensions::Agentic::Inference::Magnet::Client do
+  it 'responds to all runner methods' do
+    client = described_class.new
+    expect(client).to respond_to(:create_pole)
+    expect(client).to respond_to(:create_field)
+    expect(client).to respond_to(:magnetize)
+    expect(client).to respond_to(:interact)
+    expect(client).to respond_to(:list_poles)
+    expect(client).to respond_to(:magnetic_status)
+  end
+
+  it 'initializes with a fresh magnet engine' do
+    client = described_class.new
+    result = client.magnetic_status
+    expect(result[:report][:total_poles]).to eq(0)
+    expect(result[:report][:total_fields]).to eq(0)
+  end
+
+  it 'maintains isolated state per instance' do
+    a = described_class.new
+    b = described_class.new
+    a.create_pole(polarity: :positive, content: 'only in a')
+    expect(a.magnetic_status[:report][:total_poles]).to eq(1)
+    expect(b.magnetic_status[:report][:total_poles]).to eq(0)
+  end
+end

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

@@ -0,0 +1,120 @@
+# frozen_string_literal: true
+
+RSpec.describe Legion::Extensions::Agentic::Inference::Magnet::Helpers::Constants do
+  describe 'POLARITY_TYPES' do
+    it 'includes expected polarity types' do
+      expect(described_class::POLARITY_TYPES).to include(:positive, :negative, :neutral, :bipolar)
+    end
+
+    it 'is frozen' do
+      expect(described_class::POLARITY_TYPES).to be_frozen
+    end
+  end
+
+  describe 'MATERIAL_TYPES' do
+    it 'includes expected material types' do
+      expect(described_class::MATERIAL_TYPES).to include(:iron, :cobalt, :nickel, :lodestone, :ferrite)
+    end
+
+    it 'is frozen' do
+      expect(described_class::MATERIAL_TYPES).to be_frozen
+    end
+  end
+
+  describe 'capacity constants' do
+    it 'defines MAX_POLES as 500' do
+      expect(described_class::MAX_POLES).to eq(500)
+    end
+
+    it 'defines MAX_FIELDS as 50' do
+      expect(described_class::MAX_FIELDS).to eq(50)
+    end
+  end
+
+  describe 'rate constants' do
+    it 'defines ATTRACTION_RATE as 0.08' do
+      expect(described_class::ATTRACTION_RATE).to eq(0.08)
+    end
+
+    it 'defines REPULSION_RATE as 0.06' do
+      expect(described_class::REPULSION_RATE).to eq(0.06)
+    end
+
+    it 'defines DECAY_RATE as 0.02' do
+      expect(described_class::DECAY_RATE).to eq(0.02)
+    end
+  end
+
+  describe 'STRENGTH_LABELS' do
+    it 'covers 0.0 to 1.0 range' do
+      expect(described_class::STRENGTH_LABELS).to be_a(Hash)
+      expect(described_class::STRENGTH_LABELS.size).to be >= 5
+    end
+
+    it 'is frozen' do
+      expect(described_class::STRENGTH_LABELS).to be_frozen
+    end
+  end
+
+  describe 'ALIGNMENT_LABELS' do
+    it 'covers alignment range' do
+      expect(described_class::ALIGNMENT_LABELS).to be_a(Hash)
+      expect(described_class::ALIGNMENT_LABELS.size).to be >= 4
+    end
+
+    it 'is frozen' do
+      expect(described_class::ALIGNMENT_LABELS).to be_frozen
+    end
+  end
+
+  describe '.label_for' do
+    it 'returns correct label for strength 0.05' do
+      label = described_class.label_for(described_class::STRENGTH_LABELS, 0.05)
+      expect(label).to eq(:negligible)
+    end
+
+    it 'returns correct label for strength 0.95' do
+      label = described_class.label_for(described_class::STRENGTH_LABELS, 0.95)
+      expect(label).to eq(:overwhelming)
+    end
+
+    it 'returns correct alignment label for 0.9' do
+      label = described_class.label_for(described_class::ALIGNMENT_LABELS, 0.9)
+      expect(label).to eq(:perfect)
+    end
+
+    it 'returns correct alignment label for 0.1' do
+      label = described_class.label_for(described_class::ALIGNMENT_LABELS, 0.1)
+      expect(label).to eq(:chaotic)
+    end
+
+    it 'returns :unknown for a value not in any range' do
+      label = described_class.label_for({}, 0.5)
+      expect(label).to eq(:unknown)
+    end
+  end
+
+  describe '.valid_polarity?' do
+    it 'returns true for valid polarities' do
+      %i[positive negative neutral bipolar].each do |p|
+        expect(described_class.valid_polarity?(p)).to be true
+      end
+    end
+
+    it 'returns false for invalid polarity' do
+      expect(described_class.valid_polarity?(:zap)).to be false
+    end
+  end
+
+  describe '.valid_material?' do
+    it 'returns true for valid materials' do
+      %i[iron cobalt nickel lodestone ferrite].each do |m|
+        expect(described_class.valid_material?(m)).to be true
+      end
+    end
+
+    it 'returns false for invalid material' do
+      expect(described_class.valid_material?(:plastic)).to be false
+    end
+  end
+end

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

@@ -0,0 +1,193 @@
+# frozen_string_literal: true
+
+RSpec.describe Legion::Extensions::Agentic::Inference::Magnet::Helpers::Field do
+  subject(:field) { described_class.new(name: 'semantic_cluster') }
+
+  let(:pole_pos) do
+    Legion::Extensions::Agentic::Inference::Magnet::Helpers::Pole.new(
+      polarity: :positive, content: 'idea A', strength: 0.7
+    )
+  end
+  let(:pole_neg) do
+    Legion::Extensions::Agentic::Inference::Magnet::Helpers::Pole.new(
+      polarity: :negative, content: 'idea B', strength: 0.6
+    )
+  end
+  let(:pole_pos2) do
+    Legion::Extensions::Agentic::Inference::Magnet::Helpers::Pole.new(
+      polarity: :positive, content: 'idea C', strength: 0.8
+    )
+  end
+  let(:poles_hash) do
+    { pole_pos.id => pole_pos, pole_neg.id => pole_neg }
+  end
+
+  describe '#initialize' do
+    it 'assigns a uuid id' do
+      expect(field.id).to match(/\A[0-9a-f-]{36}\z/)
+    end
+
+    it 'sets name' do
+      expect(field.name).to eq('semantic_cluster')
+    end
+
+    it 'initializes with empty pole_ids' do
+      expect(field.pole_ids).to eq([])
+    end
+
+    it 'initializes alignment to 0.0' do
+      expect(field.alignment).to eq(0.0)
+    end
+
+    it 'initializes flux_density to 0.0' do
+      expect(field.flux_density).to eq(0.0)
+    end
+
+    it 'sets created_at' do
+      expect(field.created_at).to be_a(Time)
+    end
+  end
+
+  describe '#add_pole' do
+    it 'adds a pole id and returns true' do
+      result = field.add_pole(pole_pos.id)
+      expect(result).to be true
+      expect(field.pole_ids).to include(pole_pos.id)
+    end
+
+    it 'does not add duplicates and returns false' do
+      field.add_pole(pole_pos.id)
+      result = field.add_pole(pole_pos.id)
+      expect(result).to be false
+      expect(field.pole_ids.count(pole_pos.id)).to eq(1)
+    end
+
+    it 'can add multiple poles' do
+      field.add_pole(pole_pos.id)
+      field.add_pole(pole_neg.id)
+      expect(field.pole_ids.size).to eq(2)
+    end
+  end
+
+  describe '#remove_pole' do
+    before { field.add_pole(pole_pos.id) }
+
+    it 'removes a pole and returns true' do
+      result = field.remove_pole(pole_pos.id)
+      expect(result).to be true
+      expect(field.pole_ids).not_to include(pole_pos.id)
+    end
+
+    it 'returns false when pole not in field' do
+      result = field.remove_pole('nonexistent-id')
+      expect(result).to be false
+    end
+  end
+
+  describe '#calculate_alignment!' do
+    it 'returns self for chaining' do
+      expect(field.calculate_alignment!({})).to eq(field)
+    end
+
+    it 'does nothing with empty poles hash' do
+      field.add_pole(pole_pos.id)
+      field.calculate_alignment!({})
+      expect(field.alignment).to eq(0.0)
+    end
+
+    it 'computes alignment with attraction pair (positive+negative)' do
+      field.add_pole(pole_pos.id)
+      field.add_pole(pole_neg.id)
+      field.calculate_alignment!(poles_hash)
+      expect(field.alignment).to be > 0.5
+    end
+
+    it 'computes alignment with repulsion pair (positive+positive)' do
+      pos2_h = { pole_pos.id => pole_pos, pole_pos2.id => pole_pos2 }
+      field.add_pole(pole_pos.id)
+      field.add_pole(pole_pos2.id)
+      field.calculate_alignment!(pos2_h)
+      expect(field.alignment).to be <= 0.5
+    end
+
+    it 'updates flux_density' do
+      field.add_pole(pole_pos.id)
+      field.add_pole(pole_neg.id)
+      field.calculate_alignment!(poles_hash)
+      expect(field.flux_density).to be > 0.0
+    end
+
+    it 'handles single pole gracefully' do
+      field.add_pole(pole_pos.id)
+      field.calculate_alignment!({ pole_pos.id => pole_pos })
+      expect(field.alignment).to eq(0.0)
+    end
+  end
+
+  describe '#coherent?' do
+    it 'returns false by default' do
+      expect(field.coherent?).to be false
+    end
+
+    it 'returns true when alignment >= 0.6' do
+      field.add_pole(pole_pos.id)
+      field.add_pole(pole_neg.id)
+      field.calculate_alignment!(poles_hash)
+      if field.alignment >= 0.6
+        expect(field.coherent?).to be true
+      else
+        expect(field.coherent?).to be false
+      end
+    end
+  end
+
+  describe '#chaotic?' do
+    it 'returns true by default (alignment 0.0)' do
+      expect(field.chaotic?).to be true
+    end
+
+    it 'returns false when alignment is moderate' do
+      field.add_pole(pole_pos.id)
+      field.add_pole(pole_neg.id)
+      field.calculate_alignment!(poles_hash)
+      expect(field.chaotic?).to be(field.alignment < 0.2)
+    end
+  end
+
+  describe '#alignment_label' do
+    it 'returns a symbol' do
+      expect(field.alignment_label).to be_a(Symbol)
+    end
+
+    it 'returns :chaotic for default alignment 0.0' do
+      expect(field.alignment_label).to eq(:chaotic)
+    end
+  end
+
+  describe '#pole_count' do
+    it 'returns 0 initially' do
+      expect(field.pole_count).to eq(0)
+    end
+
+    it 'returns correct count after adding poles' do
+      field.add_pole(pole_pos.id)
+      field.add_pole(pole_neg.id)
+      expect(field.pole_count).to eq(2)
+    end
+  end
+
+  describe '#to_h' do
+    it 'includes all expected keys' do
+      h = field.to_h
+      expect(h).to include(:id, :name, :pole_ids, :alignment, :flux_density, :pole_count,
+                           :coherent, :chaotic, :alignment_label, :created_at)
+    end
+
+    it 'returns a copy of pole_ids' do
+      field.add_pole(pole_pos.id)
+      h = field.to_h
+      h[:pole_ids] << 'injected'
+      expect(field.pole_ids.size).to eq(1)
+    end
+  end
+end

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

@@ -0,0 +1,281 @@
+# frozen_string_literal: true
+
+RSpec.describe Legion::Extensions::Agentic::Inference::Magnet::Helpers::MagnetEngine do
+  subject(:engine) { described_class.new }
+
+  let(:pos_pole_id) do
+    engine.create_pole(polarity: :positive, content: 'idea A').id
+  end
+  let(:neg_pole_id) do
+    engine.create_pole(polarity: :negative, content: 'idea B').id
+  end
+
+  describe '#create_pole' do
+    it 'creates and stores a pole' do
+      result = engine.create_pole(polarity: :positive, content: 'concept')
+      expect(result).to be_a(Legion::Extensions::Agentic::Inference::Magnet::Helpers::Pole)
+      expect(engine.poles.size).to eq(1)
+    end
+
+    it 'accepts all keyword arguments' do
+      result = engine.create_pole(
+        polarity: :negative, content: 'idea', strength: 0.7,
+        material_type: :cobalt, domain: :reasoning
+      )
+      expect(result.polarity).to eq(:negative)
+      expect(result.strength).to be_within(0.001).of(0.7)
+      expect(result.material_type).to eq(:cobalt)
+    end
+
+    it 'returns error when at capacity' do
+      stub_const('Legion::Extensions::Agentic::Inference::Magnet::Helpers::Constants::MAX_POLES', 1)
+      engine.create_pole(polarity: :positive, content: 'first')
+      result = engine.create_pole(polarity: :negative, content: 'second')
+      expect(result[:error]).to eq(:capacity_exceeded)
+    end
+  end
+
+  describe '#create_field' do
+    it 'creates and stores a field' do
+      result = engine.create_field(name: 'test_field')
+      expect(result).to be_a(Legion::Extensions::Agentic::Inference::Magnet::Helpers::Field)
+      expect(engine.fields.size).to eq(1)
+    end
+
+    it 'returns error when at field capacity' do
+      stub_const('Legion::Extensions::Agentic::Inference::Magnet::Helpers::Constants::MAX_FIELDS', 1)
+      engine.create_field(name: 'first')
+      result = engine.create_field(name: 'second')
+      expect(result[:error]).to eq(:capacity_exceeded)
+    end
+  end
+
+  describe '#magnetize' do
+    it 'increases pole strength' do
+      id = engine.create_pole(polarity: :positive, content: 'x', strength: 0.5).id
+      result = engine.magnetize(id)
+      expect(result[:magnetized]).to be true
+      expect(result[:strength]).to be_within(0.001).of(0.58)
+    end
+
+    it 'returns error for unknown pole' do
+      result = engine.magnetize('nonexistent')
+      expect(result[:error]).to eq(:not_found)
+    end
+
+    it 'accepts custom rate' do
+      id = engine.create_pole(polarity: :positive, content: 'x', strength: 0.5).id
+      result = engine.magnetize(id, rate: 0.2)
+      expect(result[:strength]).to be_within(0.001).of(0.7)
+    end
+  end
+
+  describe '#interact' do
+    it 'returns attraction for positive/negative pair' do
+      result = engine.interact(pos_pole_id, neg_pole_id)
+      expect(result[:type]).to eq(:attraction)
+    end
+
+    it 'increases strength on attraction' do
+      pole_a = engine.poles[pos_pole_id]
+      original_strength = pole_a.strength
+      engine.interact(pos_pole_id, neg_pole_id)
+      expect(pole_a.strength).to be > original_strength
+    end
+
+    it 'returns repulsion for same-polarity pair' do
+      a = engine.create_pole(polarity: :positive, content: 'a').id
+      b = engine.create_pole(polarity: :positive, content: 'b').id
+      result = engine.interact(a, b)
+      expect(result[:type]).to eq(:repulsion)
+    end
+
+    it 'decreases strength on repulsion' do
+      a_pole = engine.create_pole(polarity: :positive, content: 'a', strength: 0.8)
+      b_pole = engine.create_pole(polarity: :positive, content: 'b', strength: 0.8)
+      original = a_pole.strength
+      engine.interact(a_pole.id, b_pole.id)
+      expect(a_pole.strength).to be < original
+    end
+
+    it 'returns neutral for neutral poles' do
+      a = engine.create_pole(polarity: :neutral, content: 'a').id
+      b = engine.create_pole(polarity: :neutral, content: 'b').id
+      result = engine.interact(a, b)
+      expect(result[:type]).to eq(:neutral)
+    end
+
+    it 'returns error for missing pole_a' do
+      result = engine.interact('bad_id', neg_pole_id)
+      expect(result[:error]).to eq(:pole_a_not_found)
+    end
+
+    it 'returns error for missing pole_b' do
+      result = engine.interact(pos_pole_id, 'bad_id')
+      expect(result[:error]).to eq(:pole_b_not_found)
+    end
+
+    it 'returns error for same pole' do
+      result = engine.interact(pos_pole_id, pos_pole_id)
+      expect(result[:error]).to eq(:same_pole)
+    end
+
+    it 'logs the interaction event' do
+      engine.interact(pos_pole_id, neg_pole_id)
+      expect(engine.interaction_log.size).to eq(1)
+    end
+
+    it 'includes force in result' do
+      result = engine.interact(pos_pole_id, neg_pole_id)
+      expect(result[:force]).to be >= 0.0
+    end
+
+    it 'includes timestamp in result' do
+      result = engine.interact(pos_pole_id, neg_pole_id)
+      expect(result[:at]).to be_a(Time)
+    end
+  end
+
+  describe '#demagnetize_all!' do
+    it 'decays all pole strengths' do
+      id1 = engine.create_pole(polarity: :positive, content: 'x', strength: 0.8).id
+      id2 = engine.create_pole(polarity: :negative, content: 'y', strength: 0.6).id
+      engine.demagnetize_all!
+      expect(engine.poles[id1].strength).to be < 0.8
+      expect(engine.poles[id2].strength).to be < 0.6
+    end
+
+    it 'returns count of demagnetized poles' do
+      engine.create_pole(polarity: :positive, content: 'a')
+      engine.create_pole(polarity: :negative, content: 'b')
+      result = engine.demagnetize_all!
+      expect(result[:demagnetized]).to eq(2)
+    end
+
+    it 'accepts custom rate' do
+      id = engine.create_pole(polarity: :positive, content: 'x', strength: 0.5).id
+      engine.demagnetize_all!(rate: 0.1)
+      expect(engine.poles[id].strength).to be_within(0.001).of(0.4)
+    end
+  end
+
+  describe '#add_pole_to_field' do
+    let(:field_id) { engine.create_field(name: 'test').id }
+
+    it 'adds pole to field' do
+      result = engine.add_pole_to_field(field_id: field_id, pole_id: pos_pole_id)
+      expect(result[:added]).to be true
+    end
+
+    it 'returns error for unknown field' do
+      result = engine.add_pole_to_field(field_id: 'bad', pole_id: pos_pole_id)
+      expect(result[:error]).to eq(:field_not_found)
+    end
+
+    it 'returns error for unknown pole' do
+      result = engine.add_pole_to_field(field_id: field_id, pole_id: 'bad')
+      expect(result[:error]).to eq(:pole_not_found)
+    end
+  end
+
+  describe '#remove_pole_from_field' do
+    let(:field_id) { engine.create_field(name: 'test').id }
+
+    before { engine.add_pole_to_field(field_id: field_id, pole_id: pos_pole_id) }
+
+    it 'removes pole from field' do
+      result = engine.remove_pole_from_field(field_id: field_id, pole_id: pos_pole_id)
+      expect(result[:removed]).to be true
+    end
+
+    it 'returns error for unknown field' do
+      result = engine.remove_pole_from_field(field_id: 'bad', pole_id: pos_pole_id)
+      expect(result[:error]).to eq(:field_not_found)
+    end
+  end
+
+  describe '#most_aligned_fields' do
+    it 'returns fields sorted by alignment descending' do
+      field_a = engine.create_field(name: 'field_a')
+      field_b = engine.create_field(name: 'field_b')
+      pos_a = engine.create_pole(polarity: :positive, content: 'a1', strength: 0.8)
+      neg_a = engine.create_pole(polarity: :negative, content: 'a2', strength: 0.8)
+      engine.add_pole_to_field(field_id: field_a.id, pole_id: pos_a.id)
+      engine.add_pole_to_field(field_id: field_a.id, pole_id: neg_a.id)
+      engine.add_pole_to_field(field_id: field_b.id, pole_id: pos_a.id)
+
+      results = engine.most_aligned_fields(limit: 2)
+      expect(results).to be_an(Array)
+    end
+
+    it 'respects the limit' do
+      3.times { |i| engine.create_field(name: "f#{i}") }
+      results = engine.most_aligned_fields(limit: 2)
+      expect(results.size).to be <= 2
+    end
+  end
+
+  describe '#strongest_poles' do
+    it 'returns poles sorted by strength descending' do
+      engine.create_pole(polarity: :positive, content: 'strong', strength: 0.9)
+      engine.create_pole(polarity: :negative, content: 'medium', strength: 0.5)
+      engine.create_pole(polarity: :neutral,  content: 'weak',   strength: 0.05)
+      results = engine.strongest_poles(limit: 3)
+      strengths = results.map(&:strength)
+      expect(strengths).to eq(strengths.sort.reverse)
+    end
+
+    it 'excludes weak poles' do
+      engine.create_pole(polarity: :positive, content: 'weak', strength: 0.05)
+      results = engine.strongest_poles
+      expect(results.none?(&:weak?)).to be true
+    end
+
+    it 'respects the limit' do
+      5.times { |i| engine.create_pole(polarity: :positive, content: "p#{i}", strength: 0.6) }
+      results = engine.strongest_poles(limit: 3)
+      expect(results.size).to eq(3)
+    end
+  end
+
+  describe '#field_report' do
+    it 'returns a comprehensive report' do
+      report = engine.field_report
+      expect(report).to include(:total_poles, :total_fields, :coherent_fields, :chaotic_fields,
+                                :saturated_poles, :weak_poles, :total_interactions,
+                                :strongest, :top_fields)
+    end
+
+    it 'counts poles correctly' do
+      engine.create_pole(polarity: :positive, content: 'a')
+      engine.create_pole(polarity: :negative, content: 'b')
+      report = engine.field_report
+      expect(report[:total_poles]).to eq(2)
+    end
+
+    it 'counts fields correctly' do
+      engine.create_field(name: 'f1')
+      engine.create_field(name: 'f2')
+      report = engine.field_report
+      expect(report[:total_fields]).to eq(2)
+    end
+
+    it 'counts interactions' do
+      engine.interact(pos_pole_id, neg_pole_id)
+      report = engine.field_report
+      expect(report[:total_interactions]).to eq(1)
+    end
+
+    it 'identifies saturated poles' do
+      engine.create_pole(polarity: :positive, content: 'max', strength: 1.0)
+      report = engine.field_report
+      expect(report[:saturated_poles]).to be >= 1
+    end
+
+    it 'identifies weak poles' do
+      engine.create_pole(polarity: :negative, content: 'min', strength: 0.05)
+      report = engine.field_report
+      expect(report[:weak_poles]).to be >= 1
+    end
+  end
+end