lex-agentic-inference 0.1.0

data/spec/legion/extensions/agentic/inference/enactive_cognition/runners/enactive_cognition_spec.rb

@@ -0,0 +1,214 @@
+# frozen_string_literal: true
+
+require 'legion/extensions/agentic/inference/enactive_cognition/client'
+
+RSpec.describe Legion::Extensions::Agentic::Inference::EnactiveCognition::Runners::EnactiveCognition do
+  let(:client) { Legion::Extensions::Agentic::Inference::EnactiveCognition::Client.new }
+
+  def make_coupling(action: 'press', perception: 'click', domain: 'motor', loop_type: :sensorimotor)
+    client.create_sensorimotor_coupling(
+      action:     action,
+      perception: perception,
+      domain:     domain,
+      loop_type:  loop_type
+    )
+  end
+
+  describe '#create_sensorimotor_coupling' do
+    it 'returns success: true' do
+      result = make_coupling
+      expect(result[:success]).to be true
+    end
+
+    it 'includes coupling hash with uuid id' do
+      result = make_coupling
+      expect(result[:coupling][:id]).to match(/\A[0-9a-f-]{36}\z/)
+    end
+
+    it 'reflects the given action and perception' do
+      result = make_coupling(action: 'push', perception: 'moved')
+      expect(result[:coupling][:action]).to eq('push')
+      expect(result[:coupling][:perception]).to eq('moved')
+    end
+
+    it 'accepts string loop_type and converts to symbol' do
+      result = client.create_sensorimotor_coupling(
+        action:     'x',
+        perception: 'y',
+        domain:     'z',
+        loop_type:  'cognitive'
+      )
+      expect(result[:coupling][:loop_type]).to eq(:cognitive)
+    end
+  end
+
+  describe '#execute_enactive_action' do
+    let(:coupling_id) { make_coupling[:coupling][:id] }
+
+    it 'returns success: true on matching perception' do
+      result = client.execute_enactive_action(coupling_id: coupling_id, actual_perception: 'click')
+      expect(result[:success]).to be true
+      expect(result[:match]).to be true
+    end
+
+    it 'returns success: true on mismatching perception' do
+      result = client.execute_enactive_action(coupling_id: coupling_id, actual_perception: 'silence')
+      expect(result[:success]).to be true
+      expect(result[:match]).to be false
+    end
+
+    it 'returns success: false for unknown coupling_id' do
+      result = client.execute_enactive_action(coupling_id: 'bad-id', actual_perception: 'click')
+      expect(result[:success]).to be false
+    end
+
+    it 'includes coupling_label in result' do
+      result = client.execute_enactive_action(coupling_id: coupling_id, actual_perception: 'click')
+      expect(result[:coupling_label]).to be_a(Symbol)
+    end
+  end
+
+  describe '#adapt_sensorimotor_coupling' do
+    let(:coupling_id) { make_coupling[:coupling][:id] }
+
+    it 'returns success: true' do
+      result = client.adapt_sensorimotor_coupling(coupling_id: coupling_id, new_perception: 'soft_click')
+      expect(result[:success]).to be true
+    end
+
+    it 'returns new_perception in result' do
+      result = client.adapt_sensorimotor_coupling(coupling_id: coupling_id, new_perception: 'soft_click')
+      expect(result[:new_perception]).to eq('soft_click')
+    end
+
+    it 'returns success: false for missing coupling' do
+      result = client.adapt_sensorimotor_coupling(coupling_id: 'missing', new_perception: 'x')
+      expect(result[:success]).to be false
+    end
+  end
+
+  describe '#find_action_for_perception' do
+    it 'returns found: false when nothing is coupled' do
+      result = client.find_action_for_perception(perception: 'click')
+      expect(result[:found]).to be false
+    end
+
+    it 'returns found: true when a coupled loop matches' do
+      id = make_coupling[:coupling][:id]
+      5.times { client.execute_enactive_action(coupling_id: id, actual_perception: 'click') }
+      result = client.find_action_for_perception(perception: 'click')
+      # may or may not be coupled depending on starting strength + reinforcement
+      if result[:found]
+        expect(result[:action]).to eq('press')
+      else
+        expect(result[:found]).to be false
+      end
+    end
+  end
+
+  describe '#coupled_sensorimotor_loops' do
+    it 'returns loops and count' do
+      result = client.coupled_sensorimotor_loops
+      expect(result).to include(:loops, :count)
+      expect(result[:loops]).to be_an(Array)
+    end
+
+    it 'count is zero initially' do
+      expect(client.coupled_sensorimotor_loops[:count]).to eq(0)
+    end
+  end
+
+  describe '#domain_couplings' do
+    before { make_coupling(domain: 'motor') }
+
+    it 'returns loops in the domain' do
+      result = client.domain_couplings(domain: 'motor')
+      expect(result[:domain]).to eq('motor')
+      expect(result[:count]).to eq(1)
+    end
+
+    it 'returns zero for unknown domain' do
+      result = client.domain_couplings(domain: 'unknown')
+      expect(result[:count]).to eq(0)
+    end
+  end
+
+  describe '#strongest_couplings' do
+    before { 3.times { |i| make_coupling(action: "act#{i}", perception: "per#{i}", domain: 'dom') } }
+
+    it 'returns loops array' do
+      result = client.strongest_couplings(limit: 2)
+      expect(result[:loops].size).to be <= 2
+    end
+
+    it 'uses default limit of 5' do
+      result = client.strongest_couplings
+      expect(result[:loops].size).to be <= 5
+    end
+  end
+
+  describe '#overall_enactive_coupling' do
+    it 'returns overall_coupling and coupling_label' do
+      result = client.overall_enactive_coupling
+      expect(result).to include(:overall_coupling, :coupling_label)
+    end
+
+    it 'returns 0.0 when no couplings exist' do
+      expect(client.overall_enactive_coupling[:overall_coupling]).to eq(0.0)
+    end
+
+    it 'returns :decoupled label when no couplings' do
+      expect(client.overall_enactive_coupling[:coupling_label]).to eq(:decoupled)
+    end
+
+    it 'returns :forming label at default strength' do
+      make_coupling
+      result = client.overall_enactive_coupling
+      expect(result[:coupling_label]).to eq(:forming)
+    end
+  end
+
+  describe '#update_enactive_cognition' do
+    before { make_coupling }
+
+    it 'returns success: true' do
+      result = client.update_enactive_cognition
+      expect(result[:success]).to be true
+    end
+
+    it 'decays couplings when decay: true' do
+      before_strength = client.strongest_couplings(limit: 1)[:loops].first[:coupling_strength]
+      client.update_enactive_cognition(decay: true)
+      after_strength = client.strongest_couplings(limit: 1)[:loops].first[:coupling_strength]
+      expect(after_strength).to be < before_strength
+    end
+
+    it 'reflects coupling_count in result' do
+      result = client.update_enactive_cognition
+      expect(result[:coupling_count]).to be >= 1
+    end
+  end
+
+  describe '#enactive_cognition_stats' do
+    it 'returns success: true' do
+      result = client.enactive_cognition_stats
+      expect(result[:success]).to be true
+    end
+
+    it 'includes stats hash' do
+      result = client.enactive_cognition_stats
+      expect(result[:stats]).to include(:coupling_count, :coupled_count, :overall_coupling)
+    end
+
+    it 'reports zero coupling_count when empty' do
+      result = client.enactive_cognition_stats
+      expect(result[:stats][:coupling_count]).to eq(0)
+    end
+
+    it 'increments coupling_count after creating a coupling' do
+      make_coupling
+      result = client.enactive_cognition_stats
+      expect(result[:stats][:coupling_count]).to eq(1)
+    end
+  end
+end

data/spec/legion/extensions/agentic/inference/expectation_violation/expectation_violation_spec.rb

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

data/spec/legion/extensions/agentic/inference/expectation_violation/helpers/expectation_spec.rb

@@ -0,0 +1,102 @@
+# frozen_string_literal: true
+
+RSpec.describe Legion::Extensions::Agentic::Inference::ExpectationViolation::Helpers::Expectation do
+  subject(:expectation) { described_class.new(context: 'response_time', domain: :performance) }
+
+  describe '#initialize' do
+    it 'creates with defaults' do
+      expect(expectation.context).to eq('response_time')
+      expect(expectation.domain).to eq(:performance)
+      expect(expectation.expected_value).to eq(0.5)
+      expect(expectation.tolerance).to eq(0.2)
+      expect(expectation.violation_count).to eq(0)
+    end
+
+    it 'generates a uuid' do
+      expect(expectation.id).to match(/\A[0-9a-f-]{36}\z/)
+    end
+
+    it 'clamps expected value' do
+      clamped = described_class.new(context: 'x', domain: :d, expected_value: 5.0)
+      expect(clamped.expected_value).to eq(1.0)
+    end
+  end
+
+  describe '#evaluate' do
+    context 'when within tolerance' do
+      it 'returns not violated' do
+        result = expectation.evaluate(actual_value: 0.6)
+        expect(result[:violated]).to be false
+        expect(result[:type]).to eq(:neutral)
+      end
+    end
+
+    context 'when positive violation' do
+      it 'detects positive violation' do
+        result = expectation.evaluate(actual_value: 0.9)
+        expect(result[:violated]).to be true
+        expect(result[:type]).to eq(:positive)
+        expect(result[:arousal]).to be > 0
+      end
+    end
+
+    context 'when negative violation' do
+      it 'detects negative violation' do
+        result = expectation.evaluate(actual_value: 0.1)
+        expect(result[:violated]).to be true
+        expect(result[:type]).to eq(:negative)
+        expect(result[:arousal]).to be > 0
+      end
+    end
+
+    it 'increments violation count on violation' do
+      expectation.evaluate(actual_value: 0.9)
+      expect(expectation.violation_count).to eq(1)
+    end
+
+    it 'does not increment on non-violation' do
+      expectation.evaluate(actual_value: 0.5)
+      expect(expectation.violation_count).to eq(0)
+    end
+
+    it 'returns arousal label' do
+      result = expectation.evaluate(actual_value: 0.95)
+      expect(result[:arousal_label]).to be_a(Symbol)
+    end
+  end
+
+  describe '#adapt!' do
+    it 'moves expected value toward actual' do
+      expectation.adapt!(actual_value: 0.9)
+      expect(expectation.expected_value).to be > 0.5
+      expect(expectation.adaptation_count).to eq(1)
+    end
+
+    it 'moves gradually not instantly' do
+      expectation.adapt!(actual_value: 1.0)
+      expect(expectation.expected_value).to be < 1.0
+    end
+  end
+
+  describe '#violation_label' do
+    it 'returns label for positive deviation' do
+      expect(expectation.violation_label(0.5)).to eq(:positive)
+    end
+
+    it 'returns label for negative deviation' do
+      expect(expectation.violation_label(-0.5)).to eq(:negative)
+    end
+
+    it 'returns neutral for small deviation' do
+      expect(expectation.violation_label(0.1)).to eq(:neutral)
+    end
+  end
+
+  describe '#to_h' do
+    it 'returns complete hash' do
+      hash = expectation.to_h
+      expect(hash).to include(:id, :context, :domain, :expected_value, :tolerance,
+                              :violation_count, :adaptation_count)
+    end
+  end
+end

data/spec/legion/extensions/agentic/inference/expectation_violation/helpers/violation_engine_spec.rb

@@ -0,0 +1,121 @@
+# frozen_string_literal: true
+
+RSpec.describe Legion::Extensions::Agentic::Inference::ExpectationViolation::Helpers::ViolationEngine do
+  subject(:engine) { described_class.new }
+
+  let(:exp) { engine.create_expectation(context: 'response', domain: :perf) }
+
+  describe '#create_expectation' do
+    it 'creates and stores an expectation' do
+      result = engine.create_expectation(context: 'latency', domain: :network)
+      expect(result).to be_a(Legion::Extensions::Agentic::Inference::ExpectationViolation::Helpers::Expectation)
+    end
+
+    it 'records history' do
+      engine.create_expectation(context: 'x', domain: :d)
+      expect(engine.history.last[:event]).to eq(:created)
+    end
+  end
+
+  describe '#evaluate_against' do
+    it 'evaluates within tolerance' do
+      result = engine.evaluate_against(expectation_id: exp.id, actual_value: 0.5)
+      expect(result[:success]).to be true
+      expect(result[:violated]).to be false
+    end
+
+    it 'detects positive violation' do
+      result = engine.evaluate_against(expectation_id: exp.id, actual_value: 0.9)
+      expect(result[:violated]).to be true
+      expect(result[:type]).to eq(:positive)
+    end
+
+    it 'detects negative violation' do
+      result = engine.evaluate_against(expectation_id: exp.id, actual_value: 0.1)
+      expect(result[:violated]).to be true
+      expect(result[:type]).to eq(:negative)
+    end
+
+    it 'returns not_found for missing' do
+      result = engine.evaluate_against(expectation_id: 'missing', actual_value: 0.5)
+      expect(result[:success]).to be false
+    end
+
+    it 'records violations' do
+      engine.evaluate_against(expectation_id: exp.id, actual_value: 0.9)
+      expect(engine.recent_violations.size).to eq(1)
+    end
+  end
+
+  describe '#adapt_expectation' do
+    it 'adapts the expected value' do
+      result = engine.adapt_expectation(expectation_id: exp.id, actual_value: 0.8)
+      expect(result[:success]).to be true
+      expect(result[:new_expected]).to be > 0.5
+    end
+
+    it 'returns not_found for missing' do
+      result = engine.adapt_expectation(expectation_id: 'missing', actual_value: 0.8)
+      expect(result[:success]).to be false
+    end
+  end
+
+  describe '#recent_violations' do
+    it 'returns recent violations' do
+      engine.evaluate_against(expectation_id: exp.id, actual_value: 0.9)
+      engine.evaluate_against(expectation_id: exp.id, actual_value: 0.1)
+      expect(engine.recent_violations(limit: 5).size).to eq(2)
+    end
+  end
+
+  describe '#violations_by_type' do
+    it 'filters by type' do
+      engine.evaluate_against(expectation_id: exp.id, actual_value: 0.9)
+      engine.evaluate_against(expectation_id: exp.id, actual_value: 0.1)
+      expect(engine.violations_by_type(type: :positive).size).to eq(1)
+    end
+  end
+
+  describe '#expectations_by_domain' do
+    it 'filters by domain' do
+      engine.create_expectation(context: 'a', domain: :net)
+      engine.create_expectation(context: 'b', domain: :cpu)
+      expect(engine.expectations_by_domain(domain: :net).size).to eq(1)
+    end
+  end
+
+  describe '#most_violated' do
+    it 'returns expectations sorted by violation count' do
+      exp1 = engine.create_expectation(context: 'a', domain: :d)
+      engine.create_expectation(context: 'b', domain: :d)
+      3.times { engine.evaluate_against(expectation_id: exp1.id, actual_value: 0.9) }
+      result = engine.most_violated(limit: 2)
+      expect(result.first).to eq(exp1)
+    end
+  end
+
+  describe '#violation_rate' do
+    it 'computes rate of violations per evaluation' do
+      engine.evaluate_against(expectation_id: exp.id, actual_value: 0.9)
+      engine.evaluate_against(expectation_id: exp.id, actual_value: 0.5)
+      expect(engine.violation_rate).to be_a(Float)
+    end
+  end
+
+  describe '#positive_violation_ratio' do
+    it 'computes ratio of positive violations' do
+      engine.evaluate_against(expectation_id: exp.id, actual_value: 0.9)
+      engine.evaluate_against(expectation_id: exp.id, actual_value: 0.1)
+      expect(engine.positive_violation_ratio).to eq(0.5)
+    end
+  end
+
+  describe '#to_h' do
+    it 'returns stats hash' do
+      exp
+      stats = engine.to_h
+      expect(stats).to include(:total_expectations, :total_violations,
+                               :violation_rate, :positive_ratio, :history_count)
+    end
+  end
+end

data/spec/legion/extensions/agentic/inference/expectation_violation/runners/expectation_violation_spec.rb

@@ -0,0 +1,59 @@
+# frozen_string_literal: true
+
+RSpec.describe Legion::Extensions::Agentic::Inference::ExpectationViolation::Runners::ExpectationViolation do
+  let(:client) { Legion::Extensions::Agentic::Inference::ExpectationViolation::Helpers::Client.new }
+
+  describe '#create_expectation' do
+    it 'creates an expectation' do
+      result = client.create_expectation(context: 'test', domain: :perf)
+      expect(result[:success]).to be true
+      expect(result[:expectation][:context]).to eq('test')
+    end
+  end
+
+  describe '#evaluate_expectation' do
+    it 'evaluates against expectation' do
+      created = client.create_expectation(context: 'x', domain: :d)
+      result = client.evaluate_expectation(expectation_id: created[:expectation][:id], actual_value: 0.9)
+      expect(result[:success]).to be true
+      expect(result[:violated]).to be true
+    end
+  end
+
+  describe '#adapt_expectation_value' do
+    it 'adapts the expected value' do
+      created = client.create_expectation(context: 'x', domain: :d)
+      result = client.adapt_expectation_value(expectation_id: created[:expectation][:id], actual_value: 0.8)
+      expect(result[:success]).to be true
+    end
+  end
+
+  describe '#recent_violations_report' do
+    it 'returns recent violations' do
+      result = client.recent_violations_report(limit: 5)
+      expect(result[:success]).to be true
+    end
+  end
+
+  describe '#violations_by_type_report' do
+    it 'filters by type' do
+      result = client.violations_by_type_report(type: :positive)
+      expect(result[:success]).to be true
+    end
+  end
+
+  describe '#most_violated_expectations' do
+    it 'returns most violated' do
+      result = client.most_violated_expectations(limit: 3)
+      expect(result[:success]).to be true
+    end
+  end
+
+  describe '#expectation_violation_stats' do
+    it 'returns stats' do
+      result = client.expectation_violation_stats
+      expect(result[:success]).to be true
+      expect(result).to include(:total_expectations, :total_violations)
+    end
+  end
+end

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

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+RSpec.describe Legion::Extensions::Agentic::Inference::FreeEnergy::Client do
+  subject(:client) { described_class.new }
+
+  describe '#add_generative_belief' do
+    it 'delegates to runner' do
+      result = client.add_generative_belief(content: 'test model')
+      expect(result[:success]).to be true
+    end
+  end
+
+  describe '#observe_outcome' do
+    it 'observes and computes error' do
+      belief = client.add_generative_belief(content: 'model', prediction: { v: 0.5 })
+      result = client.observe_outcome(belief_id: belief[:belief_id], observation: { v: 0.5 })
+      expect(result[:prediction_error]).to eq(0.0)
+    end
+  end
+
+  describe '#minimize_free_energy' do
+    it 'performs perceptual minimization' do
+      belief = client.add_generative_belief(content: 'model', prediction: { v: 0.3 })
+      client.observe_outcome(belief_id: belief[:belief_id], observation: { v: 0.9 })
+      result = client.minimize_free_energy(belief_id: belief[:belief_id], mode: :perceptual)
+      expect(result[:success]).to be true
+    end
+  end
+
+  describe '#free_energy_stats' do
+    it 'returns stats' do
+      result = client.free_energy_stats
+      expect(result[:success]).to be true
+      expect(result[:belief_count]).to eq(0)
+    end
+  end
+
+  describe 'with injected engine' do
+    it 'uses the provided engine' do
+      engine = Legion::Extensions::Agentic::Inference::FreeEnergy::Helpers::FreeEnergyEngine.new
+      engine.add_belief(content: 'preloaded')
+      custom_client = described_class.new(engine: engine)
+      expect(custom_client.free_energy_stats[:belief_count]).to eq(1)
+    end
+  end
+end