lex-agentic-social 0.1.0

data/spec/legion/extensions/agentic/social/mirror_system/runners/mirror_spec.rb

@@ -0,0 +1,122 @@
+# frozen_string_literal: true
+
+RSpec.describe Legion::Extensions::Agentic::Social::MirrorSystem::Runners::Mirror do
+  let(:client) { Legion::Extensions::Agentic::Social::MirrorSystem::Client.new }
+
+  describe '#observe_behavior' do
+    it 'creates an observation' do
+      result = client.observe_behavior(agent_id: 'alice', action: :deploy, domain: :infra)
+      expect(result[:success]).to be true
+      expect(result[:observation][:agent_id]).to eq('alice')
+      expect(result[:observation][:action]).to eq(:deploy)
+    end
+
+    it 'boosts resonance on repeat observation' do
+      client.observe_behavior(agent_id: 'alice', action: :deploy, domain: :infra)
+      result = client.observe_behavior(agent_id: 'alice', action: :deploy, domain: :infra)
+      expect(result[:observation][:observation_count]).to eq(2)
+    end
+  end
+
+  describe '#imitate_behavior' do
+    it 'returns imitated: false with no observations' do
+      result = client.imitate_behavior(action: :deploy, domain: :infra)
+      expect(result[:success]).to be true
+      expect(result[:imitated]).to be false
+    end
+
+    it 'imitates observed behavior' do
+      client.observe_behavior(agent_id: 'alice', action: :deploy, domain: :infra)
+      result = client.imitate_behavior(action: :deploy, domain: :infra)
+      expect(result[:imitated]).to be true
+      expect(result[:source]).to eq('alice')
+      expect(result[:fidelity]).to be_a(Float)
+    end
+
+    it 'filters by source_agent' do
+      client.observe_behavior(agent_id: 'alice', action: :deploy, domain: :infra)
+      client.observe_behavior(agent_id: 'bob', action: :deploy, domain: :infra)
+      result = client.imitate_behavior(action: :deploy, domain: :infra, source_agent: 'bob')
+      expect(result[:source]).to eq('bob')
+    end
+  end
+
+  describe '#report_imitation_outcome' do
+    it 'updates fidelity on success' do
+      result = client.report_imitation_outcome(action: :deploy, domain: :infra, success_flag: true)
+      expect(result[:success]).to be true
+      expect(result[:fidelity]).to be > Legion::Extensions::Agentic::Social::MirrorSystem::Helpers::Constants::DEFAULT_FIDELITY
+    end
+
+    it 'updates fidelity on failure' do
+      result = client.report_imitation_outcome(action: :deploy, domain: :infra, success_flag: false)
+      expect(result[:fidelity]).to be < Legion::Extensions::Agentic::Social::MirrorSystem::Helpers::Constants::DEFAULT_FIDELITY
+    end
+  end
+
+  describe '#strongest_mirrors' do
+    it 'returns top mirrors' do
+      client.observe_behavior(agent_id: 'alice', action: :deploy, domain: :infra)
+      client.observe_behavior(agent_id: 'bob', action: :test, domain: :code)
+      result = client.strongest_mirrors(count: 2)
+      expect(result[:success]).to be true
+      expect(result[:count]).to eq(2)
+    end
+  end
+
+  describe '#observations_for' do
+    it 'returns observations for agent' do
+      client.observe_behavior(agent_id: 'alice', action: :deploy, domain: :infra)
+      client.observe_behavior(agent_id: 'alice', action: :test, domain: :code)
+      result = client.observations_for(agent_id: 'alice')
+      expect(result[:count]).to eq(2)
+    end
+
+    it 'returns empty for unknown agent' do
+      result = client.observations_for(agent_id: 'nobody')
+      expect(result[:count]).to eq(0)
+    end
+  end
+
+  describe '#observations_in' do
+    it 'returns observations in domain' do
+      client.observe_behavior(agent_id: 'alice', action: :deploy, domain: :infra)
+      client.observe_behavior(agent_id: 'bob', action: :test, domain: :code)
+      result = client.observations_in(domain: :infra)
+      expect(result[:count]).to eq(1)
+    end
+  end
+
+  describe '#repertoire_status' do
+    it 'starts empty' do
+      result = client.repertoire_status
+      expect(result[:size]).to eq(0)
+    end
+
+    it 'grows after imitation' do
+      client.observe_behavior(agent_id: 'alice', action: :deploy, domain: :infra)
+      client.imitate_behavior(action: :deploy, domain: :infra)
+      result = client.repertoire_status
+      expect(result[:size]).to eq(1)
+    end
+  end
+
+  describe '#update_mirror' do
+    it 'decays and returns stats' do
+      client.observe_behavior(agent_id: 'alice', action: :deploy, domain: :infra)
+      result = client.update_mirror
+      expect(result[:success]).to be true
+      expect(result).to have_key(:observations)
+      expect(result).to have_key(:repertoire)
+      expect(result).to have_key(:agents)
+    end
+  end
+
+  describe '#mirror_stats' do
+    it 'returns comprehensive stats' do
+      result = client.mirror_stats
+      expect(result[:success]).to be true
+      expect(result[:stats]).to include(:observations, :repertoire_size, :mirrored_agents)
+    end
+  end
+end

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

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+RSpec.describe Legion::Extensions::Agentic::Social::MoralReasoning::Client do
+  subject(:client) { described_class.new }
+
+  it 'responds to all runner methods' do
+    expect(client).to respond_to(:evaluate_moral_action)
+    expect(client).to respond_to(:pose_moral_dilemma)
+    expect(client).to respond_to(:resolve_moral_dilemma)
+    expect(client).to respond_to(:apply_ethical_framework)
+    expect(client).to respond_to(:add_moral_principle)
+    expect(client).to respond_to(:check_moral_development)
+    expect(client).to respond_to(:moral_foundation_profile)
+    expect(client).to respond_to(:moral_stage_info)
+    expect(client).to respond_to(:update_moral_reasoning)
+    expect(client).to respond_to(:moral_reasoning_stats)
+  end
+
+  it 'maintains separate engine state per instance' do
+    client_a = described_class.new
+    client_b = described_class.new
+
+    client_a.pose_moral_dilemma(
+      description: 'Instance A dilemma',
+      options:     [{ id: 'opt_a', description: 'Option A', foundations: [:care] }]
+    )
+
+    stats_a = client_a.moral_reasoning_stats
+    stats_b = client_b.moral_reasoning_stats
+
+    expect(stats_a[:total_dilemmas]).to eq(1)
+    expect(stats_b[:total_dilemmas]).to eq(0)
+  end
+end

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

@@ -0,0 +1,108 @@
+# frozen_string_literal: true
+
+RSpec.describe Legion::Extensions::Agentic::Social::MoralReasoning::Helpers::Dilemma do
+  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
+
+  subject(:dilemma) do
+    described_class.new(
+      id:          'dilemma_1',
+      description: 'A trolley problem',
+      options:     options,
+      domain:      :ethics,
+      severity:    0.9
+    )
+  end
+
+  describe '#initialize' do
+    it 'sets id, description, domain, severity' do
+      expect(dilemma.id).to eq('dilemma_1')
+      expect(dilemma.description).to eq('A trolley problem')
+      expect(dilemma.domain).to eq(:ethics)
+      expect(dilemma.severity).to eq(0.9)
+    end
+
+    it 'is not resolved by default' do
+      expect(dilemma.resolved?).to be false
+    end
+
+    it 'has nil chosen_option, reasoning, framework_used' do
+      expect(dilemma.chosen_option).to be_nil
+      expect(dilemma.reasoning).to be_nil
+      expect(dilemma.framework_used).to be_nil
+    end
+
+    it 'clamps severity above 1.0' do
+      d = described_class.new(id: 'x', description: 'x', options: [], severity: 1.5)
+      expect(d.severity).to eq(1.0)
+    end
+
+    it 'clamps severity below 0.0' do
+      d = described_class.new(id: 'x', description: 'x', options: [], severity: -0.5)
+      expect(d.severity).to eq(0.0)
+    end
+  end
+
+  describe '#severity_label' do
+    it 'returns :critical for severity >= 0.8' do
+      expect(dilemma.severity_label).to eq(:critical)
+    end
+
+    it 'returns :serious for severity 0.6..0.79' do
+      d = described_class.new(id: 'x', description: 'x', options: [], severity: 0.7)
+      expect(d.severity_label).to eq(:serious)
+    end
+
+    it 'returns :moderate for severity 0.4..0.59' do
+      d = described_class.new(id: 'x', description: 'x', options: [], severity: 0.5)
+      expect(d.severity_label).to eq(:moderate)
+    end
+
+    it 'returns :minor for severity 0.2..0.39' do
+      d = described_class.new(id: 'x', description: 'x', options: [], severity: 0.3)
+      expect(d.severity_label).to eq(:minor)
+    end
+
+    it 'returns :trivial for severity < 0.2' do
+      d = described_class.new(id: 'x', description: 'x', options: [], severity: 0.1)
+      expect(d.severity_label).to eq(:trivial)
+    end
+  end
+
+  describe '#resolve' do
+    before { dilemma.resolve(option_id: 'opt_a', reasoning: 'Utilitarian outcome', framework: :utilitarian) }
+
+    it 'marks dilemma as resolved' do
+      expect(dilemma.resolved?).to be true
+    end
+
+    it 'sets chosen_option' do
+      expect(dilemma.chosen_option).to eq('opt_a')
+    end
+
+    it 'sets reasoning' do
+      expect(dilemma.reasoning).to eq('Utilitarian outcome')
+    end
+
+    it 'sets framework_used' do
+      expect(dilemma.framework_used).to eq(:utilitarian)
+    end
+
+    it 'sets resolved_at timestamp' do
+      expect(dilemma.resolved_at).not_to be_nil
+    end
+  end
+
+  describe '#to_h' do
+    it 'returns a hash with all expected keys' do
+      h = dilemma.to_h
+      expect(h).to include(:id, :description, :domain, :severity, :severity_label,
+                           :options, :chosen_option, :reasoning, :framework_used,
+                           :resolved, :created_at, :resolved_at)
+    end
+  end
+end

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

@@ -0,0 +1,232 @@
+# frozen_string_literal: true
+
+RSpec.describe Legion::Extensions::Agentic::Social::MoralReasoning::Helpers::LlmEnhancer do
+  subject(:enhancer) { described_class }
+
+  let(:foundations) { { care: 0.5, fairness: 0.6, loyalty: 0.4, authority: 0.5, sanctity: 0.4, liberty: 0.5 } }
+
+  let(:options) do
+    [
+      { id: 'opt_a', description: 'Prioritize care', foundations: %i[care fairness] },
+      { id: 'opt_b', description: 'Follow rules',    foundations: %i[authority loyalty] }
+    ]
+  end
+
+  describe '.available?' do
+    context 'when Legion::LLM is not defined' do
+      it 'returns false' do
+        expect(enhancer.available?).to be false
+      end
+    end
+
+    context 'when Legion::LLM is defined but not started' do
+      before do
+        stub_const('Legion::LLM', double(respond_to?: true, started?: false))
+      end
+
+      it 'returns false' do
+        expect(enhancer.available?).to be false
+      end
+    end
+
+    context 'when Legion::LLM is started' do
+      before do
+        stub_const('Legion::LLM', double(respond_to?: true, started?: true))
+      end
+
+      it 'returns true' do
+        expect(enhancer.available?).to be true
+      end
+    end
+
+    context 'when Legion::LLM raises an error' do
+      before do
+        stub_const('Legion::LLM', double)
+        allow(Legion::LLM).to receive(:respond_to?).and_raise(StandardError, 'boom')
+      end
+
+      it 'returns false' do
+        expect(enhancer.available?).to be false
+      end
+    end
+  end
+
+  describe '.evaluate_action' do
+    let(:mock_response) do
+      content = <<~TEXT
+        REASONING: This action demonstrates care for others and promotes fairness. It strengthens the foundational values of justice and compassion.
+        IMPACT: care=0.3 | fairness=0.2 | loyalty=-0.1 | authority=0.0 | sanctity=0.1 | liberty=0.15
+      TEXT
+      double('response', content: content)
+    end
+
+    before do
+      stub_const('Legion::LLM', double)
+      chat = double('chat')
+      allow(Legion::LLM).to receive(:chat).and_return(chat)
+      allow(chat).to receive(:with_instructions)
+      allow(chat).to receive(:ask).and_return(mock_response)
+    end
+
+    it 'returns reasoning and foundation_impacts' do
+      result = enhancer.evaluate_action(
+        action:      :help_stranger,
+        description: 'Helping someone in need',
+        foundations: foundations
+      )
+      expect(result).to be_a(Hash)
+      expect(result[:reasoning]).to be_a(String)
+      expect(result[:reasoning]).not_to be_empty
+      expect(result[:foundation_impacts]).to be_a(Hash)
+    end
+
+    it 'parses all foundation impacts' do
+      result = enhancer.evaluate_action(
+        action:      :help_stranger,
+        description: 'Helping someone in need',
+        foundations: foundations
+      )
+      expect(result[:foundation_impacts].keys).to include(:care, :fairness, :loyalty)
+    end
+
+    it 'clamps foundation impact values to -1.0..1.0' do
+      result = enhancer.evaluate_action(
+        action:      :help_stranger,
+        description: 'Helping someone in need',
+        foundations: foundations
+      )
+      result[:foundation_impacts].each_value do |val|
+        expect(val).to be_between(-1.0, 1.0)
+      end
+    end
+
+    context 'when LLM raises an error' do
+      before do
+        chat = double('chat')
+        allow(Legion::LLM).to receive(:chat).and_return(chat)
+        allow(chat).to receive(:with_instructions)
+        allow(chat).to receive(:ask).and_raise(StandardError, 'API unavailable')
+      end
+
+      it 'returns nil' do
+        result = enhancer.evaluate_action(
+          action:      :help_stranger,
+          description: 'test',
+          foundations: foundations
+        )
+        expect(result).to be_nil
+      end
+    end
+
+    context 'when response has no content' do
+      before do
+        chat = double('chat')
+        allow(Legion::LLM).to receive(:chat).and_return(chat)
+        allow(chat).to receive(:with_instructions)
+        allow(chat).to receive(:ask).and_return(double('response', content: nil))
+      end
+
+      it 'returns nil' do
+        result = enhancer.evaluate_action(
+          action:      :test,
+          description: 'test',
+          foundations: foundations
+        )
+        expect(result).to be_nil
+      end
+    end
+
+    context 'when response has malformed IMPACT line' do
+      before do
+        bad_response = double('response', content: 'REASONING: some text only, no IMPACT line')
+        chat = double('chat')
+        allow(Legion::LLM).to receive(:chat).and_return(chat)
+        allow(chat).to receive(:with_instructions)
+        allow(chat).to receive(:ask).and_return(bad_response)
+      end
+
+      it 'returns nil' do
+        result = enhancer.evaluate_action(action: :test, description: 'test', foundations: foundations)
+        expect(result).to be_nil
+      end
+    end
+  end
+
+  describe '.resolve_dilemma' do
+    let(:mock_response) do
+      content = <<~TEXT
+        CHOSEN: opt_a
+        CONFIDENCE: 0.82
+        REASONING: From a care ethics perspective, prioritizing the wellbeing of those directly affected aligns with the core principle of nurturing relationships and responding to vulnerability.
+      TEXT
+      double('response', content: content)
+    end
+
+    before do
+      stub_const('Legion::LLM', double)
+      chat = double('chat')
+      allow(Legion::LLM).to receive(:chat).and_return(chat)
+      allow(chat).to receive(:with_instructions)
+      allow(chat).to receive(:ask).and_return(mock_response)
+    end
+
+    it 'returns chosen_option, confidence, and reasoning' do
+      result = enhancer.resolve_dilemma(
+        dilemma_description: 'Should the agent reveal sensitive information?',
+        options:             options,
+        framework:           :care
+      )
+      expect(result).to be_a(Hash)
+      expect(result[:chosen_option]).to eq('opt_a')
+      expect(result[:confidence]).to be_a(Float)
+      expect(result[:reasoning]).to be_a(String)
+      expect(result[:reasoning]).not_to be_empty
+    end
+
+    it 'clamps confidence to 0.0..1.0' do
+      result = enhancer.resolve_dilemma(
+        dilemma_description: 'Test',
+        options:             options,
+        framework:           :utilitarian
+      )
+      expect(result[:confidence]).to be_between(0.0, 1.0)
+    end
+
+    context 'when LLM raises an error' do
+      before do
+        chat = double('chat')
+        allow(Legion::LLM).to receive(:chat).and_return(chat)
+        allow(chat).to receive(:with_instructions)
+        allow(chat).to receive(:ask).and_raise(StandardError, 'timeout')
+      end
+
+      it 'returns nil' do
+        result = enhancer.resolve_dilemma(
+          dilemma_description: 'test',
+          options:             options,
+          framework:           :utilitarian
+        )
+        expect(result).to be_nil
+      end
+    end
+
+    context 'when response is malformed' do
+      before do
+        bad_response = double('response', content: 'This is just some text without any format markers.')
+        chat = double('chat')
+        allow(Legion::LLM).to receive(:chat).and_return(chat)
+        allow(chat).to receive(:with_instructions)
+        allow(chat).to receive(:ask).and_return(bad_response)
+      end
+
+      it 'returns nil' do
+        result = enhancer.resolve_dilemma(
+          dilemma_description: 'test',
+          options:             options,
+          framework:           :deontological
+        )
+        expect(result).to be_nil
+      end
+    end
+  end
+end