lex-agentic-social 0.1.0

data/spec/legion/extensions/agentic/social/moral_reasoning/helpers/moral_engine_spec.rb

@@ -0,0 +1,266 @@
+# frozen_string_literal: true
+
+RSpec.describe Legion::Extensions::Agentic::Social::MoralReasoning::Helpers::MoralEngine do
+  subject(:engine) { described_class.new }
+
+  let(:options) do
+    [
+      { id: 'opt_a', description: 'Help the many', foundations: %i[care fairness] },
+      { id: 'opt_b', description: 'Follow the rule', foundations: %i[authority loyalty] }
+    ]
+  end
+
+  describe '#initialize' do
+    it 'starts at :social_contract stage' do
+      expect(engine.stage).to eq(:social_contract)
+    end
+
+    it 'initializes all moral foundations' do
+      profile = engine.foundation_profile
+      Legion::Extensions::Agentic::Social::MoralReasoning::Helpers::Constants::MORAL_FOUNDATIONS.each do |f|
+        expect(profile).to have_key(f)
+      end
+    end
+
+    it 'starts with empty dilemmas and principles' do
+      expect(engine.dilemmas).to be_empty
+      expect(engine.principles).to be_empty
+    end
+  end
+
+  describe '#evaluate_action' do
+    it 'returns a score for an action' do
+      result = engine.evaluate_action(action: 'help_stranger', affected_foundations: %i[care fairness])
+      expect(result[:score]).to be_a(Float)
+      expect(result[:score]).to be >= 0.0
+    end
+
+    it 'returns 0.0 for empty foundations' do
+      result = engine.evaluate_action(action: 'noop', affected_foundations: [])
+      expect(result[:score]).to eq(0.0)
+    end
+
+    it 'includes action and domain in result' do
+      result = engine.evaluate_action(action: 'report', affected_foundations: %i[loyalty], domain: :workplace)
+      expect(result[:action]).to eq('report')
+      expect(result[:domain]).to eq(:workplace)
+    end
+  end
+
+  describe '#pose_dilemma' do
+    it 'creates a dilemma and returns success' do
+      result = engine.pose_dilemma(description: 'Trolley problem', options: options)
+      expect(result[:success]).to be true
+      expect(result[:dilemma][:description]).to eq('Trolley problem')
+    end
+
+    it 'assigns a unique id' do
+      r1 = engine.pose_dilemma(description: 'A', options: options)
+      r2 = engine.pose_dilemma(description: 'B', options: options)
+      expect(r1[:dilemma][:id]).not_to eq(r2[:dilemma][:id])
+    end
+
+    it 'stores the dilemma in @dilemmas' do
+      engine.pose_dilemma(description: 'Test', options: options)
+      expect(engine.dilemmas).not_to be_empty
+    end
+
+    it 'returns failure when max dilemmas reached' do
+      Legion::Extensions::Agentic::Social::MoralReasoning::Helpers::Constants::MAX_DILEMMAS.times do |i|
+        engine.pose_dilemma(description: "Dilemma #{i}", options: options)
+      end
+      result = engine.pose_dilemma(description: 'One more', options: options)
+      expect(result[:success]).to be false
+      expect(result[:reason]).to eq(:max_dilemmas_reached)
+    end
+  end
+
+  describe '#resolve_dilemma' do
+    let(:dilemma_id) do
+      engine.pose_dilemma(description: 'Test dilemma', options: options)[:dilemma][:id]
+    end
+
+    it 'resolves an existing dilemma' do
+      result = engine.resolve_dilemma(
+        dilemma_id: dilemma_id, option_id: 'opt_a',
+        reasoning: 'Most good', framework: :utilitarian
+      )
+      expect(result[:success]).to be true
+      expect(result[:dilemma][:resolved]).to be true
+    end
+
+    it 'returns failure for unknown dilemma_id' do
+      result = engine.resolve_dilemma(
+        dilemma_id: 'nonexistent', option_id: 'opt_a',
+        reasoning: 'N/A', framework: :utilitarian
+      )
+      expect(result[:success]).to be false
+      expect(result[:reason]).to eq(:not_found)
+    end
+
+    it 'returns failure for invalid option_id' do
+      result = engine.resolve_dilemma(
+        dilemma_id: dilemma_id, option_id: 'bad_opt',
+        reasoning: 'N/A', framework: :utilitarian
+      )
+      expect(result[:success]).to be false
+      expect(result[:reason]).to eq(:invalid_option)
+    end
+
+    it 'returns failure if already resolved' do
+      engine.resolve_dilemma(
+        dilemma_id: dilemma_id, option_id: 'opt_a',
+        reasoning: 'First', framework: :utilitarian
+      )
+      result = engine.resolve_dilemma(
+        dilemma_id: dilemma_id, option_id: 'opt_b',
+        reasoning: 'Second', framework: :deontological
+      )
+      expect(result[:success]).to be false
+      expect(result[:reason]).to eq(:already_resolved)
+    end
+  end
+
+  describe '#apply_framework' do
+    let(:dilemma_id) do
+      engine.pose_dilemma(description: 'Framework test', options: options)[:dilemma][:id]
+    end
+
+    it 'returns rankings for a valid framework' do
+      result = engine.apply_framework(dilemma_id: dilemma_id, framework: :utilitarian)
+      expect(result[:success]).to be true
+      expect(result[:rankings]).to be_an(Array)
+      expect(result[:rankings].size).to eq(2)
+    end
+
+    it 'returns failure for unknown framework' do
+      result = engine.apply_framework(dilemma_id: dilemma_id, framework: :made_up)
+      expect(result[:success]).to be false
+      expect(result[:reason]).to eq(:unknown_framework)
+    end
+
+    it 'returns failure for unknown dilemma' do
+      result = engine.apply_framework(dilemma_id: 'nope', framework: :utilitarian)
+      expect(result[:success]).to be false
+      expect(result[:reason]).to eq(:not_found)
+    end
+
+    Legion::Extensions::Agentic::Social::MoralReasoning::Helpers::Constants::ETHICAL_FRAMEWORKS.each do |framework|
+      it "applies #{framework} framework" do
+        result = engine.apply_framework(dilemma_id: dilemma_id, framework: framework)
+        expect(result[:success]).to be true
+        expect(result[:framework]).to eq(framework)
+      end
+    end
+  end
+
+  describe '#add_principle' do
+    it 'adds a custom moral principle' do
+      result = engine.add_principle(
+        name:        'Do no harm',
+        description: 'Avoid causing harm to others',
+        foundation:  :care
+      )
+      expect(result[:success]).to be true
+      expect(result[:principle][:name]).to eq('Do no harm')
+    end
+
+    it 'returns failure for unknown foundation' do
+      result = engine.add_principle(name: 'Test', description: 'Test', foundation: :made_up)
+      expect(result[:success]).to be false
+      expect(result[:reason]).to eq(:unknown_foundation)
+    end
+
+    it 'returns failure when max principles reached' do
+      Legion::Extensions::Agentic::Social::MoralReasoning::Helpers::Constants::MAX_PRINCIPLES.times do |i|
+        engine.add_principle(name: "P#{i}", description: "Desc #{i}", foundation: :care)
+      end
+      result = engine.add_principle(name: 'One more', description: 'Extra', foundation: :care)
+      expect(result[:success]).to be false
+      expect(result[:reason]).to eq(:max_principles_reached)
+    end
+  end
+
+  describe '#moral_development' do
+    context 'with insufficient resolved dilemmas' do
+      it 'does not advance stage' do
+        result = engine.moral_development
+        expect(result[:advanced]).to be false
+      end
+    end
+
+    context 'with enough high-severity resolved dilemmas' do
+      before do
+        5.times do |i|
+          r = engine.pose_dilemma(description: "D#{i}", options: options, severity: 0.8)
+          engine.resolve_dilemma(
+            dilemma_id: r[:dilemma][:id], option_id: 'opt_a',
+            reasoning: 'Because', framework: :utilitarian
+          )
+        end
+      end
+
+      it 'advances to the next Kohlberg stage' do
+        result = engine.moral_development
+        expect(result[:advanced]).to be true
+        expect(result[:stage]).not_to eq(:social_contract)
+      end
+    end
+  end
+
+  describe '#foundation_profile' do
+    it 'returns a hash keyed by foundation ids' do
+      profile = engine.foundation_profile
+      expect(profile.keys).to match_array(Legion::Extensions::Agentic::Social::MoralReasoning::Helpers::Constants::MORAL_FOUNDATIONS)
+    end
+  end
+
+  describe '#stage_info' do
+    it 'returns stage, level, and description' do
+      info = engine.stage_info
+      expect(info).to include(:stage, :level, :description)
+      expect(info[:stage]).to eq(:social_contract)
+      expect(info[:level]).to eq(:postconventional)
+    end
+  end
+
+  describe '#unresolved_dilemmas / #resolved_dilemmas' do
+    before do
+      engine.pose_dilemma(description: 'Unresolved', options: options)
+      r = engine.pose_dilemma(description: 'Resolved', options: options)
+      engine.resolve_dilemma(
+        dilemma_id: r[:dilemma][:id], option_id: 'opt_a',
+        reasoning: 'Because', framework: :utilitarian
+      )
+    end
+
+    it 'returns only unresolved dilemmas' do
+      expect(engine.unresolved_dilemmas.size).to eq(1)
+      expect(engine.unresolved_dilemmas.first.resolved?).to be false
+    end
+
+    it 'returns only resolved dilemmas' do
+      expect(engine.resolved_dilemmas.size).to eq(1)
+      expect(engine.resolved_dilemmas.first.resolved?).to be true
+    end
+  end
+
+  describe '#decay_all' do
+    it 'decreases foundation weights' do
+      profile_before = engine.foundation_profile.transform_values { |f| f[:weight] }
+      engine.decay_all
+      profile_after = engine.foundation_profile.transform_values { |f| f[:weight] }
+      profile_before.each do |fid, before_weight|
+        expect(profile_after[fid]).to be <= before_weight
+      end
+    end
+  end
+
+  describe '#to_h' do
+    it 'returns a stats summary hash' do
+      h = engine.to_h
+      expect(h).to include(:stage, :total_dilemmas, :resolved_dilemmas,
+                           :unresolved_dilemmas, :principles, :foundation_profile)
+    end
+  end
+end

data/spec/legion/extensions/agentic/social/moral_reasoning/helpers/moral_foundation_spec.rb

@@ -0,0 +1,70 @@
+# frozen_string_literal: true
+
+RSpec.describe Legion::Extensions::Agentic::Social::MoralReasoning::Helpers::MoralFoundation do
+  subject(:foundation) { described_class.new(id: :care) }
+
+  describe '#initialize' do
+    it 'sets id' do
+      expect(foundation.id).to eq(:care)
+    end
+
+    it 'defaults weight to DEFAULT_WEIGHT' do
+      expect(foundation.weight).to eq(Legion::Extensions::Agentic::Social::MoralReasoning::Helpers::Constants::DEFAULT_WEIGHT)
+    end
+
+    it 'clamps weight to WEIGHT_FLOOR if below floor' do
+      f = described_class.new(id: :care, weight: 0.0)
+      expect(f.weight).to eq(Legion::Extensions::Agentic::Social::MoralReasoning::Helpers::Constants::WEIGHT_FLOOR)
+    end
+
+    it 'clamps weight to WEIGHT_CEILING if above ceiling' do
+      f = described_class.new(id: :care, weight: 2.0)
+      expect(f.weight).to eq(Legion::Extensions::Agentic::Social::MoralReasoning::Helpers::Constants::WEIGHT_CEILING)
+    end
+  end
+
+  describe '#reinforce' do
+    it 'increases weight' do
+      before = foundation.weight
+      foundation.reinforce(amount: 1.0)
+      expect(foundation.weight).to be > before
+    end
+
+    it 'does not exceed WEIGHT_CEILING' do
+      10.times { foundation.reinforce(amount: 10.0) }
+      expect(foundation.weight).to eq(Legion::Extensions::Agentic::Social::MoralReasoning::Helpers::Constants::WEIGHT_CEILING)
+    end
+  end
+
+  describe '#weaken' do
+    it 'decreases weight' do
+      before = foundation.weight
+      foundation.weaken(amount: 1.0)
+      expect(foundation.weight).to be < before
+    end
+
+    it 'does not go below WEIGHT_FLOOR' do
+      10.times { foundation.weaken(amount: 10.0) }
+      expect(foundation.weight).to eq(Legion::Extensions::Agentic::Social::MoralReasoning::Helpers::Constants::WEIGHT_FLOOR)
+    end
+  end
+
+  describe '#decay' do
+    it 'decreases weight by DECAY_RATE' do
+      before = foundation.weight
+      foundation.decay
+      expected = (before - Legion::Extensions::Agentic::Social::MoralReasoning::Helpers::Constants::DECAY_RATE)
+                 .clamp(Legion::Extensions::Agentic::Social::MoralReasoning::Helpers::Constants::WEIGHT_FLOOR,
+                        Legion::Extensions::Agentic::Social::MoralReasoning::Helpers::Constants::WEIGHT_CEILING)
+      expect(foundation.weight).to eq(expected)
+    end
+  end
+
+  describe '#to_h' do
+    it 'returns a hash with id, weight, sensitivity' do
+      h = foundation.to_h
+      expect(h).to include(:id, :weight, :sensitivity)
+      expect(h[:id]).to eq(:care)
+    end
+  end
+end

data/spec/legion/extensions/agentic/social/moral_reasoning/runners/moral_reasoning_spec.rb

@@ -0,0 +1,275 @@
+# frozen_string_literal: true
+
+RSpec.describe Legion::Extensions::Agentic::Social::MoralReasoning::Runners::MoralReasoning do
+  let(:client) { Legion::Extensions::Agentic::Social::MoralReasoning::Client.new }
+  let(:enhancer) { Legion::Extensions::Agentic::Social::MoralReasoning::Helpers::LlmEnhancer }
+
+  let(:options) do
+    [
+      { id: 'opt_a', description: 'Care approach', foundations: %i[care fairness] },
+      { id: 'opt_b', description: 'Rule approach', foundations: %i[authority loyalty] }
+    ]
+  end
+
+  describe '#evaluate_moral_action' do
+    it 'returns success with a score' do
+      result = client.evaluate_moral_action(
+        action:               'help_stranger',
+        affected_foundations: %i[care fairness]
+      )
+      expect(result[:success]).to be true
+      expect(result[:score]).to be_a(Float)
+    end
+
+    it 'accepts a domain parameter' do
+      result = client.evaluate_moral_action(
+        action:               'whistleblow',
+        affected_foundations: %i[fairness],
+        domain:               :workplace
+      )
+      expect(result[:domain]).to eq(:workplace)
+    end
+
+    context 'when LLM is available' do
+      let(:llm_result) do
+        {
+          reasoning:          'LLM ethical analysis of this action.',
+          foundation_impacts: { care: 0.2, fairness: 0.1, loyalty: -0.05,
+                                authority: 0.0, sanctity: 0.1, liberty: 0.05 }
+        }
+      end
+
+      before do
+        allow(enhancer).to receive(:available?).and_return(true)
+        allow(enhancer).to receive(:evaluate_action).and_return(llm_result)
+      end
+
+      it 'returns source: :llm' do
+        result = client.evaluate_moral_action(
+          action:               'help_stranger',
+          affected_foundations: %i[care fairness]
+        )
+        expect(result[:source]).to eq(:llm)
+      end
+
+      it 'includes LLM reasoning' do
+        result = client.evaluate_moral_action(
+          action:               'help_stranger',
+          affected_foundations: %i[care fairness]
+        )
+        expect(result[:reasoning]).to eq('LLM ethical analysis of this action.')
+      end
+
+      it 'includes foundation_impacts from LLM' do
+        result = client.evaluate_moral_action(
+          action:               'help_stranger',
+          affected_foundations: %i[care fairness]
+        )
+        expect(result[:foundation_impacts]).to eq(llm_result[:foundation_impacts])
+      end
+    end
+
+    context 'when LLM is unavailable' do
+      before do
+        allow(enhancer).to receive(:available?).and_return(false)
+      end
+
+      it 'returns source: :mechanical' do
+        result = client.evaluate_moral_action(
+          action:               'help_stranger',
+          affected_foundations: %i[care fairness]
+        )
+        expect(result[:source]).to eq(:mechanical)
+      end
+
+      it 'still returns success: true' do
+        result = client.evaluate_moral_action(
+          action:               'help_stranger',
+          affected_foundations: %i[care fairness]
+        )
+        expect(result[:success]).to be true
+      end
+    end
+
+    context 'when LLM returns nil' do
+      before do
+        allow(enhancer).to receive(:available?).and_return(true)
+        allow(enhancer).to receive(:evaluate_action).and_return(nil)
+      end
+
+      it 'falls back to mechanical and returns source: :mechanical' do
+        result = client.evaluate_moral_action(
+          action:               'help_stranger',
+          affected_foundations: %i[care fairness]
+        )
+        expect(result[:source]).to eq(:mechanical)
+      end
+    end
+  end
+
+  describe '#pose_moral_dilemma' do
+    it 'creates a dilemma' do
+      result = client.pose_moral_dilemma(
+        description: 'Test dilemma',
+        options:     options
+      )
+      expect(result[:success]).to be true
+      expect(result[:dilemma][:description]).to eq('Test dilemma')
+    end
+  end
+
+  describe '#resolve_moral_dilemma' do
+    let(:dilemma_id) do
+      client.pose_moral_dilemma(description: 'Resolve test', options: options)[:dilemma][:id]
+    end
+
+    it 'resolves a dilemma' do
+      result = client.resolve_moral_dilemma(
+        dilemma_id: dilemma_id,
+        option_id:  'opt_a',
+        reasoning:  'Greatest good',
+        framework:  :utilitarian
+      )
+      expect(result[:success]).to be true
+      expect(result[:dilemma][:resolved]).to be true
+    end
+
+    it 'returns failure for unknown dilemma' do
+      result = client.resolve_moral_dilemma(
+        dilemma_id: 'bad_id',
+        option_id:  'opt_a',
+        reasoning:  'N/A',
+        framework:  :utilitarian
+      )
+      expect(result[:success]).to be false
+    end
+
+    context 'when LLM is available' do
+      let(:llm_result) do
+        {
+          chosen_option: 'opt_a',
+          confidence:    0.88,
+          reasoning:     'Utilitarian calculus favors this option for the greatest collective benefit.'
+        }
+      end
+
+      before do
+        allow(enhancer).to receive(:available?).and_return(true)
+        allow(enhancer).to receive(:resolve_dilemma).and_return(llm_result)
+      end
+
+      it 'returns source: :llm' do
+        result = client.resolve_moral_dilemma(
+          dilemma_id: dilemma_id,
+          option_id:  'opt_a',
+          reasoning:  'manual reasoning',
+          framework:  :utilitarian
+        )
+        expect(result[:source]).to eq(:llm)
+      end
+
+      it 'includes llm_chosen and llm_confidence' do
+        result = client.resolve_moral_dilemma(
+          dilemma_id: dilemma_id,
+          option_id:  'opt_a',
+          reasoning:  'manual reasoning',
+          framework:  :utilitarian
+        )
+        expect(result[:llm_chosen]).to eq('opt_a')
+        expect(result[:llm_confidence]).to eq(0.88)
+      end
+
+      it 'resolves successfully using LLM reasoning' do
+        result = client.resolve_moral_dilemma(
+          dilemma_id: dilemma_id,
+          option_id:  'opt_a',
+          reasoning:  'manual reasoning',
+          framework:  :utilitarian
+        )
+        expect(result[:success]).to be true
+      end
+    end
+
+    context 'when LLM is unavailable' do
+      before do
+        allow(enhancer).to receive(:available?).and_return(false)
+      end
+
+      it 'resolves mechanically without source key from LLM' do
+        result = client.resolve_moral_dilemma(
+          dilemma_id: dilemma_id,
+          option_id:  'opt_a',
+          reasoning:  'manual reasoning',
+          framework:  :utilitarian
+        )
+        expect(result[:success]).to be true
+        expect(result[:source]).to be_nil
+      end
+    end
+  end
+
+  describe '#apply_ethical_framework' do
+    let(:dilemma_id) do
+      client.pose_moral_dilemma(description: 'Framework test', options: options)[:dilemma][:id]
+    end
+
+    it 'applies a framework and returns rankings' do
+      result = client.apply_ethical_framework(dilemma_id: dilemma_id, framework: :care)
+      expect(result[:success]).to be true
+      expect(result[:rankings]).to be_an(Array)
+    end
+  end
+
+  describe '#add_moral_principle' do
+    it 'adds a principle' do
+      result = client.add_moral_principle(
+        name:        'Non-maleficence',
+        description: 'Do not harm',
+        foundation:  :care
+      )
+      expect(result[:success]).to be true
+    end
+  end
+
+  describe '#check_moral_development' do
+    it 'returns success with current stage' do
+      result = client.check_moral_development
+      expect(result[:success]).to be true
+      expect(result[:stage]).to be_a(Symbol)
+    end
+  end
+
+  describe '#moral_foundation_profile' do
+    it 'returns all foundations' do
+      result = client.moral_foundation_profile
+      expect(result[:success]).to be true
+      expect(result[:foundations].keys).to match_array(
+        Legion::Extensions::Agentic::Social::MoralReasoning::Helpers::Constants::MORAL_FOUNDATIONS
+      )
+    end
+  end
+
+  describe '#moral_stage_info' do
+    it 'returns stage, level, and description' do
+      result = client.moral_stage_info
+      expect(result[:success]).to be true
+      expect(result).to include(:stage, :level, :description)
+    end
+  end
+
+  describe '#update_moral_reasoning' do
+    it 'decays foundations and returns profile' do
+      result = client.update_moral_reasoning
+      expect(result[:success]).to be true
+      expect(result[:foundations]).to be_a(Hash)
+    end
+  end
+
+  describe '#moral_reasoning_stats' do
+    it 'returns stats including stage and counts' do
+      result = client.moral_reasoning_stats
+      expect(result[:success]).to be true
+      expect(result).to include(:stage, :total_dilemmas, :resolved_dilemmas)
+    end
+  end
+end

data/spec/legion/extensions/agentic/social/perspective_shifting/client_spec.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+require 'legion/extensions/agentic/social/perspective_shifting/client'
+
+RSpec.describe Legion::Extensions::Agentic::Social::PerspectiveShifting::Client do
+  it 'responds to all runner methods' do
+    client = described_class.new
+    expect(client).to respond_to(:add_perspective)
+    expect(client).to respond_to(:list_perspectives)
+    expect(client).to respond_to(:get_perspective)
+    expect(client).to respond_to(:add_situation)
+    expect(client).to respond_to(:list_situations)
+    expect(client).to respond_to(:generate_view)
+    expect(client).to respond_to(:views_for_situation)
+    expect(client).to respond_to(:perspective_agreement)
+    expect(client).to respond_to(:blind_spots)
+    expect(client).to respond_to(:coverage_score)
+    expect(client).to respond_to(:dominant_view)
+    expect(client).to respond_to(:synthesize)
+    expect(client).to respond_to(:most_divergent_pair)
+    expect(client).to respond_to(:engine_status)
+  end
+
+  it 'initializes with its own isolated engine per instance' do
+    c1 = described_class.new
+    c2 = described_class.new
+    c1.add_perspective(name: 'CEO', type: :stakeholder)
+    expect(c2.list_perspectives[:count]).to eq(0)
+  end
+end