lex-agentic-social 0.1.0

data/spec/legion/extensions/agentic/social/social/helpers/social_graph_spec.rb

@@ -0,0 +1,322 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+RSpec.describe Legion::Extensions::Agentic::Social::Social::Helpers::SocialGraph do
+  subject(:graph) { described_class.new }
+
+  describe '#initialize' do
+    it 'starts with empty groups' do
+      expect(graph.groups).to be_empty
+    end
+
+    it 'starts with empty reputation scores' do
+      expect(graph.reputation_scores).to be_empty
+    end
+
+    it 'starts with empty reciprocity ledger' do
+      expect(graph.reciprocity_ledger).to be_empty
+    end
+  end
+
+  describe '#join_group' do
+    it 'creates a new group entry' do
+      graph.join_group(group_id: :alpha)
+      expect(graph.groups).to have_key(:alpha)
+    end
+
+    it 'returns the group hash' do
+      result = graph.join_group(group_id: :alpha, role: :leader)
+      expect(result[:role]).to eq(:leader)
+    end
+
+    it 'defaults role to contributor' do
+      graph.join_group(group_id: :alpha)
+      expect(graph.groups[:alpha][:role]).to eq(:contributor)
+    end
+
+    it 'stores members' do
+      graph.join_group(group_id: :alpha, members: %w[a1 a2])
+      expect(graph.groups[:alpha][:members]).to eq(%w[a1 a2])
+    end
+
+    it 'initializes cohesion at 0.5' do
+      graph.join_group(group_id: :alpha)
+      expect(graph.groups[:alpha][:cohesion]).to eq(0.5)
+    end
+
+    it 'initializes empty violations' do
+      graph.join_group(group_id: :alpha)
+      expect(graph.groups[:alpha][:violations]).to be_empty
+    end
+
+    it 'does not overwrite existing group' do
+      graph.join_group(group_id: :alpha, role: :leader)
+      graph.join_group(group_id: :alpha, role: :observer)
+      expect(graph.groups[:alpha][:role]).to eq(:leader)
+    end
+
+    it 'trims groups beyond MAX_GROUPS' do
+      max = Legion::Extensions::Agentic::Social::Social::Helpers::Constants::MAX_GROUPS
+      (max + 3).times { |i| graph.join_group(group_id: :"group_#{i}") }
+      expect(graph.group_count).to eq(max)
+    end
+  end
+
+  describe '#leave_group' do
+    before { graph.join_group(group_id: :alpha) }
+
+    it 'removes the group' do
+      graph.leave_group(:alpha)
+      expect(graph.groups).not_to have_key(:alpha)
+    end
+
+    it 'returns nil for unknown group' do
+      expect(graph.leave_group(:unknown)).to be_nil
+    end
+  end
+
+  describe '#update_role' do
+    before { graph.join_group(group_id: :alpha, role: :contributor) }
+
+    it 'updates the role' do
+      graph.update_role(group_id: :alpha, role: :leader)
+      expect(graph.groups[:alpha][:role]).to eq(:leader)
+    end
+
+    it 'returns nil for unknown group' do
+      expect(graph.update_role(group_id: :unknown, role: :leader)).to be_nil
+    end
+
+    it 'returns nil for invalid role' do
+      expect(graph.update_role(group_id: :alpha, role: :invalid)).to be_nil
+    end
+  end
+
+  describe '#update_reputation' do
+    it 'initializes reputation scores for new agent' do
+      graph.update_reputation(agent_id: :a1, dimension: :reliability, signal: 0.8)
+      expect(graph.reputation_scores[:a1]).to be_a(Hash)
+    end
+
+    it 'updates the specified dimension via EMA' do
+      graph.update_reputation(agent_id: :a1, dimension: :reliability, signal: 1.0)
+      score = graph.reputation_scores[:a1][:reliability]
+      expect(score).to be > 0.5
+      expect(score).to be < 1.0
+    end
+
+    it 'clamps signal to 0..1' do
+      graph.update_reputation(agent_id: :a1, dimension: :reliability, signal: 5.0)
+      score = graph.reputation_scores[:a1][:reliability]
+      expect(score).to be <= 1.0
+    end
+
+    it 'returns nil for invalid dimension' do
+      result = graph.update_reputation(agent_id: :a1, dimension: :fake, signal: 0.5)
+      expect(result).to be_nil
+    end
+
+    it 'converges toward signal over repeated updates' do
+      20.times { graph.update_reputation(agent_id: :a1, dimension: :competence, signal: 0.9) }
+      expect(graph.reputation_scores[:a1][:competence]).to be > 0.8
+    end
+  end
+
+  describe '#reputation_for' do
+    before do
+      graph.update_reputation(agent_id: :a1, dimension: :reliability, signal: 0.8)
+    end
+
+    it 'returns agent_id in the result' do
+      expect(graph.reputation_for(:a1)[:agent_id]).to eq(:a1)
+    end
+
+    it 'returns a composite score' do
+      expect(graph.reputation_for(:a1)[:composite]).to be_a(Float)
+    end
+
+    it 'returns a standing classification' do
+      expect(graph.reputation_for(:a1)[:standing]).to be_a(Symbol)
+    end
+
+    it 'returns rounded scores' do
+      rep = graph.reputation_for(:a1)
+      rep[:scores].each_value do |v|
+        expect(v.to_s.split('.').last.length).to be <= 4
+      end
+    end
+
+    it 'returns nil for unknown agent' do
+      expect(graph.reputation_for(:unknown)).to be_nil
+    end
+  end
+
+  describe '#social_standing' do
+    it 'returns :neutral when no agents tracked' do
+      expect(graph.social_standing).to eq(:neutral)
+    end
+
+    it 'returns a classification symbol with agents' do
+      graph.update_reputation(agent_id: :a1, dimension: :reliability, signal: 0.9)
+      expect(graph.social_standing).to be_a(Symbol)
+    end
+  end
+
+  describe '#record_reciprocity' do
+    it 'adds an entry to the ledger' do
+      graph.record_reciprocity(agent_id: :a1, action: :helped, direction: :given)
+      expect(graph.reciprocity_ledger.size).to eq(1)
+    end
+
+    it 'tracks direction' do
+      graph.record_reciprocity(agent_id: :a1, action: :helped, direction: :given)
+      expect(graph.reciprocity_ledger.first[:direction]).to eq(:given)
+    end
+
+    it 'enforces RECIPROCITY_WINDOW' do
+      window = Legion::Extensions::Agentic::Social::Social::Helpers::Constants::RECIPROCITY_WINDOW
+      (window + 10).times do |i|
+        graph.record_reciprocity(agent_id: :a1, action: :"action_#{i}", direction: :given)
+      end
+      expect(graph.reciprocity_ledger.size).to eq(window)
+    end
+  end
+
+  describe '#reciprocity_balance' do
+    before do
+      3.times { graph.record_reciprocity(agent_id: :a1, action: :help, direction: :given) }
+      graph.record_reciprocity(agent_id: :a1, action: :assist, direction: :received)
+      2.times { graph.record_reciprocity(agent_id: :a2, action: :teach, direction: :given) }
+    end
+
+    it 'counts given correctly' do
+      expect(graph.reciprocity_balance(:a1)[:given]).to eq(3)
+    end
+
+    it 'counts received correctly' do
+      expect(graph.reciprocity_balance(:a1)[:received]).to eq(1)
+    end
+
+    it 'computes balance as given - received' do
+      expect(graph.reciprocity_balance(:a1)[:balance]).to eq(2)
+    end
+
+    it 'isolates by agent' do
+      expect(graph.reciprocity_balance(:a2)[:given]).to eq(2)
+      expect(graph.reciprocity_balance(:a2)[:received]).to eq(0)
+    end
+  end
+
+  describe '#record_violation' do
+    before { graph.join_group(group_id: :alpha) }
+
+    it 'records the violation' do
+      result = graph.record_violation(group_id: :alpha, type: :free_riding, agent_id: :a1)
+      expect(result[:type]).to eq(:free_riding)
+    end
+
+    it 'reduces cohesion' do
+      initial = graph.groups[:alpha][:cohesion]
+      graph.record_violation(group_id: :alpha, type: :defection, agent_id: :a1)
+      expect(graph.groups[:alpha][:cohesion]).to be < initial
+    end
+
+    it 'returns nil for unknown group' do
+      result = graph.record_violation(group_id: :unknown, type: :free_riding, agent_id: :a1)
+      expect(result).to be_nil
+    end
+
+    it 'returns nil for invalid violation type' do
+      result = graph.record_violation(group_id: :alpha, type: :invalid, agent_id: :a1)
+      expect(result).to be_nil
+    end
+
+    it 'cohesion does not go below 0' do
+      10.times { graph.record_violation(group_id: :alpha, type: :free_riding, agent_id: :a1) }
+      expect(graph.groups[:alpha][:cohesion]).to be >= 0.0
+    end
+  end
+
+  describe '#group_cohesion' do
+    it 'returns nil for unknown group' do
+      expect(graph.group_cohesion(:unknown)).to be_nil
+    end
+
+    it 'returns the cohesion value' do
+      graph.join_group(group_id: :alpha)
+      expect(graph.group_cohesion(:alpha)).to eq(0.5)
+    end
+  end
+
+  describe '#update_cohesion' do
+    before { graph.join_group(group_id: :alpha) }
+
+    it 'moves cohesion toward signal via EMA' do
+      graph.update_cohesion(group_id: :alpha, signal: 1.0)
+      expect(graph.group_cohesion(:alpha)).to be > 0.5
+    end
+
+    it 'clamps signal to 0..1' do
+      graph.update_cohesion(group_id: :alpha, signal: 5.0)
+      expect(graph.group_cohesion(:alpha)).to be <= 1.0
+    end
+
+    it 'returns nil for unknown group' do
+      expect(graph.update_cohesion(group_id: :unknown, signal: 0.8)).to be_nil
+    end
+  end
+
+  describe '#classify_cohesion' do
+    before { graph.join_group(group_id: :alpha) }
+
+    it 'returns :moderate for default cohesion (0.5)' do
+      expect(graph.classify_cohesion(:alpha)).to eq(:moderate)
+    end
+
+    it 'returns :tight for high cohesion' do
+      5.times { graph.update_cohesion(group_id: :alpha, signal: 1.0) }
+      10.times { graph.update_cohesion(group_id: :alpha, signal: 1.0) }
+      expect(graph.classify_cohesion(:alpha)).to eq(:tight)
+    end
+
+    it 'returns nil for unknown group' do
+      expect(graph.classify_cohesion(:unknown)).to be_nil
+    end
+  end
+
+  describe '#group_count' do
+    it 'returns 0 with no groups' do
+      expect(graph.group_count).to eq(0)
+    end
+
+    it 'returns the number of groups' do
+      graph.join_group(group_id: :alpha)
+      graph.join_group(group_id: :beta)
+      expect(graph.group_count).to eq(2)
+    end
+  end
+
+  describe '#agents_tracked' do
+    it 'returns 0 with no agents' do
+      expect(graph.agents_tracked).to eq(0)
+    end
+
+    it 'counts unique agents with reputation' do
+      graph.update_reputation(agent_id: :a1, dimension: :reliability, signal: 0.5)
+      graph.update_reputation(agent_id: :a2, dimension: :competence, signal: 0.7)
+      expect(graph.agents_tracked).to eq(2)
+    end
+  end
+
+  describe '#to_h' do
+    it 'returns a hash with expected keys' do
+      result = graph.to_h
+      expect(result).to have_key(:groups)
+      expect(result).to have_key(:group_count)
+      expect(result).to have_key(:agents_tracked)
+      expect(result).to have_key(:social_standing)
+      expect(result).to have_key(:ledger_size)
+    end
+  end
+end

data/spec/legion/extensions/agentic/social/social/runners/social_spec.rb

@@ -0,0 +1,220 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+RSpec.describe Legion::Extensions::Agentic::Social::Social::Runners::Social do
+  let(:graph) { Legion::Extensions::Agentic::Social::Social::Helpers::SocialGraph.new }
+
+  let(:host) do
+    Object.new.tap do |obj|
+      obj.extend(described_class)
+      obj.instance_variable_set(:@social_graph, graph)
+    end
+  end
+
+  describe '#join_group' do
+    it 'returns success' do
+      result = host.join_group(group_id: :alpha, role: :contributor)
+      expect(result[:success]).to be true
+    end
+
+    it 'returns the group_id and role' do
+      result = host.join_group(group_id: :alpha, role: :leader, members: %w[a1])
+      expect(result[:group_id]).to eq(:alpha)
+      expect(result[:role]).to eq(:leader)
+    end
+
+    it 'includes the group hash' do
+      result = host.join_group(group_id: :alpha)
+      expect(result[:group]).to be_a(Hash)
+    end
+  end
+
+  describe '#leave_group' do
+    before { host.join_group(group_id: :alpha) }
+
+    it 'returns success' do
+      result = host.leave_group(group_id: :alpha)
+      expect(result[:success]).to be true
+    end
+
+    it 'removes the group from the graph' do
+      host.leave_group(group_id: :alpha)
+      expect(graph.groups).not_to have_key(:alpha)
+    end
+  end
+
+  describe '#update_reputation' do
+    it 'returns success for valid dimension' do
+      result = host.update_reputation(agent_id: :a1, dimension: :reliability, signal: 0.8)
+      expect(result[:success]).to be true
+    end
+
+    it 'returns reputation hash' do
+      result = host.update_reputation(agent_id: :a1, dimension: :competence, signal: 0.9)
+      expect(result[:reputation]).to have_key(:composite)
+    end
+
+    it 'returns failure for invalid dimension' do
+      result = host.update_reputation(agent_id: :a1, dimension: :fake, signal: 0.5)
+      expect(result[:success]).to be false
+    end
+  end
+
+  describe '#agent_reputation' do
+    it 'returns reputation for known agent' do
+      host.update_reputation(agent_id: :a1, dimension: :reliability, signal: 0.8)
+      result = host.agent_reputation(agent_id: :a1)
+      expect(result[:composite]).to be_a(Float)
+    end
+
+    it 'returns error for unknown agent' do
+      result = host.agent_reputation(agent_id: :unknown)
+      expect(result[:error]).to eq('unknown agent')
+    end
+  end
+
+  describe '#reciprocity_status' do
+    it 'returns balance for agent' do
+      result = host.reciprocity_status(agent_id: :a1)
+      expect(result[:given]).to eq(0)
+      expect(result[:received]).to eq(0)
+      expect(result[:balance]).to eq(0)
+    end
+  end
+
+  describe '#record_exchange' do
+    it 'returns success' do
+      result = host.record_exchange(agent_id: :a1, action: :helped, direction: :given)
+      expect(result[:success]).to be true
+    end
+
+    it 'updates the reciprocity ledger' do
+      host.record_exchange(agent_id: :a1, action: :helped, direction: :given)
+      expect(graph.reciprocity_ledger.size).to eq(1)
+    end
+
+    it 'converts direction to symbol' do
+      host.record_exchange(agent_id: :a1, action: :helped, direction: 'received')
+      expect(graph.reciprocity_ledger.first[:direction]).to eq(:received)
+    end
+  end
+
+  describe '#report_violation' do
+    before { host.join_group(group_id: :alpha) }
+
+    it 'returns success for valid violation' do
+      result = host.report_violation(group_id: :alpha, type: :free_riding, agent_id: :a1)
+      expect(result[:success]).to be true
+    end
+
+    it 'returns the violation and cohesion' do
+      result = host.report_violation(group_id: :alpha, type: :defection, agent_id: :a1)
+      expect(result[:violation]).to be_a(Hash)
+      expect(result[:cohesion]).to be_a(Float)
+    end
+
+    it 'returns failure for invalid group' do
+      result = host.report_violation(group_id: :unknown, type: :free_riding, agent_id: :a1)
+      expect(result[:success]).to be false
+    end
+
+    it 'converts type to symbol' do
+      result = host.report_violation(group_id: :alpha, type: 'deception', agent_id: :a1)
+      expect(result[:success]).to be true
+    end
+  end
+
+  describe '#group_status' do
+    before { host.join_group(group_id: :alpha, role: :leader, members: %w[a1 a2]) }
+
+    it 'returns group details' do
+      result = host.group_status(group_id: :alpha)
+      expect(result[:group_id]).to eq(:alpha)
+      expect(result[:role]).to eq(:leader)
+      expect(result[:members]).to eq(2)
+      expect(result[:cohesion]).to be_a(Float)
+      expect(result[:cohesion_level]).to be_a(Symbol)
+      expect(result[:violations]).to eq(0)
+    end
+
+    it 'returns error for unknown group' do
+      result = host.group_status(group_id: :unknown)
+      expect(result[:error]).to eq('unknown group')
+    end
+  end
+
+  describe '#social_status' do
+    it 'returns a state hash' do
+      result = host.social_status
+      expect(result).to have_key(:groups)
+      expect(result).to have_key(:group_count)
+      expect(result).to have_key(:social_standing)
+    end
+  end
+
+  describe '#social_stats' do
+    before do
+      host.join_group(group_id: :alpha, role: :leader)
+      host.join_group(group_id: :beta, role: :contributor)
+    end
+
+    it 'returns group count' do
+      expect(host.social_stats[:groups]).to eq(2)
+    end
+
+    it 'returns group roles' do
+      roles = host.social_stats[:group_roles]
+      expect(roles[:alpha]).to eq(:leader)
+      expect(roles[:beta]).to eq(:contributor)
+    end
+
+    it 'returns ledger size' do
+      expect(host.social_stats[:ledger_size]).to eq(0)
+    end
+  end
+
+  describe '#update_social' do
+    before { host.join_group(group_id: :alpha) }
+
+    it 'returns social summary hash' do
+      result = host.update_social(tick_results: {})
+      expect(result).to have_key(:groups)
+      expect(result).to have_key(:agents_tracked)
+      expect(result).to have_key(:standing)
+      expect(result).to have_key(:ledger_size)
+    end
+
+    it 'extracts trust signals from tick results' do
+      tick = {
+        trust: {
+          updates: [
+            { agent_id: :a1, score: 0.9 },
+            { agent_id: :a2, score: 0.7 }
+          ]
+        }
+      }
+      host.update_social(tick_results: tick)
+      expect(graph.agents_tracked).to eq(2)
+    end
+
+    it 'handles missing trust data gracefully' do
+      result = host.update_social(tick_results: { trust: {} })
+      expect(result[:agents_tracked]).to eq(0)
+    end
+
+    it 'extracts mesh signals and updates cohesion' do
+      initial_cohesion = graph.group_cohesion(:alpha)
+      tick = { mesh_interface: { peer_count: 8 } }
+      host.update_social(tick_results: tick)
+      expect(graph.group_cohesion(:alpha)).to be > initial_cohesion
+    end
+
+    it 'skips mesh update when peer_count is zero' do
+      initial_cohesion = graph.group_cohesion(:alpha)
+      tick = { mesh_interface: { peer_count: 0 } }
+      host.update_social(tick_results: tick)
+      expect(graph.group_cohesion(:alpha)).to eq(initial_cohesion)
+    end
+  end
+end

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

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+RSpec.describe Legion::Extensions::Agentic::Social::SocialLearning::Client do
+  let(:client) { described_class.new }
+
+  it 'responds to all runner methods' do
+    expect(client).to respond_to(:register_model_agent)
+    expect(client).to respond_to(:observe_agent_behavior)
+    expect(client).to respond_to(:retained_behaviors)
+    expect(client).to respond_to(:reproducible_behaviors)
+    expect(client).to respond_to(:reproduce_observed_behavior)
+    expect(client).to respond_to(:reinforce_reproduction)
+    expect(client).to respond_to(:best_model_agents)
+    expect(client).to respond_to(:domain_models)
+    expect(client).to respond_to(:update_social_learning)
+    expect(client).to respond_to(:social_learning_stats)
+  end
+
+  it 'accepts an injected engine' do
+    engine = Legion::Extensions::Agentic::Social::SocialLearning::Helpers::SocialLearningEngine.new
+    injected_client = described_class.new(engine: engine)
+    result = injected_client.social_learning_stats
+    expect(result[:success]).to be true
+  end
+end

data/spec/legion/extensions/agentic/social/social_learning/helpers/constants_spec.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+RSpec.describe Legion::Extensions::Agentic::Social::SocialLearning::Helpers::Constants do
+  it 'defines MAX_MODELS' do
+    expect(described_module::MAX_MODELS).to eq(200)
+  end
+
+  it 'defines MAX_BEHAVIORS' do
+    expect(described_module::MAX_BEHAVIORS).to eq(500)
+  end
+
+  it 'defines ATTENTION_THRESHOLD' do
+    expect(described_module::ATTENTION_THRESHOLD).to eq(0.3)
+  end
+
+  it 'defines REPRODUCTION_CONFIDENCE' do
+    expect(described_module::REPRODUCTION_CONFIDENCE).to eq(0.5)
+  end
+
+  it 'defines OUTCOME_TYPES' do
+    expect(described_module::OUTCOME_TYPES).to eq(%i[positive negative neutral])
+  end
+
+  it 'defines LEARNING_STAGES' do
+    expect(described_module::LEARNING_STAGES).to eq(%i[attention retention reproduction motivation])
+  end
+
+  it 'defines MODEL_LABELS mapping' do
+    expect(described_module::MODEL_LABELS).to be_a(Hash)
+    expect(described_module::MODEL_LABELS.size).to eq(5)
+  end
+
+  it 'PRESTIGE_FLOOR is 0.0' do
+    expect(described_module::PRESTIGE_FLOOR).to eq(0.0)
+  end
+
+  it 'PRESTIGE_CEILING is 1.0' do
+    expect(described_module::PRESTIGE_CEILING).to eq(1.0)
+  end
+
+  def described_module
+    Legion::Extensions::Agentic::Social::SocialLearning::Helpers::Constants
+  end
+end