lex-agentic-social 0.1.0

data/spec/legion/extensions/agentic/social/theory_of_mind/helpers/mental_state_tracker_spec.rb

@@ -0,0 +1,228 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+RSpec.describe Legion::Extensions::Agentic::Social::TheoryOfMind::Helpers::MentalStateTracker do
+  subject(:tracker) { described_class.new }
+
+  describe '#initialize' do
+    it 'starts with empty agent models' do
+      expect(tracker.agent_models).to be_empty
+    end
+
+    it 'starts with empty prediction log' do
+      expect(tracker.prediction_log).to be_empty
+    end
+  end
+
+  describe '#model_for' do
+    it 'creates a new model for unknown agent' do
+      model = tracker.model_for(:a1)
+      expect(model).to be_a(Legion::Extensions::Agentic::Social::TheoryOfMind::Helpers::AgentModel)
+      expect(model.agent_id).to eq(:a1)
+    end
+
+    it 'returns the same model on repeat call' do
+      model1 = tracker.model_for(:a1)
+      model2 = tracker.model_for(:a1)
+      expect(model1).to equal(model2)
+    end
+
+    it 'trims models beyond MAX_AGENT_MODELS' do
+      max = Legion::Extensions::Agentic::Social::TheoryOfMind::Helpers::Constants::MAX_AGENT_MODELS
+      (max + 5).times { |i| tracker.model_for(:"agent_#{i}") }
+      expect(tracker.agents_tracked).to eq(max)
+    end
+  end
+
+  describe '#update_belief' do
+    it 'stores a belief on the agent model' do
+      tracker.update_belief(agent_id: :a1, domain: :skill, content: 'expert', confidence: 0.9)
+      model = tracker.agent_models[:a1]
+      expect(model.beliefs[:skill][:content]).to eq('expert')
+    end
+  end
+
+  describe '#update_desire' do
+    it 'stores a desire on the agent model' do
+      tracker.update_desire(agent_id: :a1, goal: 'deploy', priority: :high)
+      model = tracker.agent_models[:a1]
+      expect(model.desires.first[:goal]).to eq('deploy')
+    end
+  end
+
+  describe '#infer_intention' do
+    it 'stores an intention on the agent model' do
+      tracker.infer_intention(agent_id: :a1, action: :request_help, confidence: :likely)
+      model = tracker.agent_models[:a1]
+      expect(model.intentions.first[:action]).to eq(:request_help)
+    end
+  end
+
+  describe '#predict_behavior' do
+    before do
+      tracker.update_desire(agent_id: :a1, goal: 'optimize', priority: :critical)
+      tracker.infer_intention(agent_id: :a1, action: :refactor, confidence: :certain)
+    end
+
+    it 'returns a prediction hash' do
+      result = tracker.predict_behavior(agent_id: :a1)
+      expect(result[:predicted_action]).to eq(:refactor)
+      expect(result[:underlying_desire]).to eq('optimize')
+    end
+
+    it 'adds to prediction log' do
+      tracker.predict_behavior(agent_id: :a1)
+      expect(tracker.prediction_log.size).to eq(1)
+    end
+
+    it 'returns nil for unknown agent' do
+      expect(tracker.predict_behavior(agent_id: :unknown)).to be_nil
+    end
+
+    it 'includes model accuracy' do
+      result = tracker.predict_behavior(agent_id: :a1)
+      expect(result[:model_accuracy]).to be_a(Float)
+    end
+  end
+
+  describe '#record_prediction_outcome' do
+    before { tracker.model_for(:a1) }
+
+    it 'updates the model prediction accuracy' do
+      initial = tracker.agent_models[:a1].prediction_accuracy
+      tracker.record_prediction_outcome(agent_id: :a1, outcome: :correct)
+      expect(tracker.agent_models[:a1].prediction_accuracy).to be > initial
+    end
+
+    it 'returns nil for unknown agent' do
+      expect(tracker.record_prediction_outcome(agent_id: :unknown, outcome: :correct)).to be_nil
+    end
+  end
+
+  describe '#false_belief_check' do
+    before do
+      tracker.update_belief(agent_id: :a1, domain: :status, content: 'online', confidence: 0.8)
+    end
+
+    it 'identifies false beliefs' do
+      result = tracker.false_belief_check(agent_id: :a1, known_truths: { status: 'offline' })
+      expect(result).to have_key(:status)
+      expect(result[:status][:agent_believes]).to eq('online')
+    end
+
+    it 'returns empty hash when beliefs are correct' do
+      result = tracker.false_belief_check(agent_id: :a1, known_truths: { status: 'online' })
+      expect(result).to be_empty
+    end
+
+    it 'returns nil for unknown agent' do
+      expect(tracker.false_belief_check(agent_id: :unknown, known_truths: {})).to be_nil
+    end
+  end
+
+  describe '#perspective_take' do
+    before do
+      tracker.update_belief(agent_id: :a1, domain: :task, content: 'building', confidence: 0.9)
+      tracker.update_desire(agent_id: :a1, goal: 'ship_feature', priority: :high)
+    end
+
+    it 'returns the perspective hash' do
+      result = tracker.perspective_take(agent_id: :a1)
+      expect(result[:knowledge][:task]).to eq('building')
+      expect(result[:goals]).to include('ship_feature')
+    end
+
+    it 'returns nil for unknown agent' do
+      expect(tracker.perspective_take(agent_id: :unknown)).to be_nil
+    end
+  end
+
+  describe '#compare_agents' do
+    before do
+      tracker.update_belief(agent_id: :a1, domain: :color, content: 'blue', confidence: 0.9)
+      tracker.update_belief(agent_id: :a2, domain: :color, content: 'blue', confidence: 0.8)
+      tracker.update_desire(agent_id: :a1, goal: 'win', priority: :high)
+      tracker.update_desire(agent_id: :a2, goal: 'win', priority: :critical)
+    end
+
+    it 'returns a comparison hash' do
+      result = tracker.compare_agents(agent_ids: %i[a1 a2])
+      expect(result[:agents].size).to eq(2)
+    end
+
+    it 'finds shared beliefs with consensus' do
+      result = tracker.compare_agents(agent_ids: %i[a1 a2])
+      shared = result[:shared_beliefs].find { |s| s[:domain] == :color }
+      expect(shared[:consensus]).to be true
+    end
+
+    it 'finds conflicting goals' do
+      result = tracker.compare_agents(agent_ids: %i[a1 a2])
+      expect(result[:conflicting_goals]).not_to be_empty
+    end
+
+    it 'returns nil when no agents match' do
+      expect(tracker.compare_agents(agent_ids: %i[unknown1 unknown2])).to be_nil
+    end
+  end
+
+  describe '#decay_all' do
+    it 'decays beliefs across all models' do
+      tracker.update_belief(agent_id: :a1, domain: :test, content: 'val', confidence: 0.5)
+      initial = tracker.agent_models[:a1].beliefs[:test][:confidence]
+      tracker.decay_all
+      expect(tracker.agent_models[:a1].beliefs[:test][:confidence]).to be < initial
+    end
+
+    it 'removes models with no state left' do
+      threshold = Legion::Extensions::Agentic::Social::TheoryOfMind::Helpers::Constants::CONFIDENCE_THRESHOLD
+      tracker.update_belief(agent_id: :weak, domain: :x, content: 'v', confidence: threshold + 0.005)
+      tracker.decay_all
+      expect(tracker.agent_models).not_to have_key(:weak)
+    end
+  end
+
+  describe '#agents_tracked' do
+    it 'returns 0 initially' do
+      expect(tracker.agents_tracked).to eq(0)
+    end
+
+    it 'counts tracked agents' do
+      tracker.model_for(:a1)
+      tracker.model_for(:a2)
+      expect(tracker.agents_tracked).to eq(2)
+    end
+  end
+
+  describe '#total_beliefs' do
+    it 'sums beliefs across all models' do
+      tracker.update_belief(agent_id: :a1, domain: :x, content: 'v', confidence: 0.9)
+      tracker.update_belief(agent_id: :a1, domain: :y, content: 'v', confidence: 0.9)
+      tracker.update_belief(agent_id: :a2, domain: :z, content: 'v', confidence: 0.9)
+      expect(tracker.total_beliefs).to eq(3)
+    end
+  end
+
+  describe '#avg_prediction_accuracy' do
+    it 'returns 0.0 when empty' do
+      expect(tracker.avg_prediction_accuracy).to eq(0.0)
+    end
+
+    it 'averages accuracy across models' do
+      tracker.model_for(:a1)
+      tracker.model_for(:a2)
+      expect(tracker.avg_prediction_accuracy).to eq(0.5)
+    end
+  end
+
+  describe '#to_h' do
+    it 'returns a summary hash' do
+      result = tracker.to_h
+      expect(result).to have_key(:agents_tracked)
+      expect(result).to have_key(:total_beliefs)
+      expect(result).to have_key(:avg_prediction_accuracy)
+      expect(result).to have_key(:prediction_log_size)
+    end
+  end
+end

data/spec/legion/extensions/agentic/social/theory_of_mind/runners/theory_of_mind_spec.rb

@@ -0,0 +1,221 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+RSpec.describe Legion::Extensions::Agentic::Social::TheoryOfMind::Runners::TheoryOfMind do
+  let(:mental_tracker) { Legion::Extensions::Agentic::Social::TheoryOfMind::Helpers::MentalStateTracker.new }
+
+  let(:host) do
+    Object.new.tap do |obj|
+      obj.extend(described_class)
+      obj.instance_variable_set(:@tracker, mental_tracker)
+    end
+  end
+
+  describe '#observe_agent' do
+    it 'records a belief' do
+      result = host.observe_agent(agent_id: :a1, observations: { domain: :location, belief: 'office', confidence: 0.9 })
+      expect(result[:success]).to be true
+      expect(mental_tracker.agent_models[:a1].beliefs[:location][:content]).to eq('office')
+    end
+
+    it 'records a desire' do
+      result = host.observe_agent(agent_id: :a1, observations: { goal: 'deploy' })
+      expect(result[:success]).to be true
+    end
+
+    it 'records an intention' do
+      result = host.observe_agent(agent_id: :a1, observations: { action: :send_message, action_confidence: :certain })
+      expect(result[:success]).to be true
+    end
+
+    it 'records all three at once' do
+      host.observe_agent(
+        agent_id:     :a1,
+        observations: {
+          domain: :mood, belief: 'happy', confidence: 0.8,
+          goal: 'rest', goal_priority: :low,
+          action: :idle, action_confidence: :likely
+        }
+      )
+      model = mental_tracker.agent_models[:a1]
+      expect(model.beliefs[:mood][:content]).to eq('happy')
+      expect(model.desires.first[:goal]).to eq('rest')
+      expect(model.intentions.first[:action]).to eq(:idle)
+    end
+
+    it 'returns the updated model summary' do
+      result = host.observe_agent(agent_id: :a1, observations: { domain: :x, belief: 'y', confidence: 0.5 })
+      expect(result[:model]).to have_key(:agent_id)
+      expect(result[:model][:belief_count]).to eq(1)
+    end
+  end
+
+  describe '#predict_behavior' do
+    before do
+      host.observe_agent(agent_id: :a1, observations: { goal: 'optimize', action: :refactor, action_confidence: :certain })
+    end
+
+    it 'returns a prediction' do
+      result = host.predict_behavior(agent_id: :a1)
+      expect(result[:predicted_action]).to eq(:refactor)
+      expect(result[:underlying_desire]).to eq('optimize')
+    end
+
+    it 'returns error for unknown agent' do
+      result = host.predict_behavior(agent_id: :unknown)
+      expect(result[:error]).to eq('unknown agent')
+    end
+  end
+
+  describe '#record_outcome' do
+    before do
+      host.observe_agent(agent_id: :a1, observations: { domain: :x, belief: 'y', confidence: 0.5 })
+    end
+
+    it 'returns success with updated accuracy' do
+      result = host.record_outcome(agent_id: :a1, outcome: :correct)
+      expect(result[:success]).to be true
+      expect(result[:accuracy]).to be > 0.5
+    end
+
+    it 'accepts string outcomes' do
+      result = host.record_outcome(agent_id: :a1, outcome: 'incorrect')
+      expect(result[:success]).to be true
+    end
+
+    it 'returns error for unknown agent' do
+      result = host.record_outcome(agent_id: :unknown, outcome: :correct)
+      expect(result[:error]).to eq('unknown agent')
+    end
+  end
+
+  describe '#check_false_beliefs' do
+    before do
+      host.observe_agent(agent_id: :a1, observations: { domain: :weather, belief: 'sunny', confidence: 0.9 })
+      host.observe_agent(agent_id: :a1, observations: { domain: :day, belief: 'monday', confidence: 0.8 })
+    end
+
+    it 'identifies false beliefs' do
+      result = host.check_false_beliefs(agent_id: :a1, known_truths: { weather: 'rainy', day: 'monday' })
+      expect(result[:count]).to eq(1)
+      expect(result[:false_beliefs]).to have_key(:weather)
+    end
+
+    it 'returns error for unknown agent' do
+      result = host.check_false_beliefs(agent_id: :unknown, known_truths: {})
+      expect(result[:error]).to eq('unknown agent')
+    end
+  end
+
+  describe '#perspective_take' do
+    before do
+      host.observe_agent(agent_id: :a1, observations: { domain: :task, belief: 'coding', confidence: 0.9, goal: 'ship' })
+    end
+
+    it 'returns the perspective' do
+      result = host.perspective_take(agent_id: :a1)
+      expect(result[:agent_id]).to eq(:a1)
+      expect(result[:perspective][:knowledge][:task]).to eq('coding')
+      expect(result[:perspective][:goals]).to include('ship')
+    end
+
+    it 'returns error for unknown agent' do
+      result = host.perspective_take(agent_id: :unknown)
+      expect(result[:error]).to eq('unknown agent')
+    end
+  end
+
+  describe '#compare_agents' do
+    before do
+      host.observe_agent(agent_id: :a1, observations: { domain: :lang, belief: 'ruby', confidence: 0.9, goal: 'refactor' })
+      host.observe_agent(agent_id: :a2, observations: { domain: :lang, belief: 'ruby', confidence: 0.8, goal: 'refactor' })
+    end
+
+    it 'returns comparison data' do
+      result = host.compare_agents(agent_ids: %i[a1 a2])
+      expect(result[:agents].size).to eq(2)
+      expect(result[:shared_beliefs]).not_to be_empty
+    end
+
+    it 'returns error when no agents match' do
+      result = host.compare_agents(agent_ids: %i[x1 x2])
+      expect(result[:error]).to eq('no matching agents')
+    end
+  end
+
+  describe '#mental_state' do
+    before do
+      host.observe_agent(agent_id: :a1, observations: { domain: :role, belief: 'dev', confidence: 0.8, goal: 'learn' })
+    end
+
+    it 'returns full mental state' do
+      result = host.mental_state(agent_id: :a1)
+      expect(result[:agent_id]).to eq(:a1)
+      expect(result[:beliefs]).to have_key(:role)
+      expect(result[:desires]).not_to be_empty
+      expect(result[:perspective]).to be_a(Hash)
+    end
+
+    it 'returns error for unknown agent' do
+      result = host.mental_state(agent_id: :unknown)
+      expect(result[:error]).to eq('unknown agent')
+    end
+  end
+
+  describe '#tom_stats' do
+    it 'returns aggregate statistics' do
+      host.observe_agent(agent_id: :a1, observations: { domain: :x, belief: 'y', confidence: 0.5 })
+      result = host.tom_stats
+      expect(result[:agents_tracked]).to eq(1)
+      expect(result[:total_beliefs]).to eq(1)
+      expect(result[:models]).to be_a(Hash)
+    end
+  end
+
+  describe '#update_theory_of_mind' do
+    it 'returns tracker summary' do
+      result = host.update_theory_of_mind(tick_results: {})
+      expect(result).to have_key(:agents_tracked)
+    end
+
+    it 'extracts social observations from tick results' do
+      tick = {
+        social: {
+          reputation_updates: [
+            { agent_id: :a1, standing: :respected, composite: 0.7 },
+            { agent_id: :a2, standing: :neutral, composite: 0.5 }
+          ]
+        }
+      }
+      host.update_theory_of_mind(tick_results: tick)
+      expect(mental_tracker.agents_tracked).to eq(2)
+      expect(mental_tracker.agent_models[:a1].beliefs[:social_standing][:content]).to eq(:respected)
+    end
+
+    it 'extracts mesh observations from tick results' do
+      tick = {
+        mesh_interface: {
+          received_messages: [
+            { from: :a1, type: :request },
+            { from: :a2, type: :broadcast }
+          ]
+        }
+      }
+      host.update_theory_of_mind(tick_results: tick)
+      expect(mental_tracker.agent_models[:a1].intentions.first[:action]).to eq(:request)
+    end
+
+    it 'handles empty tick results' do
+      result = host.update_theory_of_mind(tick_results: {})
+      expect(result[:agents_tracked]).to eq(0)
+    end
+
+    it 'decays beliefs during tick' do
+      host.observe_agent(agent_id: :a1, observations: { domain: :test, belief: 'val', confidence: 0.5 })
+      initial = mental_tracker.agent_models[:a1].beliefs[:test][:confidence]
+      host.update_theory_of_mind(tick_results: {})
+      expect(mental_tracker.agent_models[:a1].beliefs[:test][:confidence]).to be < initial
+    end
+  end
+end

data/spec/legion/extensions/agentic/social/trust/actors/decay_spec.rb

@@ -0,0 +1,62 @@
+# frozen_string_literal: true
+
+# Stub the framework actor base class since legionio gem is not available in test
+module Legion
+  module Extensions
+    module Actors
+      class Every # rubocop:disable Lint/EmptyClass
+      end
+    end
+  end
+end
+
+# Intercept the require in the actor file so it doesn't fail
+$LOADED_FEATURES << 'legion/extensions/actors/every'
+
+require 'legion/extensions/agentic/social/trust/actors/decay'
+
+RSpec.describe Legion::Extensions::Agentic::Social::Trust::Actor::Decay do
+  subject(:actor) { described_class.new }
+
+  describe '#runner_class' do
+    it 'returns the Trust module' do
+      expect(actor.runner_class).to eq(Legion::Extensions::Agentic::Social::Trust::Runners::Trust)
+    end
+  end
+
+  describe '#runner_function' do
+    it 'returns decay_trust' do
+      expect(actor.runner_function).to eq('decay_trust')
+    end
+  end
+
+  describe '#time' do
+    it 'returns 300 seconds' do
+      expect(actor.time).to eq(300)
+    end
+  end
+
+  describe '#run_now?' do
+    it 'returns false' do
+      expect(actor.run_now?).to be false
+    end
+  end
+
+  describe '#use_runner?' do
+    it 'returns false' do
+      expect(actor.use_runner?).to be false
+    end
+  end
+
+  describe '#check_subtask?' do
+    it 'returns false' do
+      expect(actor.check_subtask?).to be false
+    end
+  end
+
+  describe '#generate_task?' do
+    it 'returns false' do
+      expect(actor.generate_task?).to be false
+    end
+  end
+end

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

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+require 'legion/extensions/agentic/social/trust/client'
+
+RSpec.describe Legion::Extensions::Agentic::Social::Trust::Client do
+  let(:client) { described_class.new }
+
+  it 'responds to trust runner methods' do
+    expect(client).to respond_to(:get_trust)
+    expect(client).to respond_to(:record_trust_interaction)
+    expect(client).to respond_to(:reinforce_trust_dimension)
+    expect(client).to respond_to(:decay_trust)
+    expect(client).to respond_to(:trusted_agents)
+    expect(client).to respond_to(:delegatable_agents)
+    expect(client).to respond_to(:trust_status)
+  end
+end