lex-agentic-inference 0.1.0

data/spec/legion/extensions/agentic/inference/causal_attribution/helpers/attribution_engine_spec.rb

@@ -0,0 +1,181 @@
+# frozen_string_literal: true
+
+RSpec.describe Legion::Extensions::Agentic::Inference::CausalAttribution::Helpers::AttributionEngine do
+  subject(:engine) { described_class.new }
+
+  let(:basic_args) do
+    {
+      event:           'task completed',
+      outcome:         :success,
+      domain:          :work,
+      locus:           :internal,
+      stability:       :stable,
+      controllability: :controllable
+    }
+  end
+
+  describe '#create_attribution' do
+    it 'returns an Attribution object' do
+      result = engine.create_attribution(**basic_args)
+      expect(result).to be_a(Legion::Extensions::Agentic::Inference::CausalAttribution::Helpers::Attribution)
+    end
+
+    it 'stores the attribution' do
+      engine.create_attribution(**basic_args)
+      expect(engine.count).to eq(1)
+    end
+
+    it 'accepts optional confidence' do
+      attr = engine.create_attribution(**basic_args, confidence: 0.9)
+      expect(attr.confidence).to eq(0.9)
+    end
+  end
+
+  describe '#reattribute' do
+    let!(:attr) { engine.create_attribution(**basic_args) }
+
+    it 'updates locus when provided' do
+      result = engine.reattribute(attribution_id: attr.id, locus: :external)
+      expect(result.locus).to eq(:external)
+    end
+
+    it 'preserves unchanged dimensions' do
+      result = engine.reattribute(attribution_id: attr.id, locus: :external)
+      expect(result.stability).to eq(:stable)
+      expect(result.controllability).to eq(:controllable)
+    end
+
+    it 'updates the emotional_response after reattribution' do
+      result = engine.reattribute(attribution_id: attr.id, locus: :external)
+      expect(result.emotional_response).to eq(:anger)
+    end
+
+    it 'returns not found hash for unknown id' do
+      result = engine.reattribute(attribution_id: 'nonexistent')
+      expect(result[:found]).to be false
+    end
+  end
+
+  describe '#by_pattern' do
+    before do
+      engine.create_attribution(**basic_args)
+      engine.create_attribution(**basic_args, locus: :external)
+    end
+
+    it 'filters by locus' do
+      results = engine.by_pattern(locus: :internal)
+      expect(results.size).to eq(1)
+      expect(results.first.locus).to eq(:internal)
+    end
+
+    it 'returns all when no filter given' do
+      expect(engine.by_pattern.size).to eq(2)
+    end
+  end
+
+  describe '#by_domain' do
+    before do
+      engine.create_attribution(**basic_args)
+      engine.create_attribution(**basic_args, domain: :personal)
+    end
+
+    it 'returns only matching domain' do
+      results = engine.by_domain(domain: :work)
+      expect(results.size).to eq(1)
+    end
+  end
+
+  describe '#by_outcome' do
+    before do
+      engine.create_attribution(**basic_args)
+      engine.create_attribution(**basic_args, outcome: :failure)
+    end
+
+    it 'returns only matching outcome' do
+      results = engine.by_outcome(outcome: :failure)
+      expect(results.size).to eq(1)
+    end
+  end
+
+  describe '#attribution_bias' do
+    it 'returns bias hash with detection key' do
+      engine.create_attribution(**basic_args)
+      result = engine.attribution_bias
+      expect(result).to have_key(:self_serving_bias_detected)
+      expect(result).to have_key(:external_failure_ratio)
+    end
+
+    it 'detects self-serving bias when failures are mostly external' do
+      3.times do
+        engine.create_attribution(**basic_args, outcome: :failure, locus: :external, stability: :unstable, controllability: :controllable)
+      end
+      result = engine.attribution_bias
+      expect(result[:self_serving_bias_detected]).to be true
+    end
+
+    it 'returns no attributions message when empty' do
+      result = engine.attribution_bias
+      expect(result[:bias]).to eq(:none)
+    end
+  end
+
+  describe '#emotional_profile' do
+    before do
+      engine.create_attribution(**basic_args)
+      engine.create_attribution(**basic_args, locus: :external, stability: :unstable)
+    end
+
+    it 'returns distribution and dominant' do
+      result = engine.emotional_profile
+      expect(result).to have_key(:distribution)
+      expect(result).to have_key(:dominant)
+      expect(result[:total]).to eq(2)
+    end
+  end
+
+  describe '#most_common_pattern' do
+    before do
+      2.times { engine.create_attribution(**basic_args) }
+      engine.create_attribution(**basic_args, locus: :external)
+    end
+
+    it 'returns the most frequent pattern' do
+      result = engine.most_common_pattern
+      expect(result[:pattern]).to eq(%i[internal stable controllable])
+      expect(result[:count]).to eq(2)
+    end
+
+    it 'returns nil pattern when empty' do
+      expect(described_class.new.most_common_pattern[:pattern]).to be_nil
+    end
+  end
+
+  describe '#decay_all' do
+    it 'reduces confidence on all attributions' do
+      engine.create_attribution(**basic_args, confidence: 0.8)
+      engine.decay_all
+      expect(engine.by_pattern.first.confidence).to be < 0.8
+    end
+
+    it 'returns count of decayed entries' do
+      2.times { engine.create_attribution(**basic_args) }
+      expect(engine.decay_all).to eq(2)
+    end
+
+    it 'floors at CONFIDENCE_FLOOR' do
+      attr = engine.create_attribution(**basic_args, confidence: 0.001)
+      engine.decay_all
+      expect(attr.confidence).to be >= Legion::Extensions::Agentic::Inference::CausalAttribution::Helpers::Attribution::CONFIDENCE_FLOOR
+    end
+  end
+
+  describe '#to_h' do
+    it 'includes stats keys' do
+      engine.create_attribution(**basic_args)
+      h = engine.to_h
+      expect(h).to have_key(:total_attributions)
+      expect(h).to have_key(:outcome_counts)
+      expect(h).to have_key(:locus_counts)
+    end
+  end
+end

data/spec/legion/extensions/agentic/inference/causal_attribution/helpers/attribution_spec.rb

@@ -0,0 +1,108 @@
+# frozen_string_literal: true
+
+RSpec.describe Legion::Extensions::Agentic::Inference::CausalAttribution::Helpers::Attribution do
+  subject(:attr) do
+    described_class.new(
+      event:           'task failed',
+      outcome:         :failure,
+      domain:          :work,
+      locus:           :internal,
+      stability:       :stable,
+      controllability: :controllable
+    )
+  end
+
+  describe '#initialize' do
+    it 'assigns an id' do
+      expect(attr.id).to match(/\A[0-9a-f-]{36}\z/)
+    end
+
+    it 'stores all dimensions' do
+      expect(attr.locus).to eq(:internal)
+      expect(attr.stability).to eq(:stable)
+      expect(attr.controllability).to eq(:controllable)
+    end
+
+    it 'derives emotional_response from ATTRIBUTION_EMOTIONS' do
+      expect(attr.emotional_response).to eq(:guilt)
+    end
+
+    it 'uses DEFAULT_CONFIDENCE when none given' do
+      expect(attr.confidence).to eq(described_class::DEFAULT_CONFIDENCE)
+    end
+
+    it 'clamps confidence to ceiling' do
+      high = described_class.new(
+        event: 'x', outcome: :success, domain: :test,
+        locus: :external, stability: :unstable, controllability: :uncontrollable,
+        confidence: 5.0
+      )
+      expect(high.confidence).to eq(1.0)
+    end
+
+    it 'clamps confidence to floor' do
+      low = described_class.new(
+        event: 'x', outcome: :success, domain: :test,
+        locus: :external, stability: :unstable, controllability: :uncontrollable,
+        confidence: -1.0
+      )
+      expect(low.confidence).to eq(0.0)
+    end
+
+    it 'records created_at' do
+      expect(attr.created_at).to be_a(Time)
+    end
+  end
+
+  describe '#pattern' do
+    it 'returns [locus, stability, controllability] tuple' do
+      expect(attr.pattern).to eq(%i[internal stable controllable])
+    end
+  end
+
+  describe 'predicates' do
+    it 'internal? returns true for internal locus' do
+      expect(attr.internal?).to be true
+      expect(attr.external?).to be false
+    end
+
+    it 'stable? returns true for stable stability' do
+      expect(attr.stable?).to be true
+    end
+
+    it 'controllable? returns true for controllable controllability' do
+      expect(attr.controllable?).to be true
+    end
+  end
+
+  describe 'ATTRIBUTION_EMOTIONS mapping' do
+    {
+      %i[internal stable controllable]     => :guilt,
+      %i[internal stable uncontrollable]   => :shame,
+      %i[internal unstable controllable]   => :regret,
+      %i[internal unstable uncontrollable] => :surprise,
+      %i[external stable controllable]     => :anger,
+      %i[external stable uncontrollable]   => :helplessness,
+      %i[external unstable controllable]   => :frustration,
+      %i[external unstable uncontrollable] => :relief
+    }.each do |pattern, emotion|
+      it "maps #{pattern.inspect} to #{emotion}" do
+        a = described_class.new(
+          event: 'e', outcome: :neutral, domain: :test,
+          locus: pattern[0], stability: pattern[1], controllability: pattern[2]
+        )
+        expect(a.emotional_response).to eq(emotion)
+      end
+    end
+  end
+
+  describe '#to_h' do
+    it 'includes all required keys' do
+      h = attr.to_h
+      %i[id event outcome domain locus stability controllability
+         confidence emotional_response created_at].each do |key|
+        expect(h).to have_key(key)
+      end
+    end
+  end
+end

data/spec/legion/extensions/agentic/inference/causal_attribution/runners/causal_attribution_spec.rb

@@ -0,0 +1,142 @@
+# frozen_string_literal: true
+
+require 'legion/extensions/agentic/inference/causal_attribution/client'
+
+RSpec.describe Legion::Extensions::Agentic::Inference::CausalAttribution::Runners::CausalAttribution do
+  let(:client) { Legion::Extensions::Agentic::Inference::CausalAttribution::Client.new }
+
+  let(:base_args) do
+    {
+      event:           'missed deadline',
+      outcome:         :failure,
+      domain:          :work,
+      locus:           :internal,
+      stability:       :stable,
+      controllability: :controllable
+    }
+  end
+
+  describe '#create_causal_attribution' do
+    it 'returns success true' do
+      result = client.create_causal_attribution(**base_args)
+      expect(result[:success]).to be true
+    end
+
+    it 'includes attribution hash' do
+      result = client.create_causal_attribution(**base_args)
+      expect(result[:attribution]).to have_key(:id)
+      expect(result[:attribution][:emotional_response]).to eq(:guilt)
+    end
+
+    it 'accepts string locus and coerces to symbol' do
+      result = client.create_causal_attribution(**base_args, locus: 'external')
+      expect(result[:attribution][:locus]).to eq(:external)
+    end
+  end
+
+  describe '#reattribute_cause' do
+    let!(:id) { client.create_causal_attribution(**base_args)[:attribution][:id] }
+
+    it 'updates the attribution' do
+      result = client.reattribute_cause(attribution_id: id, locus: :external)
+      expect(result[:success]).to be true
+      expect(result[:attribution][:locus]).to eq(:external)
+    end
+
+    it 'returns success false for unknown id' do
+      result = client.reattribute_cause(attribution_id: 'bad-id')
+      expect(result[:success]).to be false
+      expect(result[:found]).to be false
+    end
+  end
+
+  describe '#attributions_by_pattern' do
+    before do
+      client.create_causal_attribution(**base_args)
+      client.create_causal_attribution(**base_args, locus: :external)
+    end
+
+    it 'filters by locus' do
+      result = client.attributions_by_pattern(locus: :internal)
+      expect(result[:count]).to eq(1)
+    end
+
+    it 'returns all when no filter given' do
+      result = client.attributions_by_pattern
+      expect(result[:count]).to eq(2)
+    end
+  end
+
+  describe '#domain_attributions' do
+    before { client.create_causal_attribution(**base_args) }
+
+    it 'returns attributions for domain' do
+      result = client.domain_attributions(domain: :work)
+      expect(result[:count]).to be >= 1
+    end
+  end
+
+  describe '#outcome_attributions' do
+    before do
+      client.create_causal_attribution(**base_args)
+      client.create_causal_attribution(**base_args, outcome: :success)
+    end
+
+    it 'returns attributions by outcome' do
+      result = client.outcome_attributions(outcome: :failure)
+      expect(result[:count]).to eq(1)
+    end
+  end
+
+  describe '#attribution_bias_assessment' do
+    before { client.create_causal_attribution(**base_args) }
+
+    it 'returns bias structure' do
+      result = client.attribution_bias_assessment
+      expect(result[:success]).to be true
+      expect(result[:bias]).to have_key(:self_serving_bias_detected)
+    end
+  end
+
+  describe '#emotional_attribution_profile' do
+    before { client.create_causal_attribution(**base_args) }
+
+    it 'returns profile with dominant emotion' do
+      result = client.emotional_attribution_profile
+      expect(result[:success]).to be true
+      expect(result[:profile]).to have_key(:dominant)
+    end
+  end
+
+  describe '#most_common_attribution' do
+    before do
+      2.times { client.create_causal_attribution(**base_args) }
+    end
+
+    it 'returns the most frequent pattern' do
+      result = client.most_common_attribution
+      expect(result[:success]).to be true
+      expect(result[:count]).to eq(2)
+    end
+  end
+
+  describe '#update_causal_attribution' do
+    before { client.create_causal_attribution(**base_args, confidence: 0.8) }
+
+    it 'decays confidence and reports count' do
+      result = client.update_causal_attribution
+      expect(result[:success]).to be true
+      expect(result[:decayed]).to eq(1)
+    end
+  end
+
+  describe '#causal_attribution_stats' do
+    before { client.create_causal_attribution(**base_args) }
+
+    it 'returns stats hash' do
+      result = client.causal_attribution_stats
+      expect(result[:success]).to be true
+      expect(result[:stats][:total_attributions]).to eq(1)
+    end
+  end
+end

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

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+require 'legion/extensions/agentic/inference/causal_reasoning/client'
+
+RSpec.describe Legion::Extensions::Agentic::Inference::CausalReasoning::Client do
+  let(:client) { described_class.new }
+
+  it 'responds to all runner methods' do
+    expect(client).to respond_to(:add_causal_variable)
+    expect(client).to respond_to(:add_causal_edge)
+    expect(client).to respond_to(:find_causes)
+    expect(client).to respond_to(:find_effects)
+    expect(client).to respond_to(:trace_causal_chain)
+    expect(client).to respond_to(:causal_intervention)
+    expect(client).to respond_to(:find_confounders)
+    expect(client).to respond_to(:add_causal_evidence)
+    expect(client).to respond_to(:update_causal_reasoning)
+    expect(client).to respond_to(:causal_reasoning_stats)
+  end
+
+  it 'accepts an injected graph' do
+    injected_graph = Legion::Extensions::Agentic::Inference::CausalReasoning::Helpers::CausalGraph.new
+    injected_graph.add_edge(cause: :a, effect: :b, edge_type: :causes)
+    client_with_graph = described_class.new(graph: injected_graph)
+    result = client_with_graph.causal_reasoning_stats
+    expect(result[:edges]).to eq(1)
+  end
+
+  it 'maintains isolated state between instances' do
+    c1 = described_class.new
+    c2 = described_class.new
+    c1.add_causal_edge(cause: :a, effect: :b, edge_type: :causes)
+    expect(c2.causal_reasoning_stats[:edges]).to eq(0)
+  end
+end

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

@@ -0,0 +1,158 @@
+# frozen_string_literal: true
+
+require 'legion/extensions/agentic/inference/causal_reasoning/client'
+
+RSpec.describe Legion::Extensions::Agentic::Inference::CausalReasoning::Helpers::CausalEdge do
+  subject(:edge) do
+    described_class.new(cause: :rain, effect: :wet_grass, edge_type: :causes, domain: :weather)
+  end
+
+  describe '#initialize' do
+    it 'sets cause and effect' do
+      expect(edge.cause).to eq(:rain)
+      expect(edge.effect).to eq(:wet_grass)
+    end
+
+    it 'sets edge_type and domain' do
+      expect(edge.edge_type).to eq(:causes)
+      expect(edge.domain).to eq(:weather)
+    end
+
+    it 'clamps strength to STRENGTH_FLOOR..STRENGTH_CEILING' do
+      over  = described_class.new(cause: :a, effect: :b, edge_type: :causes, strength: 2.0)
+      under = described_class.new(cause: :a, effect: :b, edge_type: :causes, strength: 0.0)
+      expect(over.strength).to eq(Legion::Extensions::Agentic::Inference::CausalReasoning::Helpers::Constants::STRENGTH_CEILING)
+      expect(under.strength).to eq(Legion::Extensions::Agentic::Inference::CausalReasoning::Helpers::Constants::STRENGTH_FLOOR)
+    end
+
+    it 'starts with evidence_count of zero' do
+      expect(edge.evidence_count).to eq(0)
+    end
+
+    it 'assigns a unique id' do
+      other = described_class.new(cause: :rain, effect: :wet_grass, edge_type: :causes)
+      expect(edge.id).not_to eq(other.id)
+    end
+  end
+
+  describe '#add_evidence' do
+    it 'increments evidence_count' do
+      edge.add_evidence
+      expect(edge.evidence_count).to eq(1)
+    end
+
+    it 'increases strength' do
+      before = edge.strength
+      edge.add_evidence
+      expect(edge.strength).to be > before
+    end
+
+    it 'returns self' do
+      expect(edge.add_evidence).to be(edge)
+    end
+
+    it 'does not exceed STRENGTH_CEILING' do
+      100.times { edge.add_evidence }
+      expect(edge.strength).to eq(Legion::Extensions::Agentic::Inference::CausalReasoning::Helpers::Constants::STRENGTH_CEILING)
+    end
+  end
+
+  describe '#remove_evidence' do
+    it 'decrements evidence_count but not below zero' do
+      edge.remove_evidence
+      expect(edge.evidence_count).to eq(0)
+    end
+
+    it 'decreases strength' do
+      before = edge.strength
+      edge.remove_evidence
+      expect(edge.strength).to be < before
+    end
+
+    it 'does not go below STRENGTH_FLOOR' do
+      100.times { edge.remove_evidence }
+      expect(edge.strength).to eq(Legion::Extensions::Agentic::Inference::CausalReasoning::Helpers::Constants::STRENGTH_FLOOR)
+    end
+  end
+
+  describe '#reinforce' do
+    it 'increases strength by given amount' do
+      before = edge.strength
+      edge.reinforce(amount: 0.2)
+      expect(edge.strength).to be_within(0.001).of(before + 0.2)
+    end
+
+    it 'clamps at STRENGTH_CEILING' do
+      edge.reinforce(amount: 1.0)
+      expect(edge.strength).to eq(Legion::Extensions::Agentic::Inference::CausalReasoning::Helpers::Constants::STRENGTH_CEILING)
+    end
+  end
+
+  describe '#weaken' do
+    it 'decreases strength by given amount' do
+      before = edge.strength
+      edge.weaken(amount: 0.1)
+      expect(edge.strength).to be_within(0.001).of(before - 0.1)
+    end
+
+    it 'clamps at STRENGTH_FLOOR' do
+      edge.weaken(amount: 1.0)
+      expect(edge.strength).to eq(Legion::Extensions::Agentic::Inference::CausalReasoning::Helpers::Constants::STRENGTH_FLOOR)
+    end
+  end
+
+  describe '#decay' do
+    it 'reduces strength by DECAY_RATE' do
+      before = edge.strength
+      edge.decay
+      expect(edge.strength).to be_within(0.001).of(before - Legion::Extensions::Agentic::Inference::CausalReasoning::Helpers::Constants::DECAY_RATE)
+    end
+
+    it 'does not go below STRENGTH_FLOOR' do
+      100.times { edge.decay }
+      expect(edge.strength).to eq(Legion::Extensions::Agentic::Inference::CausalReasoning::Helpers::Constants::STRENGTH_FLOOR)
+    end
+  end
+
+  describe '#confident?' do
+    it 'returns false when evidence_count is below EVIDENCE_THRESHOLD' do
+      expect(edge.confident?).to be false
+    end
+
+    it 'returns true when both strength and evidence_count meet thresholds' do
+      3.times { edge.add_evidence }
+      edge.reinforce(amount: 0.2)
+      expect(edge.confident?).to be true
+    end
+  end
+
+  describe '#confidence_label' do
+    it 'returns :speculative for low strength' do
+      edge.weaken(amount: 1.0)
+      expect(edge.confidence_label).to eq(:speculative)
+    end
+
+    it 'returns :moderate for strength around 0.7' do
+      strong_edge = described_class.new(cause: :a, effect: :b, edge_type: :causes, strength: 0.7)
+      expect(strong_edge.confidence_label).to eq(:moderate)
+    end
+
+    it 'returns :strong for strength >= 0.8' do
+      strong_edge = described_class.new(cause: :a, effect: :b, edge_type: :causes, strength: 0.9)
+      expect(strong_edge.confidence_label).to eq(:strong)
+    end
+  end
+
+  describe '#to_h' do
+    it 'includes all key fields' do
+      hash = edge.to_h
+      expect(hash).to include(:id, :cause, :effect, :edge_type, :domain,
+                              :strength, :evidence_count, :confident, :label,
+                              :created_at, :updated_at)
+    end
+
+    it 'reflects confident? state' do
+      expect(edge.to_h[:confident]).to be false
+    end
+  end
+end