lex-agentic-inference 0.1.0

data/spec/legion/extensions/agentic/inference/causal_reasoning/helpers/causal_graph_spec.rb

@@ -0,0 +1,259 @@
+# frozen_string_literal: true
+
+require 'legion/extensions/agentic/inference/causal_reasoning/client'
+
+RSpec.describe Legion::Extensions::Agentic::Inference::CausalReasoning::Helpers::CausalGraph do
+  subject(:graph) { described_class.new }
+
+  let(:const) { Legion::Extensions::Agentic::Inference::CausalReasoning::Helpers::Constants }
+
+  def add_rain_wet(grph = graph)
+    grph.add_edge(cause: :rain, effect: :wet_grass, edge_type: :causes, domain: :weather)
+  end
+
+  describe '#add_variable' do
+    it 'registers a new variable and returns it' do
+      var = graph.add_variable(name: :temperature, domain: :weather)
+      expect(var[:name]).to eq(:temperature)
+      expect(var[:domain]).to eq(:weather)
+    end
+
+    it 'returns nil for a duplicate variable name' do
+      graph.add_variable(name: :temperature, domain: :weather)
+      result = graph.add_variable(name: :temperature, domain: :weather)
+      expect(result).to be_nil
+    end
+  end
+
+  describe '#add_edge' do
+    it 'creates and returns a CausalEdge' do
+      edge = add_rain_wet
+      expect(edge).to be_a(Legion::Extensions::Agentic::Inference::CausalReasoning::Helpers::CausalEdge)
+    end
+
+    it 'auto-registers both cause and effect as variables' do
+      add_rain_wet
+      expect(graph.to_h[:variables]).to eq(2)
+    end
+
+    it 'returns nil for unknown edge_type' do
+      result = graph.add_edge(cause: :a, effect: :b, edge_type: :unknown_type)
+      expect(result).to be_nil
+    end
+
+    it 'accepts all valid EDGE_TYPES' do
+      const::EDGE_TYPES.each_with_index do |type, idx|
+        result = graph.add_edge(cause: :"cause_#{idx}", effect: :"effect_#{idx}", edge_type: type)
+        expect(result).not_to be_nil
+      end
+    end
+  end
+
+  describe '#remove_edge' do
+    it 'removes an existing edge and returns it' do
+      edge    = add_rain_wet
+      removed = graph.remove_edge(edge_id: edge.id)
+      expect(removed.id).to eq(edge.id)
+      expect(graph.to_h[:edges]).to eq(0)
+    end
+
+    it 'returns nil for unknown edge_id' do
+      expect(graph.remove_edge(edge_id: 'nonexistent')).to be_nil
+    end
+  end
+
+  describe '#causes_of' do
+    it 'returns edges where the variable is the effect' do
+      add_rain_wet
+      causes = graph.causes_of(variable: :wet_grass)
+      expect(causes.size).to eq(1)
+      expect(causes.first.cause).to eq(:rain)
+    end
+
+    it 'returns empty array for variable with no causes' do
+      expect(graph.causes_of(variable: :rain)).to be_empty
+    end
+  end
+
+  describe '#effects_of' do
+    it 'returns edges where the variable is the cause' do
+      add_rain_wet
+      effects = graph.effects_of(variable: :rain)
+      expect(effects.size).to eq(1)
+      expect(effects.first.effect).to eq(:wet_grass)
+    end
+
+    it 'returns empty array for unknown variable' do
+      expect(graph.effects_of(variable: :unknown)).to be_empty
+    end
+  end
+
+  describe '#causal_chain' do
+    before do
+      graph.add_edge(cause: :rain, effect: :wet_grass, edge_type: :causes)
+      graph.add_edge(cause: :wet_grass, effect: :slippery_path, edge_type: :causes)
+    end
+
+    it 'finds a direct path between connected variables' do
+      paths = graph.causal_chain(from: :rain, to: :slippery_path)
+      expect(paths).not_to be_empty
+      expect(paths.first).to eq(%i[rain wet_grass slippery_path])
+    end
+
+    it 'returns empty array when no path exists' do
+      paths = graph.causal_chain(from: :slippery_path, to: :rain)
+      expect(paths).to be_empty
+    end
+
+    it 'returns empty array when from == to' do
+      paths = graph.causal_chain(from: :rain, to: :rain)
+      expect(paths).to be_empty
+    end
+
+    it 'respects max_depth' do
+      graph.add_edge(cause: :slippery_path, effect: :injury, edge_type: :causes)
+      graph.add_edge(cause: :injury, effect: :hospital_visit, edge_type: :causes)
+      paths = graph.causal_chain(from: :rain, to: :hospital_visit, max_depth: 2)
+      expect(paths).to be_empty
+    end
+  end
+
+  describe '#intervene' do
+    before do
+      graph.add_edge(cause: :smoking, effect: :cancer, edge_type: :causes)
+      graph.add_edge(cause: :cancer, effect: :death, edge_type: :causes)
+    end
+
+    it 'returns the intervention variable and value' do
+      result = graph.intervene(variable: :smoking, value: true)
+      expect(result[:intervention]).to eq(:smoking)
+      expect(result[:value]).to be true
+    end
+
+    it 'lists all downstream effects' do
+      result = graph.intervene(variable: :smoking, value: true)
+      variables = result[:downstream_effects].map { |e| e[:variable] }
+      expect(variables).to include(:cancer, :death)
+    end
+
+    it 'returns empty downstream for leaf variable' do
+      result = graph.intervene(variable: :death, value: true)
+      expect(result[:downstream_effects]).to be_empty
+    end
+  end
+
+  describe '#observe' do
+    it 'updates edges involving the variable when evidence is true' do
+      edge = add_rain_wet
+      before_count = edge.evidence_count
+      graph.observe(variable: :rain, value: true, evidence: true)
+      expect(edge.evidence_count).to be > before_count
+    end
+
+    it 'returns the variable, value, and count of edges updated' do
+      add_rain_wet
+      result = graph.observe(variable: :rain, value: true, evidence: true)
+      expect(result[:variable]).to eq(:rain)
+      expect(result[:edges_updated]).to eq(1)
+    end
+  end
+
+  describe '#confounders' do
+    it 'finds common ancestors of two variables' do
+      graph.add_edge(cause: :weather, effect: :rain, edge_type: :causes)
+      graph.add_edge(cause: :weather, effect: :cold, edge_type: :causes)
+      common = graph.confounders(var_a: :rain, var_b: :cold)
+      expect(common).to include(:weather)
+    end
+
+    it 'returns empty array when no confounders exist' do
+      graph.add_edge(cause: :a, effect: :b, edge_type: :causes)
+      graph.add_edge(cause: :c, effect: :d, edge_type: :causes)
+      expect(graph.confounders(var_a: :b, var_b: :d)).to be_empty
+    end
+  end
+
+  describe '#add_evidence and #remove_evidence' do
+    it 'delegates add_evidence to the edge' do
+      edge = add_rain_wet
+      graph.add_evidence(edge_id: edge.id)
+      expect(edge.evidence_count).to eq(1)
+    end
+
+    it 'returns nil for unknown edge_id in add_evidence' do
+      expect(graph.add_evidence(edge_id: 'bad_id')).to be_nil
+    end
+
+    it 'delegates remove_evidence to the edge' do
+      edge = add_rain_wet
+      edge.add_evidence
+      graph.remove_evidence(edge_id: edge.id)
+      expect(edge.evidence_count).to eq(0)
+    end
+  end
+
+  describe '#confident_edges' do
+    it 'returns only edges meeting confidence threshold' do
+      edge = add_rain_wet
+      3.times { edge.add_evidence }
+      edge.reinforce(amount: 0.2)
+      expect(graph.confident_edges).to include(edge)
+    end
+
+    it 'excludes edges below threshold' do
+      add_rain_wet
+      expect(graph.confident_edges).to be_empty
+    end
+  end
+
+  describe '#by_domain and #by_type' do
+    before do
+      graph.add_edge(cause: :rain, effect: :wet_grass, edge_type: :causes, domain: :weather)
+      graph.add_edge(cause: :stress, effect: :illness, edge_type: :causes, domain: :health)
+    end
+
+    it 'filters edges by domain' do
+      expect(graph.by_domain(domain: :weather).size).to eq(1)
+      expect(graph.by_domain(domain: :health).size).to eq(1)
+    end
+
+    it 'filters edges by type' do
+      expect(graph.by_type(type: :causes).size).to eq(2)
+      expect(graph.by_type(type: :prevents).size).to eq(0)
+    end
+  end
+
+  describe '#decay_all' do
+    it 'decays all edges and returns total count' do
+      add_rain_wet
+      result = graph.decay_all
+      expect(result).to eq(1)
+    end
+  end
+
+  describe '#prune_weak' do
+    it 'removes edges at STRENGTH_FLOOR and returns count' do
+      edge = add_rain_wet
+      100.times { edge.weaken }
+      pruned = graph.prune_weak
+      expect(pruned).to eq(1)
+      expect(graph.to_h[:edges]).to eq(0)
+    end
+
+    it 'returns 0 when no weak edges exist' do
+      add_rain_wet
+      expect(graph.prune_weak).to eq(0)
+    end
+  end
+
+  describe '#to_h' do
+    it 'returns stats hash with variables, edges, confident_edges, edge_types' do
+      add_rain_wet
+      stats = graph.to_h
+      expect(stats[:variables]).to eq(2)
+      expect(stats[:edges]).to eq(1)
+      expect(stats[:edge_types]).to be_a(Hash)
+      expect(stats[:edge_types][:causes]).to eq(1)
+    end
+  end
+end

data/spec/legion/extensions/agentic/inference/causal_reasoning/runners/causal_reasoning_spec.rb

@@ -0,0 +1,161 @@
+# frozen_string_literal: true
+
+require 'legion/extensions/agentic/inference/causal_reasoning/client'
+
+RSpec.describe Legion::Extensions::Agentic::Inference::CausalReasoning::Runners::CausalReasoning do
+  let(:client) { Legion::Extensions::Agentic::Inference::CausalReasoning::Client.new }
+
+  describe '#add_causal_variable' do
+    it 'returns success: true and the variable hash' do
+      result = client.add_causal_variable(name: :temperature, domain: :weather)
+      expect(result[:success]).to be true
+      expect(result[:variable][:name]).to eq(:temperature)
+    end
+
+    it 'returns success: false for duplicate variable' do
+      client.add_causal_variable(name: :temperature, domain: :weather)
+      result = client.add_causal_variable(name: :temperature, domain: :weather)
+      expect(result[:success]).to be false
+      expect(result[:reason]).to eq(:limit_or_duplicate)
+    end
+  end
+
+  describe '#add_causal_edge' do
+    it 'returns success: true and an edge hash' do
+      result = client.add_causal_edge(cause: :rain, effect: :wet_grass, edge_type: :causes)
+      expect(result[:success]).to be true
+      expect(result[:edge][:cause]).to eq(:rain)
+      expect(result[:edge][:effect]).to eq(:wet_grass)
+    end
+
+    it 'returns success: false for invalid edge_type' do
+      result = client.add_causal_edge(cause: :a, effect: :b, edge_type: :unknown)
+      expect(result[:success]).to be false
+      expect(result[:reason]).to eq(:limit_or_invalid_type)
+    end
+
+    it 'uses given strength' do
+      result = client.add_causal_edge(cause: :a, effect: :b, edge_type: :causes, strength: 0.8)
+      expect(result[:edge][:strength]).to be_within(0.001).of(0.8)
+    end
+  end
+
+  describe '#find_causes' do
+    it 'returns causes of a variable' do
+      client.add_causal_edge(cause: :rain, effect: :wet_grass, edge_type: :causes)
+      result = client.find_causes(variable: :wet_grass)
+      expect(result[:success]).to be true
+      expect(result[:count]).to eq(1)
+      expect(result[:causes].first[:cause]).to eq(:rain)
+    end
+
+    it 'returns empty causes for variable with no incoming edges' do
+      client.add_causal_edge(cause: :rain, effect: :wet_grass, edge_type: :causes)
+      result = client.find_causes(variable: :rain)
+      expect(result[:count]).to eq(0)
+    end
+  end
+
+  describe '#find_effects' do
+    it 'returns effects of a variable' do
+      client.add_causal_edge(cause: :rain, effect: :wet_grass, edge_type: :causes)
+      result = client.find_effects(variable: :rain)
+      expect(result[:success]).to be true
+      expect(result[:count]).to eq(1)
+      expect(result[:effects].first[:effect]).to eq(:wet_grass)
+    end
+
+    it 'returns empty effects for leaf variable' do
+      client.add_causal_edge(cause: :rain, effect: :wet_grass, edge_type: :causes)
+      result = client.find_effects(variable: :wet_grass)
+      expect(result[:count]).to eq(0)
+    end
+  end
+
+  describe '#trace_causal_chain' do
+    before do
+      client.add_causal_edge(cause: :rain, effect: :wet_grass, edge_type: :causes)
+      client.add_causal_edge(cause: :wet_grass, effect: :slippery, edge_type: :causes)
+    end
+
+    it 'finds a multi-hop causal path' do
+      result = client.trace_causal_chain(from: :rain, to: :slippery)
+      expect(result[:success]).to be true
+      expect(result[:path_count]).to be >= 1
+    end
+
+    it 'returns zero paths when no connection' do
+      result = client.trace_causal_chain(from: :slippery, to: :rain)
+      expect(result[:path_count]).to eq(0)
+    end
+  end
+
+  describe '#causal_intervention' do
+    before do
+      client.add_causal_edge(cause: :smoking, effect: :cancer, edge_type: :causes)
+      client.add_causal_edge(cause: :cancer, effect: :treatment, edge_type: :causes)
+    end
+
+    it 'returns success: true and lists downstream effects' do
+      result = client.causal_intervention(variable: :smoking, value: true)
+      expect(result[:success]).to be true
+      expect(result[:intervention]).to eq(:smoking)
+      downstream_vars = result[:downstream_effects].map { |e| e[:variable] }
+      expect(downstream_vars).to include(:cancer, :treatment)
+    end
+  end
+
+  describe '#find_confounders' do
+    before do
+      client.add_causal_edge(cause: :weather, effect: :rain, edge_type: :causes)
+      client.add_causal_edge(cause: :weather, effect: :cold, edge_type: :causes)
+    end
+
+    it 'identifies common ancestors as confounders' do
+      result = client.find_confounders(var_a: :rain, var_b: :cold)
+      expect(result[:success]).to be true
+      expect(result[:confounders]).to include(:weather)
+    end
+
+    it 'returns empty confounders for unrelated variables' do
+      result = client.find_confounders(var_a: :rain, var_b: :unrelated)
+      expect(result[:count]).to eq(0)
+    end
+  end
+
+  describe '#add_causal_evidence' do
+    it 'increments evidence on an existing edge' do
+      edge_result = client.add_causal_edge(cause: :rain, effect: :wet_grass, edge_type: :causes)
+      edge_id     = edge_result[:edge][:id]
+      result      = client.add_causal_evidence(edge_id: edge_id)
+      expect(result[:success]).to be true
+      expect(result[:evidence_count]).to eq(1)
+    end
+
+    it 'returns success: false for unknown edge_id' do
+      result = client.add_causal_evidence(edge_id: 'nonexistent-uuid')
+      expect(result[:success]).to be false
+      expect(result[:reason]).to eq(:edge_not_found)
+    end
+  end
+
+  describe '#update_causal_reasoning' do
+    it 'returns success: true with decayed and pruned counts' do
+      client.add_causal_edge(cause: :rain, effect: :wet_grass, edge_type: :causes)
+      result = client.update_causal_reasoning
+      expect(result[:success]).to be true
+      expect(result[:decayed]).to eq(1)
+      expect(result[:pruned]).to eq(0)
+    end
+  end
+
+  describe '#causal_reasoning_stats' do
+    it 'returns stats including variables and edges counts' do
+      client.add_causal_edge(cause: :rain, effect: :wet_grass, edge_type: :causes)
+      result = client.causal_reasoning_stats
+      expect(result[:success]).to be true
+      expect(result[:variables]).to eq(2)
+      expect(result[:edges]).to eq(1)
+    end
+  end
+end

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

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+require 'legion/extensions/agentic/inference/coherence/client'
+
+RSpec.describe Legion::Extensions::Agentic::Inference::Coherence::Client do
+  it 'responds to all runner methods' do
+    client = described_class.new
+    expect(client).to respond_to(:add_coherence_proposition)
+    expect(client).to respond_to(:add_coherence_constraint)
+    expect(client).to respond_to(:compute_proposition_coherence)
+    expect(client).to respond_to(:maximize_coherence)
+    expect(client).to respond_to(:find_contradictions)
+    expect(client).to respond_to(:coherence_partition)
+    expect(client).to respond_to(:update_cognitive_coherence)
+    expect(client).to respond_to(:cognitive_coherence_stats)
+  end
+end