lex-agentic-inference 0.1.0

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

@@ -0,0 +1,78 @@
+# frozen_string_literal: true
+
+RSpec.describe Legion::Extensions::Agentic::Inference::RealityTesting::Helpers::Constants do
+  subject(:mod) { described_class }
+
+  describe 'capacity constants' do
+    it 'defines MAX_BELIEFS as 300' do
+      expect(mod::MAX_BELIEFS).to eq(300)
+    end
+
+    it 'defines MAX_EVIDENCE as 500' do
+      expect(mod::MAX_EVIDENCE).to eq(500)
+    end
+  end
+
+  describe 'confidence constants' do
+    it 'defines DEFAULT_CONFIDENCE as 0.5' do
+      expect(mod::DEFAULT_CONFIDENCE).to eq(0.5)
+    end
+
+    it 'defines CONFIDENCE_BOOST as 0.1' do
+      expect(mod::CONFIDENCE_BOOST).to eq(0.1)
+    end
+
+    it 'defines CONFIDENCE_PENALTY as 0.15' do
+      expect(mod::CONFIDENCE_PENALTY).to eq(0.15)
+    end
+
+    it 'defines CONFIDENCE_DECAY as 0.02' do
+      expect(mod::CONFIDENCE_DECAY).to eq(0.02)
+    end
+  end
+
+  describe 'CONFIDENCE_LABELS' do
+    it 'returns :certain for 1.0' do
+      label = mod::CONFIDENCE_LABELS.find { |e| e[:range].cover?(1.0) }[:label]
+      expect(label).to eq(:certain)
+    end
+
+    it 'returns :confident for 0.75' do
+      label = mod::CONFIDENCE_LABELS.find { |e| e[:range].cover?(0.75) }[:label]
+      expect(label).to eq(:confident)
+    end
+
+    it 'returns :tentative for 0.5' do
+      label = mod::CONFIDENCE_LABELS.find { |e| e[:range].cover?(0.5) }[:label]
+      expect(label).to eq(:tentative)
+    end
+
+    it 'returns :doubtful for 0.2' do
+      label = mod::CONFIDENCE_LABELS.find { |e| e[:range].cover?(0.2) }[:label]
+      expect(label).to eq(:doubtful)
+    end
+
+    it 'returns :rejected for 0.05' do
+      label = mod::CONFIDENCE_LABELS.find { |e| e[:range].cover?(0.05) }[:label]
+      expect(label).to eq(:rejected)
+    end
+  end
+
+  describe 'EVIDENCE_TYPES' do
+    it 'includes all four types' do
+      expect(mod::EVIDENCE_TYPES).to eq(%i[confirming disconfirming neutral ambiguous])
+    end
+  end
+
+  describe 'VALIDITY_LABELS' do
+    it 'returns :validated for 0.9' do
+      label = mod::VALIDITY_LABELS.find { |e| e[:range].cover?(0.9) }[:label]
+      expect(label).to eq(:validated)
+    end
+
+    it 'returns :refuted for 0.05' do
+      label = mod::VALIDITY_LABELS.find { |e| e[:range].cover?(0.05) }[:label]
+      expect(label).to eq(:refuted)
+    end
+  end
+end

data/spec/legion/extensions/agentic/inference/reality_testing/helpers/reality_engine_spec.rb

@@ -0,0 +1,191 @@
+# frozen_string_literal: true
+
+RSpec.describe Legion::Extensions::Agentic::Inference::RealityTesting::Helpers::RealityEngine do
+  subject(:engine) { described_class.new }
+
+  describe '#create_belief' do
+    it 'creates a belief and returns created: true' do
+      result = engine.create_belief(claim: 'All humans are mortal')
+      expect(result[:created]).to be true
+    end
+
+    it 'includes the belief hash in the result' do
+      result = engine.create_belief(claim: 'All humans are mortal')
+      expect(result[:belief]).to include(:id, :claim, :confidence)
+    end
+
+    it 'assigns sequential IDs' do
+      r1 = engine.create_belief(claim: 'claim 1')
+      r2 = engine.create_belief(claim: 'claim 2')
+      expect(r1[:belief][:id]).to eq('belief_1')
+      expect(r2[:belief][:id]).to eq('belief_2')
+    end
+
+    it 'respects custom domain' do
+      result = engine.create_belief(claim: 'test', domain: :science)
+      expect(result[:belief][:domain]).to eq(:science)
+    end
+
+    it 'respects custom confidence' do
+      result = engine.create_belief(claim: 'test', confidence: 0.8)
+      expect(result[:belief][:confidence]).to eq(0.8)
+    end
+
+    it 'returns at_capacity when MAX_BELIEFS reached' do
+      stub_const('Legion::Extensions::Agentic::Inference::RealityTesting::Helpers::Constants::MAX_BELIEFS', 2)
+      engine.create_belief(claim: 'one')
+      engine.create_belief(claim: 'two')
+      result = engine.create_belief(claim: 'three')
+      expect(result[:created]).to be false
+      expect(result[:reason]).to eq(:at_capacity)
+    end
+  end
+
+  describe '#test_belief' do
+    let(:belief_id) do
+      engine.create_belief(claim: 'test claim')[:belief][:id]
+    end
+
+    it 'returns tested: true for known belief' do
+      result = engine.test_belief(belief_id: belief_id, evidence_type: :confirming)
+      expect(result[:tested]).to be true
+    end
+
+    it 'returns tested: false for unknown belief' do
+      result = engine.test_belief(belief_id: 'nope', evidence_type: :confirming)
+      expect(result[:tested]).to be false
+      expect(result[:reason]).to eq(:not_found)
+    end
+
+    it 'updates confidence after confirming evidence' do
+      before = engine.test_belief(belief_id: belief_id, evidence_type: :confirming)
+      expect(before[:belief][:confidence]).to be > 0.5
+    end
+
+    it 'updates confidence after disconfirming evidence' do
+      result = engine.test_belief(belief_id: belief_id, evidence_type: :disconfirming)
+      expect(result[:belief][:confidence]).to be < 0.5
+    end
+  end
+
+  describe '#beliefs_needing_testing' do
+    it 'returns beliefs with confidence between 0.3 and 0.7' do
+      engine.create_belief(claim: 'uncertain', confidence: 0.5)
+      engine.create_belief(claim: 'strong', confidence: 0.95)
+      engine.create_belief(claim: 'weak', confidence: 0.05)
+      result = engine.beliefs_needing_testing
+      expect(result.size).to eq(1)
+      expect(result.first.claim).to eq('uncertain')
+    end
+  end
+
+  describe '#strongest_beliefs' do
+    it 'returns beliefs sorted by descending confidence' do
+      engine.create_belief(claim: 'low', confidence: 0.2)
+      engine.create_belief(claim: 'high', confidence: 0.9)
+      engine.create_belief(claim: 'mid', confidence: 0.5)
+      result = engine.strongest_beliefs(limit: 2)
+      expect(result.first.claim).to eq('high')
+      expect(result.size).to eq(2)
+    end
+  end
+
+  describe '#weakest_beliefs' do
+    it 'returns beliefs sorted by ascending confidence' do
+      engine.create_belief(claim: 'low', confidence: 0.2)
+      engine.create_belief(claim: 'high', confidence: 0.9)
+      result = engine.weakest_beliefs(limit: 1)
+      expect(result.first.claim).to eq('low')
+    end
+  end
+
+  describe '#beliefs_by_domain' do
+    it 'filters beliefs by domain' do
+      engine.create_belief(claim: 'science fact', domain: :science)
+      engine.create_belief(claim: 'social fact', domain: :social)
+      result = engine.beliefs_by_domain(domain: :science)
+      expect(result.size).to eq(1)
+      expect(result.first.domain).to eq(:science)
+    end
+  end
+
+  describe '#overall_reality_coherence' do
+    it 'returns 0.0 with no beliefs' do
+      expect(engine.overall_reality_coherence).to eq(0.0)
+    end
+
+    it 'returns 0.5 with one belief and no evidence' do
+      engine.create_belief(claim: 'test')
+      expect(engine.overall_reality_coherence).to eq(0.5)
+    end
+
+    it 'increases toward 1.0 with confirming evidence' do
+      id = engine.create_belief(claim: 'test')[:belief][:id]
+      5.times { engine.test_belief(belief_id: id, evidence_type: :confirming) }
+      expect(engine.overall_reality_coherence).to be > 0.5
+    end
+  end
+
+  describe '#decay_all' do
+    it 'decays all beliefs and returns count' do
+      engine.create_belief(claim: 'b1')
+      engine.create_belief(claim: 'b2')
+      count = engine.decay_all
+      expect(count).to eq(2)
+    end
+
+    it 'reduces confidence of each belief' do
+      id = engine.create_belief(claim: 'test')[:belief][:id]
+      belief_before = engine.instance_variable_get(:@beliefs)[id].confidence
+      engine.decay_all
+      belief_after = engine.instance_variable_get(:@beliefs)[id].confidence
+      expect(belief_after).to be < belief_before
+    end
+  end
+
+  describe '#prune_rejected' do
+    it 'removes beliefs with confidence below 0.1' do
+      id = engine.create_belief(claim: 'very weak', confidence: 0.05)[:belief][:id]
+      engine.create_belief(claim: 'strong', confidence: 0.8)
+      pruned = engine.prune_rejected
+      expect(pruned).to eq(1)
+      expect(engine.instance_variable_get(:@beliefs)).not_to have_key(id)
+    end
+
+    it 'returns 0 when nothing to prune' do
+      engine.create_belief(claim: 'ok', confidence: 0.5)
+      expect(engine.prune_rejected).to eq(0)
+    end
+  end
+
+  describe '#reality_report' do
+    it 'returns a report hash with required keys' do
+      engine.create_belief(claim: 'test')
+      report = engine.reality_report
+      expect(report).to include(:total_beliefs, :coherence, :needing_testing, :domains)
+    end
+
+    it 'reports total_beliefs correctly' do
+      engine.create_belief(claim: 'a')
+      engine.create_belief(claim: 'b')
+      expect(engine.reality_report[:total_beliefs]).to eq(2)
+    end
+  end
+
+  describe '#to_h' do
+    it 'returns belief_count and beliefs array' do
+      engine.create_belief(claim: 'one')
+      h = engine.to_h
+      expect(h[:belief_count]).to eq(1)
+      expect(h[:beliefs]).to be_an(Array)
+    end
+  end
+
+  describe '#size' do
+    it 'returns the number of stored beliefs' do
+      expect(engine.size).to eq(0)
+      engine.create_belief(claim: 'one')
+      expect(engine.size).to eq(1)
+    end
+  end
+end

data/spec/legion/extensions/agentic/inference/reality_testing/runners/reality_testing_spec.rb

@@ -0,0 +1,154 @@
+# frozen_string_literal: true
+
+require 'legion/extensions/agentic/inference/reality_testing/client'
+
+RSpec.describe Legion::Extensions::Agentic::Inference::RealityTesting::Runners::RealityTesting do
+  let(:client) { Legion::Extensions::Agentic::Inference::RealityTesting::Client.new }
+
+  describe '#create_belief' do
+    it 'creates a belief and returns created: true' do
+      result = client.create_belief(claim: 'Water boils at 100C')
+      expect(result[:created]).to be true
+    end
+
+    it 'uses default confidence when not specified' do
+      result = client.create_belief(claim: 'default conf')
+      expect(result[:belief][:confidence]).to eq(0.5)
+    end
+
+    it 'accepts custom confidence' do
+      result = client.create_belief(claim: 'high conf', confidence: 0.9)
+      expect(result[:belief][:confidence]).to eq(0.9)
+    end
+
+    it 'accepts custom domain' do
+      result = client.create_belief(claim: 'domain test', domain: :physics)
+      expect(result[:belief][:domain]).to eq(:physics)
+    end
+  end
+
+  describe '#test_belief' do
+    let(:belief_id) { client.create_belief(claim: 'testable')[:belief][:id] }
+
+    it 'returns tested: true for known belief' do
+      expect(client.test_belief(belief_id: belief_id, evidence_type: :confirming)[:tested]).to be true
+    end
+
+    it 'returns tested: false for unknown belief' do
+      result = client.test_belief(belief_id: 'ghost', evidence_type: :confirming)
+      expect(result[:tested]).to be false
+    end
+
+    it 'accepts string evidence_type' do
+      result = client.test_belief(belief_id: belief_id, evidence_type: 'confirming')
+      expect(result[:tested]).to be true
+    end
+
+    it 'increases confidence with confirming evidence' do
+      result = client.test_belief(belief_id: belief_id, evidence_type: :confirming)
+      expect(result[:belief][:confidence]).to be > 0.5
+    end
+
+    it 'decreases confidence with disconfirming evidence' do
+      result = client.test_belief(belief_id: belief_id, evidence_type: :disconfirming)
+      expect(result[:belief][:confidence]).to be < 0.5
+    end
+  end
+
+  describe '#get_belief' do
+    it 'returns found: true for existing belief' do
+      id = client.create_belief(claim: 'fetch me')[:belief][:id]
+      result = client.get_belief(belief_id: id)
+      expect(result[:found]).to be true
+      expect(result[:belief][:claim]).to eq('fetch me')
+    end
+
+    it 'returns found: false for missing belief' do
+      result = client.get_belief(belief_id: 'missing')
+      expect(result[:found]).to be false
+    end
+  end
+
+  describe '#beliefs_needing_testing' do
+    it 'returns count and beliefs array' do
+      client.create_belief(claim: 'uncertain', confidence: 0.5)
+      result = client.beliefs_needing_testing
+      expect(result).to include(:count, :beliefs)
+      expect(result[:count]).to be >= 1
+    end
+  end
+
+  describe '#strongest_beliefs' do
+    it 'returns highest-confidence beliefs' do
+      client.create_belief(claim: 'weak', confidence: 0.2)
+      client.create_belief(claim: 'strong', confidence: 0.9)
+      result = client.strongest_beliefs(limit: 1)
+      expect(result[:beliefs].first[:claim]).to eq('strong')
+    end
+  end
+
+  describe '#weakest_beliefs' do
+    it 'returns lowest-confidence beliefs' do
+      client.create_belief(claim: 'weak', confidence: 0.2)
+      client.create_belief(claim: 'strong', confidence: 0.9)
+      result = client.weakest_beliefs(limit: 1)
+      expect(result[:beliefs].first[:claim]).to eq('weak')
+    end
+  end
+
+  describe '#beliefs_by_domain' do
+    it 'filters beliefs by domain' do
+      client.create_belief(claim: 'logic rule', domain: :logic)
+      client.create_belief(claim: 'social norm', domain: :social)
+      result = client.beliefs_by_domain(domain: :logic)
+      expect(result[:domain]).to eq(:logic)
+      expect(result[:count]).to eq(1)
+    end
+  end
+
+  describe '#overall_coherence' do
+    it 'returns a coherence value between 0 and 1' do
+      client.create_belief(claim: 'test')
+      result = client.overall_coherence
+      expect(result[:coherence]).to be_between(0.0, 1.0)
+    end
+  end
+
+  describe '#decay_beliefs' do
+    it 'returns the number of decayed beliefs' do
+      client.create_belief(claim: 'one')
+      result = client.decay_beliefs
+      expect(result[:decayed]).to eq(1)
+    end
+  end
+
+  describe '#prune_rejected_beliefs' do
+    it 'returns count of pruned beliefs' do
+      client.create_belief(claim: 'dead', confidence: 0.05)
+      result = client.prune_rejected_beliefs
+      expect(result[:pruned]).to eq(1)
+    end
+
+    it 'returns 0 when nothing pruned' do
+      client.create_belief(claim: 'alive', confidence: 0.8)
+      expect(client.prune_rejected_beliefs[:pruned]).to eq(0)
+    end
+  end
+
+  describe '#reality_report' do
+    it 'returns a full report hash' do
+      client.create_belief(claim: 'fact')
+      report = client.reality_report
+      expect(report).to include(:total_beliefs, :coherence, :needing_testing, :domains)
+    end
+  end
+
+  describe '#reality_status' do
+    it 'returns total_beliefs, coherence, needing_testing' do
+      client.create_belief(claim: 'status test')
+      result = client.reality_status
+      expect(result).to include(:total_beliefs, :coherence, :needing_testing)
+      expect(result[:total_beliefs]).to eq(1)
+    end
+  end
+end

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

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+RSpec.describe Legion::Extensions::Agentic::Inference::Schema::Client do
+  describe '#initialize' do
+    it 'creates a default world model' do
+      client = described_class.new
+      expect(client.world_model).to be_a(Legion::Extensions::Agentic::Inference::Schema::Helpers::WorldModel)
+    end
+
+    it 'accepts an injected world model' do
+      wm = Legion::Extensions::Agentic::Inference::Schema::Helpers::WorldModel.new
+      client = described_class.new(world_model: wm)
+      expect(client.world_model).to equal(wm)
+    end
+
+    it 'ignores unknown keyword arguments' do
+      expect { described_class.new(unknown: true) }.not_to raise_error
+    end
+  end
+
+  describe 'runner integration' do
+    subject(:client) { described_class.new }
+
+    it 'responds to learn_relation' do
+      expect(client).to respond_to(:learn_relation)
+    end
+
+    it 'responds to explain' do
+      expect(client).to respond_to(:explain)
+    end
+
+    it 'responds to counterfactual' do
+      expect(client).to respond_to(:counterfactual)
+    end
+
+    it 'can perform a full schema workflow' do
+      client.learn_relation(cause: :rain, effect: :wet_ground, relation_type: :causes, confidence: 0.8)
+      client.learn_relation(cause: :wet_ground, effect: :slip, relation_type: :causes, confidence: 0.7)
+      client.learn_relation(cause: :slip, effect: :injury, relation_type: :causes, confidence: 0.6)
+
+      explanation = client.explain(outcome: :injury)
+      expect(explanation[:chain]).not_to be_empty
+
+      counterfactual = client.counterfactual(cause: :rain)
+      expect(counterfactual[:affected].size).to be >= 2
+
+      stats = client.schema_stats
+      expect(stats[:relation_count]).to eq(3)
+    end
+  end
+end

data/spec/legion/extensions/agentic/inference/schema/helpers/causal_relation_spec.rb

@@ -0,0 +1,108 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+RSpec.describe Legion::Extensions::Agentic::Inference::Schema::Helpers::CausalRelation do
+  subject(:relation) { described_class.new(cause: :rain, effect: :wet_ground, relation_type: :causes, confidence: 0.6) }
+
+  describe '#initialize' do
+    it 'sets cause and effect' do
+      expect(relation.cause).to eq(:rain)
+      expect(relation.effect).to eq(:wet_ground)
+    end
+
+    it 'sets relation type' do
+      expect(relation.relation_type).to eq(:causes)
+    end
+
+    it 'clamps confidence to 0..1' do
+      rel = described_class.new(cause: :a, effect: :b, relation_type: :causes, confidence: 5.0)
+      expect(rel.confidence).to eq(1.0)
+    end
+
+    it 'generates a UUID' do
+      expect(relation.id).to match(/\A[0-9a-f-]{36}\z/)
+    end
+
+    it 'starts with evidence count of 1' do
+      expect(relation.evidence_count).to eq(1)
+    end
+  end
+
+  describe '#reinforce' do
+    it 'increases confidence' do
+      initial = relation.confidence
+      relation.reinforce
+      expect(relation.confidence).to be > initial
+    end
+
+    it 'increments evidence count' do
+      relation.reinforce
+      expect(relation.evidence_count).to eq(2)
+    end
+
+    it 'caps confidence at 1.0' do
+      20.times { relation.reinforce(0.1) }
+      expect(relation.confidence).to eq(1.0)
+    end
+  end
+
+  describe '#weaken' do
+    it 'decreases confidence' do
+      initial = relation.confidence
+      relation.weaken
+      expect(relation.confidence).to be < initial
+    end
+
+    it 'floors confidence at 0.0' do
+      20.times { relation.weaken(0.1) }
+      expect(relation.confidence).to eq(0.0)
+    end
+  end
+
+  describe '#decay' do
+    it 'reduces confidence by DECAY_RATE' do
+      initial = relation.confidence
+      relation.decay
+      expect(relation.confidence).to be_within(0.001).of(initial - Legion::Extensions::Agentic::Inference::Schema::Helpers::Constants::DECAY_RATE)
+    end
+  end
+
+  describe '#established?' do
+    it 'returns true when confidence >= established threshold' do
+      rel = described_class.new(cause: :a, effect: :b, relation_type: :causes, confidence: 0.95)
+      expect(rel.established?).to be true
+    end
+
+    it 'returns false when confidence is moderate' do
+      expect(relation.established?).to be false
+    end
+  end
+
+  describe '#speculative?' do
+    it 'returns true when confidence is very low' do
+      rel = described_class.new(cause: :a, effect: :b, relation_type: :causes, confidence: 0.05)
+      expect(rel.speculative?).to be true
+    end
+  end
+
+  describe '#prunable?' do
+    it 'returns true when confidence below PRUNE_THRESHOLD' do
+      rel = described_class.new(cause: :a, effect: :b, relation_type: :causes, confidence: 0.05)
+      expect(rel.prunable?).to be true
+    end
+  end
+
+  describe '#to_h' do
+    it 'returns a hash with expected keys' do
+      result = relation.to_h
+      expect(result).to have_key(:id)
+      expect(result).to have_key(:cause)
+      expect(result).to have_key(:effect)
+      expect(result).to have_key(:relation_type)
+      expect(result).to have_key(:confidence)
+      expect(result).to have_key(:evidence_count)
+      expect(result).to have_key(:established)
+    end
+  end
+end

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

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+RSpec.describe Legion::Extensions::Agentic::Inference::Schema::Helpers::Constants do
+  describe 'RELATION_TYPES' do
+    it 'contains 6 types' do
+      expect(described_class::RELATION_TYPES.size).to eq(6)
+    end
+
+    it 'is frozen' do
+      expect(described_class::RELATION_TYPES).to be_frozen
+    end
+
+    %i[causes prevents enables requires correlates contradicts].each do |type|
+      it "includes #{type}" do
+        expect(described_class::RELATION_TYPES).to include(type)
+      end
+    end
+  end
+
+  describe 'CONFIDENCE_LEVELS' do
+    it 'is ordered highest to lowest' do
+      values = described_class::CONFIDENCE_LEVELS.values
+      expect(values).to eq(values.sort.reverse)
+    end
+  end
+
+  describe 'scalar constants' do
+    it 'has SCHEMA_ALPHA between 0 and 1' do
+      expect(described_class::SCHEMA_ALPHA).to be_between(0.0, 1.0)
+    end
+
+    it 'has positive MAX_SCHEMAS' do
+      expect(described_class::MAX_SCHEMAS).to be > 0
+    end
+
+    it 'has REINFORCEMENT_BONUS between 0 and 1' do
+      expect(described_class::REINFORCEMENT_BONUS).to be_between(0.0, 1.0)
+    end
+
+    it 'has CONTRADICTION_PENALTY between 0 and 1' do
+      expect(described_class::CONTRADICTION_PENALTY).to be_between(0.0, 1.0)
+    end
+
+    it 'has DECAY_RATE between 0 and 1' do
+      expect(described_class::DECAY_RATE).to be_between(0.0, 1.0)
+    end
+
+    it 'has PRUNE_THRESHOLD between 0 and 1' do
+      expect(described_class::PRUNE_THRESHOLD).to be_between(0.0, 1.0)
+    end
+  end
+end