lex-agentic-inference 0.1.0

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

@@ -0,0 +1,107 @@
+# frozen_string_literal: true
+
+RSpec.describe Legion::Extensions::Agentic::Inference::Gravity::Helpers::Constants do
+  describe 'numeric constants' do
+    it 'defines MAX_ATTRACTORS' do
+      expect(described_class::MAX_ATTRACTORS).to eq(200)
+    end
+
+    it 'defines MAX_ORBITING' do
+      expect(described_class::MAX_ORBITING).to eq(500)
+    end
+
+    it 'defines DEFAULT_MASS' do
+      expect(described_class::DEFAULT_MASS).to eq(1.0)
+    end
+
+    it 'defines MASS_ACCRETION' do
+      expect(described_class::MASS_ACCRETION).to eq(0.15)
+    end
+
+    it 'defines MASS_EROSION' do
+      expect(described_class::MASS_EROSION).to eq(0.05)
+    end
+
+    it 'defines CAPTURE_RADIUS' do
+      expect(described_class::CAPTURE_RADIUS).to eq(0.2)
+    end
+
+    it 'defines ESCAPE_RADIUS' do
+      expect(described_class::ESCAPE_RADIUS).to eq(1.5)
+    end
+
+    it 'defines PULL_CONSTANT' do
+      expect(described_class::PULL_CONSTANT).to eq(0.1)
+    end
+
+    it 'defines COLLAPSE_THRESHOLD' do
+      expect(described_class::COLLAPSE_THRESHOLD).to eq(0.1)
+    end
+
+    it 'defines SUPERMASSIVE_THRESHOLD' do
+      expect(described_class::SUPERMASSIVE_THRESHOLD).to eq(3.0)
+    end
+  end
+
+  describe 'ATTRACTOR_DOMAINS' do
+    it 'contains 8 domains' do
+      expect(described_class::ATTRACTOR_DOMAINS.size).to eq(8)
+    end
+
+    it 'includes expected domains' do
+      expect(described_class::ATTRACTOR_DOMAINS).to include(:problem, :curiosity, :anxiety, :obsession)
+      expect(described_class::ATTRACTOR_DOMAINS).to include(:interest, :fear, :desire, :unknown)
+    end
+
+    it 'is frozen' do
+      expect(described_class::ATTRACTOR_DOMAINS).to be_frozen
+    end
+  end
+
+  describe '.label_for' do
+    it 'returns correct mass label for weak mass' do
+      label = described_class.label_for(described_class::MASS_LABELS, 0.3)
+      expect(label).to eq(:weak)
+    end
+
+    it 'returns correct mass label for supermassive' do
+      label = described_class.label_for(described_class::MASS_LABELS, 4.0)
+      expect(label).to eq(:supermassive)
+    end
+
+    it 'returns :unknown for a value not in any range' do
+      label = described_class.label_for({}, 1.0)
+      expect(label).to eq(:unknown)
+    end
+
+    it 'returns empty density label for zero thoughts' do
+      label = described_class.label_for(described_class::DENSITY_LABELS, 0)
+      expect(label).to eq(:empty)
+    end
+
+    it 'returns crowded density label for large count' do
+      label = described_class.label_for(described_class::DENSITY_LABELS, 30)
+      expect(label).to eq(:crowded)
+    end
+
+    it 'returns captured orbit label for very close distance' do
+      label = described_class.label_for(described_class::ORBIT_LABELS, 0.05)
+      expect(label).to eq(:captured)
+    end
+
+    it 'returns escaped orbit label for large distance' do
+      label = described_class.label_for(described_class::ORBIT_LABELS, 2.0)
+      expect(label).to eq(:escaped)
+    end
+  end
+
+  describe '.valid_domain?' do
+    it 'returns true for a valid domain' do
+      expect(described_class.valid_domain?(:curiosity)).to be true
+    end
+
+    it 'returns false for an invalid domain' do
+      expect(described_class.valid_domain?(:nonexistent)).to be false
+    end
+  end
+end

data/spec/legion/extensions/agentic/inference/gravity/helpers/gravity_engine_spec.rb

@@ -0,0 +1,193 @@
+# frozen_string_literal: true
+
+RSpec.describe Legion::Extensions::Agentic::Inference::Gravity::Helpers::GravityEngine do
+  subject(:engine) { described_class.new }
+
+  describe '#add_attractor' do
+    it 'creates and stores an attractor' do
+      result = engine.add_attractor(content: 'test', domain: :curiosity)
+      expect(result).to be_a(Legion::Extensions::Agentic::Inference::Gravity::Helpers::Attractor)
+      expect(engine.attractors.size).to eq(1)
+    end
+
+    it 'returns error when at capacity' do
+      stub_const('Legion::Extensions::Agentic::Inference::Gravity::Helpers::Constants::MAX_ATTRACTORS', 1)
+      engine.add_attractor(content: 'first', domain: :problem)
+      result = engine.add_attractor(content: 'second', domain: :problem)
+      expect(result[:error]).to eq(:capacity_exceeded)
+    end
+  end
+
+  describe '#add_orbiting_thought' do
+    let(:attractor) { engine.add_attractor(content: 'center', domain: :problem) }
+
+    it 'creates and stores an orbiting thought' do
+      result = engine.add_orbiting_thought(content: 'orbit', attractor_id: attractor.id)
+      expect(result).to be_a(Legion::Extensions::Agentic::Inference::Gravity::Helpers::OrbitingThought)
+      expect(engine.orbiting_thoughts.size).to eq(1)
+    end
+
+    it 'returns error for unknown attractor' do
+      result = engine.add_orbiting_thought(content: 'orphan', attractor_id: 'nonexistent')
+      expect(result[:error]).to eq(:attractor_not_found)
+    end
+
+    it 'returns error when orbiting capacity exceeded' do
+      stub_const('Legion::Extensions::Agentic::Inference::Gravity::Helpers::Constants::MAX_ORBITING', 1)
+      engine.add_orbiting_thought(content: 'first', attractor_id: attractor.id)
+      result = engine.add_orbiting_thought(content: 'second', attractor_id: attractor.id)
+      expect(result[:error]).to eq(:capacity_exceeded)
+    end
+  end
+
+  describe '#simulate_tick' do
+    let!(:attractor) { engine.add_attractor(content: 'pull', domain: :obsession, mass: 2.0, pull_radius: 2.0) }
+
+    it 'returns tick_processed true' do
+      result = engine.simulate_tick
+      expect(result[:tick_processed]).to be true
+    end
+
+    it 'pulls orbiting thoughts closer' do
+      thought = engine.add_orbiting_thought(
+        content: 'drawn in', attractor_id: attractor.id, orbital_distance: 0.5
+      )
+      initial_distance = thought.orbital_distance
+      engine.simulate_tick
+      expect(thought.orbital_distance).to be < initial_distance
+    end
+
+    it 'detects capture events when thought crosses capture radius' do
+      engine.add_orbiting_thought(
+        content: 'almost captured', attractor_id: attractor.id, orbital_distance: 0.3
+      )
+      result = engine.simulate_tick
+      expect(result[:captures].size).to be >= 1
+    end
+
+    it 'does not pull thoughts beyond pull_radius' do
+      thought = engine.add_orbiting_thought(
+        content: 'far away', attractor_id: attractor.id, orbital_distance: 3.0
+      )
+      engine.simulate_tick
+      expect(thought.orbital_distance).to eq(3.0)
+    end
+
+    it 'skips collapsed attractors' do
+      collapsed = engine.add_attractor(content: 'collapsed', domain: :fear, mass: 0.05)
+      thought = engine.add_orbiting_thought(
+        content: 'near collapsed', attractor_id: collapsed.id, orbital_distance: 0.5
+      )
+      engine.simulate_tick
+      expect(thought.orbital_distance).to eq(0.5)
+    end
+  end
+
+  describe '#accrete_attractor' do
+    let!(:attractor) { engine.add_attractor(content: 'grow', domain: :interest) }
+
+    it 'increases attractor mass' do
+      engine.accrete_attractor(attractor.id)
+      expect(attractor.mass).to be_within(0.001).of(1.15)
+    end
+
+    it 'returns accreted true' do
+      result = engine.accrete_attractor(attractor.id)
+      expect(result[:accreted]).to be true
+    end
+
+    it 'returns error for unknown attractor' do
+      result = engine.accrete_attractor('nonexistent')
+      expect(result[:error]).to eq(:not_found)
+    end
+  end
+
+  describe '#erode_attractor' do
+    let!(:attractor) { engine.add_attractor(content: 'shrink', domain: :anxiety) }
+
+    it 'decreases attractor mass' do
+      engine.erode_attractor(attractor.id)
+      expect(attractor.mass).to be_within(0.001).of(0.95)
+    end
+
+    it 'returns eroded true' do
+      result = engine.erode_attractor(attractor.id)
+      expect(result[:eroded]).to be true
+    end
+
+    it 'reports collapsed when mass drops below threshold' do
+      a = engine.add_attractor(content: 'weak', domain: :fear, mass: 0.12)
+      result = engine.erode_attractor(a.id, amount: 0.1)
+      expect(result[:collapsed]).to be true
+    end
+
+    it 'returns error for unknown attractor' do
+      result = engine.erode_attractor('nonexistent')
+      expect(result[:error]).to eq(:not_found)
+    end
+  end
+
+  describe '#strongest_attractors' do
+    it 'returns attractors sorted by mass descending' do
+      engine.add_attractor(content: 'light', domain: :curiosity, mass: 0.5)
+      engine.add_attractor(content: 'heavy', domain: :obsession, mass: 2.5)
+      engine.add_attractor(content: 'medium', domain: :interest, mass: 1.2)
+      results = engine.strongest_attractors(limit: 3)
+      masses = results.map(&:mass)
+      expect(masses).to eq(masses.sort.reverse)
+    end
+
+    it 'excludes collapsed attractors' do
+      engine.add_attractor(content: 'alive', domain: :curiosity, mass: 1.5)
+      engine.add_attractor(content: 'dead', domain: :fear, mass: 0.05)
+      results = engine.strongest_attractors
+      expect(results.none?(&:collapsed?)).to be true
+    end
+
+    it 'respects the limit parameter' do
+      5.times { |i| engine.add_attractor(content: "attractor #{i}", domain: :problem) }
+      results = engine.strongest_attractors(limit: 3)
+      expect(results.size).to eq(3)
+    end
+  end
+
+  describe '#thought_distribution' do
+    it 'returns a hash of attractor_id => count' do
+      a1 = engine.add_attractor(content: 'a1', domain: :problem)
+      a2 = engine.add_attractor(content: 'a2', domain: :curiosity)
+      engine.add_orbiting_thought(content: 't1', attractor_id: a1.id)
+      engine.add_orbiting_thought(content: 't2', attractor_id: a1.id)
+      engine.add_orbiting_thought(content: 't3', attractor_id: a2.id)
+      distribution = engine.thought_distribution
+      expect(distribution[a1.id]).to eq(2)
+      expect(distribution[a2.id]).to eq(1)
+    end
+  end
+
+  describe '#cognitive_density_map' do
+    it 'returns density labels per attractor' do
+      a = engine.add_attractor(content: 'a', domain: :interest)
+      engine.add_orbiting_thought(content: 't', attractor_id: a.id)
+      density_map = engine.cognitive_density_map
+      expect(density_map[a.id]).to be_a(Symbol)
+    end
+  end
+
+  describe '#gravity_report' do
+    it 'returns a comprehensive report hash' do
+      report = engine.gravity_report
+      expect(report).to include(:total_attractors, :active_attractors, :collapsed_attractors,
+                                :supermassive_count, :total_orbiting, :captured_count,
+                                :escaped_count, :total_captures, :total_escapes, :strongest)
+    end
+
+    it 'counts attractors correctly' do
+      engine.add_attractor(content: 'active', domain: :curiosity)
+      engine.add_attractor(content: 'collapsed', domain: :fear, mass: 0.05)
+      report = engine.gravity_report
+      expect(report[:total_attractors]).to eq(2)
+      expect(report[:collapsed_attractors]).to eq(1)
+      expect(report[:active_attractors]).to eq(1)
+    end
+  end
+end

data/spec/legion/extensions/agentic/inference/gravity/helpers/orbiting_thought_spec.rb

@@ -0,0 +1,103 @@
+# frozen_string_literal: true
+
+RSpec.describe Legion::Extensions::Agentic::Inference::Gravity::Helpers::OrbitingThought do
+  let(:attractor_id) { 'test-attractor-uuid' }
+
+  subject(:thought) do
+    described_class.new(content: 'orbiting idea', attractor_id: attractor_id, orbital_distance: 0.8)
+  end
+
+  describe '#initialize' do
+    it 'assigns a uuid id' do
+      expect(thought.id).to match(/\A[0-9a-f-]{36}\z/)
+    end
+
+    it 'sets content' do
+      expect(thought.content).to eq('orbiting idea')
+    end
+
+    it 'sets attractor_id' do
+      expect(thought.attractor_id).to eq(attractor_id)
+    end
+
+    it 'sets orbital_distance' do
+      expect(thought.orbital_distance).to eq(0.8)
+    end
+
+    it 'sets velocity' do
+      expect(thought.velocity).to eq(0.0)
+    end
+
+    it 'sets created_at' do
+      expect(thought.created_at).to be_a(Time)
+    end
+  end
+
+  describe '#approach!' do
+    it 'decreases orbital distance' do
+      thought.approach!(0.2)
+      expect(thought.orbital_distance).to be_within(0.001).of(0.6)
+    end
+
+    it 'does not go below zero' do
+      t = described_class.new(content: 'x', attractor_id: attractor_id, orbital_distance: 0.05)
+      t.approach!(1.0)
+      expect(t.orbital_distance).to eq(0.0)
+    end
+
+    it 'returns self for chaining' do
+      expect(thought.approach!(0.1)).to eq(thought)
+    end
+  end
+
+  describe '#escape!' do
+    it 'increases orbital distance' do
+      thought.escape!(0.3)
+      expect(thought.orbital_distance).to be_within(0.001).of(1.1)
+    end
+
+    it 'returns self for chaining' do
+      expect(thought.escape!(0.1)).to eq(thought)
+    end
+  end
+
+  describe '#captured?' do
+    it 'returns false for normal orbital distance' do
+      expect(thought.captured?).to be false
+    end
+
+    it 'returns true when distance is below capture radius' do
+      t = described_class.new(content: 'x', attractor_id: attractor_id, orbital_distance: 0.1)
+      expect(t.captured?).to be true
+    end
+  end
+
+  describe '#escaped?' do
+    it 'returns false for normal orbital distance' do
+      expect(thought.escaped?).to be false
+    end
+
+    it 'returns true when distance is above escape radius' do
+      t = described_class.new(content: 'x', attractor_id: attractor_id, orbital_distance: 2.0)
+      expect(t.escaped?).to be true
+    end
+  end
+
+  describe '#orbit_label' do
+    it 'returns a symbol' do
+      expect(thought.orbit_label).to be_a(Symbol)
+    end
+
+    it 'returns :stable for distance 0.8' do
+      expect(thought.orbit_label).to eq(:stable)
+    end
+  end
+
+  describe '#to_h' do
+    it 'returns a hash with expected keys' do
+      h = thought.to_h
+      expect(h).to include(:id, :content, :attractor_id, :orbital_distance, :velocity,
+                           :captured, :escaped, :orbit_label, :created_at)
+    end
+  end
+end

data/spec/legion/extensions/agentic/inference/gravity/runners/gravity_spec.rb

@@ -0,0 +1,159 @@
+# frozen_string_literal: true
+
+require 'legion/extensions/agentic/inference/gravity/client'
+
+RSpec.describe Legion::Extensions::Agentic::Inference::Gravity::Runners::Gravity do
+  let(:client) { Legion::Extensions::Agentic::Inference::Gravity::Client.new }
+  let(:engine) { Legion::Extensions::Agentic::Inference::Gravity::Helpers::GravityEngine.new }
+
+  describe '#create_attractor' do
+    it 'creates an attractor with valid domain' do
+      result = client.create_attractor(content: 'deep worry', domain: :anxiety)
+      expect(result[:success]).to be true
+      expect(result[:attractor][:content]).to eq('deep worry')
+      expect(result[:attractor][:domain]).to eq(:anxiety)
+    end
+
+    it 'returns error for invalid domain' do
+      result = client.create_attractor(content: 'x', domain: :invalid_domain)
+      expect(result[:success]).to be false
+      expect(result[:error]).to eq(:invalid_domain)
+    end
+
+    it 'accepts injected engine via keyword' do
+      result = client.create_attractor(content: 'injected', domain: :problem, engine: engine)
+      expect(result[:success]).to be true
+      expect(engine.attractors.size).to eq(1)
+    end
+
+    it 'includes attractor hash in result' do
+      result = client.create_attractor(content: 'test', domain: :curiosity)
+      attractor = result[:attractor]
+      expect(attractor).to include(:id, :mass, :domain)
+    end
+  end
+
+  describe '#add_thought' do
+    let!(:attractor_id) do
+      client.create_attractor(content: 'center', domain: :problem)[:attractor][:id]
+    end
+
+    it 'adds a thought to an existing attractor' do
+      result = client.add_thought(content: 'orbiting concern', attractor_id: attractor_id)
+      expect(result[:success]).to be true
+      expect(result[:thought][:content]).to eq('orbiting concern')
+    end
+
+    it 'returns error for nonexistent attractor' do
+      result = client.add_thought(content: 'orphan', attractor_id: 'nonexistent-id')
+      expect(result[:success]).to be false
+      expect(result[:error]).to eq(:attractor_not_found)
+    end
+
+    it 'accepts injected engine via keyword' do
+      a = engine.add_attractor(content: 'center', domain: :problem)
+      result = client.add_thought(content: 'orbit', attractor_id: a.id, engine: engine)
+      expect(result[:success]).to be true
+    end
+  end
+
+  describe '#tick_gravity' do
+    it 'returns tick_processed true' do
+      result = client.tick_gravity
+      expect(result[:success]).to be true
+      expect(result[:tick_processed]).to be true
+    end
+
+    it 'returns empty captures and escapes when no thoughts' do
+      result = client.tick_gravity
+      expect(result[:captures]).to eq([])
+      expect(result[:escapes]).to eq([])
+    end
+
+    it 'uses injected engine' do
+      result = client.tick_gravity(engine: engine)
+      expect(result[:success]).to be true
+    end
+  end
+
+  describe '#accrete' do
+    let!(:attractor_id) do
+      client.create_attractor(content: 'growing', domain: :obsession)[:attractor][:id]
+    end
+
+    it 'accretes an attractor' do
+      result = client.accrete(attractor_id: attractor_id)
+      expect(result[:success]).to be true
+      expect(result[:accreted]).to be true
+    end
+
+    it 'returns error for unknown attractor' do
+      result = client.accrete(attractor_id: 'nonexistent')
+      expect(result[:success]).to be false
+    end
+
+    it 'accepts custom amount' do
+      result = client.accrete(attractor_id: attractor_id, amount: 0.5)
+      expect(result[:mass]).to be_within(0.001).of(1.5)
+    end
+  end
+
+  describe '#erode' do
+    let!(:attractor_id) do
+      client.create_attractor(content: 'fading', domain: :fear)[:attractor][:id]
+    end
+
+    it 'erodes an attractor' do
+      result = client.erode(attractor_id: attractor_id)
+      expect(result[:success]).to be true
+      expect(result[:eroded]).to be true
+    end
+
+    it 'returns error for unknown attractor' do
+      result = client.erode(attractor_id: 'nonexistent')
+      expect(result[:success]).to be false
+    end
+  end
+
+  describe '#strongest_attractors' do
+    before do
+      client.create_attractor(content: 'heavy', domain: :obsession, mass: 2.5)
+      client.create_attractor(content: 'light', domain: :curiosity, mass: 0.5)
+    end
+
+    it 'returns attractors sorted by mass' do
+      result = client.strongest_attractors
+      expect(result[:success]).to be true
+      expect(result[:attractors].first[:mass]).to be > result[:attractors].last[:mass]
+    end
+
+    it 'respects the limit' do
+      result = client.strongest_attractors(limit: 1)
+      expect(result[:count]).to eq(1)
+    end
+  end
+
+  describe '#thought_distribution' do
+    it 'returns a distribution hash' do
+      result = client.thought_distribution
+      expect(result[:success]).to be true
+      expect(result[:distribution]).to be_a(Hash)
+    end
+  end
+
+  describe '#cognitive_density_map' do
+    it 'returns a density map hash' do
+      result = client.cognitive_density_map
+      expect(result[:success]).to be true
+      expect(result[:density_map]).to be_a(Hash)
+    end
+  end
+
+  describe '#gravity_report' do
+    it 'returns a full report' do
+      result = client.gravity_report
+      expect(result[:success]).to be true
+      expect(result[:report]).to include(:total_attractors, :total_orbiting)
+    end
+  end
+end

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

@@ -0,0 +1,58 @@
+# frozen_string_literal: true
+
+require 'legion/extensions/agentic/inference/horizon/client'
+
+RSpec.describe Legion::Extensions::Agentic::Inference::Horizon::Client do
+  let(:client) { described_class.new }
+
+  it 'responds to get_horizon' do
+    expect(client).to respond_to(:get_horizon)
+  end
+
+  it 'responds to expand_horizon' do
+    expect(client).to respond_to(:expand_horizon)
+  end
+
+  it 'responds to contract_horizon' do
+    expect(client).to respond_to(:contract_horizon)
+  end
+
+  it 'responds to apply_stress' do
+    expect(client).to respond_to(:apply_stress)
+  end
+
+  it 'responds to relieve_stress' do
+    expect(client).to respond_to(:relieve_stress)
+  end
+
+  it 'responds to add_projection' do
+    expect(client).to respond_to(:add_projection)
+  end
+
+  it 'responds to projections_within_horizon' do
+    expect(client).to respond_to(:projections_within_horizon)
+  end
+
+  it 'responds to beyond_horizon_projections' do
+    expect(client).to respond_to(:beyond_horizon_projections)
+  end
+
+  it 'responds to nearest_projections' do
+    expect(client).to respond_to(:nearest_projections)
+  end
+
+  it 'responds to farthest_projections' do
+    expect(client).to respond_to(:farthest_projections)
+  end
+
+  it 'responds to horizon_status' do
+    expect(client).to respond_to(:horizon_status)
+  end
+
+  it 'each instance has independent state' do
+    c1 = described_class.new
+    c2 = described_class.new
+    c1.expand_horizon(amount: 0.3)
+    expect(c1.get_horizon[:horizon][:current_horizon]).not_to eq(c2.get_horizon[:horizon][:current_horizon])
+  end
+end