lex-agentic-affect 0.1.0

data/spec/legion/extensions/agentic/affect/motivation/helpers/constants_spec.rb

@@ -0,0 +1,111 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+RSpec.describe Legion::Extensions::Agentic::Affect::Motivation::Helpers::Constants do
+  describe 'DRIVE_TYPES' do
+    it 'defines 6 drive types' do
+      expect(described_class::DRIVE_TYPES.size).to eq(6)
+    end
+
+    it 'includes autonomy' do
+      expect(described_class::DRIVE_TYPES).to include(:autonomy)
+    end
+
+    it 'includes competence' do
+      expect(described_class::DRIVE_TYPES).to include(:competence)
+    end
+
+    it 'includes relatedness' do
+      expect(described_class::DRIVE_TYPES).to include(:relatedness)
+    end
+
+    it 'includes novelty' do
+      expect(described_class::DRIVE_TYPES).to include(:novelty)
+    end
+
+    it 'includes obligation' do
+      expect(described_class::DRIVE_TYPES).to include(:obligation)
+    end
+
+    it 'includes survival' do
+      expect(described_class::DRIVE_TYPES).to include(:survival)
+    end
+
+    it 'is frozen' do
+      expect(described_class::DRIVE_TYPES).to be_frozen
+    end
+  end
+
+  describe 'MOTIVATION_MODES' do
+    it 'defines 4 modes' do
+      expect(described_class::MOTIVATION_MODES).to eq(%i[approach avoidance maintenance dormant])
+    end
+
+    it 'is frozen' do
+      expect(described_class::MOTIVATION_MODES).to be_frozen
+    end
+  end
+
+  describe 'INTRINSIC_DRIVES' do
+    it 'contains autonomy, competence, relatedness, novelty' do
+      expect(described_class::INTRINSIC_DRIVES).to contain_exactly(:autonomy, :competence, :relatedness, :novelty)
+    end
+
+    it 'is a subset of DRIVE_TYPES' do
+      described_class::INTRINSIC_DRIVES.each do |d|
+        expect(described_class::DRIVE_TYPES).to include(d)
+      end
+    end
+  end
+
+  describe 'EXTRINSIC_DRIVES' do
+    it 'contains obligation and survival' do
+      expect(described_class::EXTRINSIC_DRIVES).to contain_exactly(:obligation, :survival)
+    end
+
+    it 'is a subset of DRIVE_TYPES' do
+      described_class::EXTRINSIC_DRIVES.each do |d|
+        expect(described_class::DRIVE_TYPES).to include(d)
+      end
+    end
+  end
+
+  describe 'intrinsic + extrinsic = all drives' do
+    it 'covers all drive types without overlap' do
+      all = described_class::INTRINSIC_DRIVES + described_class::EXTRINSIC_DRIVES
+      expect(all.sort).to eq(described_class::DRIVE_TYPES.sort)
+    end
+  end
+
+  describe 'thresholds' do
+    it 'APPROACH_THRESHOLD is above AVOIDANCE_THRESHOLD' do
+      expect(described_class::APPROACH_THRESHOLD).to be > described_class::AVOIDANCE_THRESHOLD
+    end
+
+    it 'AVOIDANCE_THRESHOLD is above BURNOUT_THRESHOLD' do
+      expect(described_class::AVOIDANCE_THRESHOLD).to be > described_class::BURNOUT_THRESHOLD
+    end
+
+    it 'AMOTIVATION_THRESHOLD is defined' do
+      expect(described_class::AMOTIVATION_THRESHOLD).to be_a(Float)
+    end
+
+    it 'DRIVE_DECAY_RATE is small and positive' do
+      expect(described_class::DRIVE_DECAY_RATE).to be > 0.0
+      expect(described_class::DRIVE_DECAY_RATE).to be < 0.1
+    end
+
+    it 'DRIVE_ALPHA is a valid EMA alpha' do
+      expect(described_class::DRIVE_ALPHA).to be > 0.0
+      expect(described_class::DRIVE_ALPHA).to be < 1.0
+    end
+  end
+
+  describe 'MAX_GOALS' do
+    it 'is a positive integer' do
+      expect(described_class::MAX_GOALS).to be_a(Integer)
+      expect(described_class::MAX_GOALS).to be > 0
+    end
+  end
+end

data/spec/legion/extensions/agentic/affect/motivation/helpers/drive_state_spec.rb

@@ -0,0 +1,183 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+RSpec.describe Legion::Extensions::Agentic::Affect::Motivation::Helpers::DriveState do
+  subject(:state) { described_class.new }
+
+  describe '#initialize' do
+    it 'starts all drives at 0.5' do
+      Legion::Extensions::Agentic::Affect::Motivation::Helpers::Constants::DRIVE_TYPES.each do |type|
+        expect(state.drives[type][:level]).to eq(0.5)
+      end
+    end
+
+    it 'starts all drives unsatisfied' do
+      state.drives.each_value do |d|
+        expect(d[:satisfied]).to be false
+      end
+    end
+
+    it 'starts with nil last_signal for all drives' do
+      state.drives.each_value do |d|
+        expect(d[:last_signal]).to be_nil
+      end
+    end
+
+    it 'initializes all defined drive types' do
+      expect(state.drives.keys).to match_array(Legion::Extensions::Agentic::Affect::Motivation::Helpers::Constants::DRIVE_TYPES)
+    end
+  end
+
+  describe '#update_drive' do
+    it 'updates level via EMA' do
+      initial = state.drive_level(:autonomy)
+      state.update_drive(:autonomy, 1.0)
+      expect(state.drive_level(:autonomy)).to be > initial
+    end
+
+    it 'clamps signal to 0.0..1.0' do
+      state.update_drive(:competence, 5.0)
+      expect(state.drive_level(:competence)).to be <= 1.0
+    end
+
+    it 'clamps negative signal to 0.0' do
+      state.update_drive(:competence, -1.0)
+      expect(state.drive_level(:competence)).to be >= 0.0
+    end
+
+    it 'marks drive satisfied when level crosses 0.6' do
+      10.times { state.update_drive(:autonomy, 1.0) }
+      expect(state.satisfied?(:autonomy)).to be true
+    end
+
+    it 'sets last_signal timestamp' do
+      state.update_drive(:relatedness, 0.8)
+      expect(state.drives[:relatedness][:last_signal]).to be_a(Time)
+    end
+
+    it 'ignores unknown drive types' do
+      expect { state.update_drive(:unknown_drive, 0.5) }.not_to raise_error
+    end
+  end
+
+  describe '#drive_level' do
+    it 'returns level for known drive' do
+      expect(state.drive_level(:autonomy)).to eq(0.5)
+    end
+
+    it 'returns 0.0 for unknown drive' do
+      expect(state.drive_level(:nonexistent)).to eq(0.0)
+    end
+  end
+
+  describe '#satisfied?' do
+    it 'returns false initially' do
+      expect(state.satisfied?(:competence)).to be false
+    end
+
+    it 'returns false for unknown drive' do
+      expect(state.satisfied?(:nonexistent)).to be false
+    end
+
+    it 'returns true after sufficiently high signals' do
+      10.times { state.update_drive(:competence, 1.0) }
+      expect(state.satisfied?(:competence)).to be true
+    end
+  end
+
+  describe '#intrinsic_average' do
+    it 'returns a float' do
+      expect(state.intrinsic_average).to be_a(Float)
+    end
+
+    it 'reflects only intrinsic drives' do
+      Legion::Extensions::Agentic::Affect::Motivation::Helpers::Constants::INTRINSIC_DRIVES.each do |d|
+        10.times { state.update_drive(d, 1.0) }
+      end
+      expect(state.intrinsic_average).to be > state.extrinsic_average
+    end
+  end
+
+  describe '#extrinsic_average' do
+    it 'returns a float' do
+      expect(state.extrinsic_average).to be_a(Float)
+    end
+
+    it 'reflects only extrinsic drives' do
+      Legion::Extensions::Agentic::Affect::Motivation::Helpers::Constants::EXTRINSIC_DRIVES.each do |d|
+        10.times { state.update_drive(d, 1.0) }
+      end
+      expect(state.extrinsic_average).to be > state.intrinsic_average
+    end
+  end
+
+  describe '#overall_level' do
+    it 'starts at 0.5' do
+      expect(state.overall_level).to eq(0.5)
+    end
+
+    it 'increases when drives are signalled high' do
+      initial = state.overall_level
+      Legion::Extensions::Agentic::Affect::Motivation::Helpers::Constants::DRIVE_TYPES.each do |d|
+        state.update_drive(d, 1.0)
+      end
+      expect(state.overall_level).to be > initial
+    end
+  end
+
+  describe '#current_mode' do
+    it 'returns :maintenance at initial 0.5' do
+      expect(state.current_mode).to eq(:maintenance)
+    end
+
+    it 'returns :approach when overall level is high' do
+      Legion::Extensions::Agentic::Affect::Motivation::Helpers::Constants::DRIVE_TYPES.each do |d|
+        10.times { state.update_drive(d, 1.0) }
+      end
+      expect(state.current_mode).to eq(:approach)
+    end
+
+    it 'returns :dormant when overall level is very low' do
+      Legion::Extensions::Agentic::Affect::Motivation::Helpers::Constants::DRIVE_TYPES.each do |d|
+        20.times { state.update_drive(d, 0.0) }
+      end
+      expect(state.current_mode).to eq(:dormant)
+    end
+
+    it 'returns one of the defined modes' do
+      modes = Legion::Extensions::Agentic::Affect::Motivation::Helpers::Constants::MOTIVATION_MODES
+      expect(modes).to include(state.current_mode)
+    end
+  end
+
+  describe '#decay_all' do
+    it 'decreases all drive levels' do
+      initial_levels = state.drives.transform_values { |d| d[:level] }
+      state.decay_all
+      state.drives.each do |type, d|
+        expect(d[:level]).to be <= initial_levels[type]
+      end
+    end
+
+    it 'does not drop drives below 0.0' do
+      20.times { state.decay_all }
+      state.drives.each_value do |d|
+        expect(d[:level]).to be >= 0.0
+      end
+    end
+  end
+
+  describe '#amotivated?' do
+    it 'returns false at initial levels' do
+      expect(state.amotivated?).to be false
+    end
+
+    it 'returns true when all drives are very low' do
+      Legion::Extensions::Agentic::Affect::Motivation::Helpers::Constants::DRIVE_TYPES.each do |d|
+        20.times { state.update_drive(d, 0.0) }
+      end
+      expect(state.amotivated?).to be true
+    end
+  end
+end

data/spec/legion/extensions/agentic/affect/motivation/helpers/motivation_store_spec.rb

@@ -0,0 +1,185 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+RSpec.describe Legion::Extensions::Agentic::Affect::Motivation::Helpers::MotivationStore do
+  subject(:store) { described_class.new }
+
+  describe '#initialize' do
+    it 'creates a default drive_state' do
+      expect(store.drive_state).to be_a(Legion::Extensions::Agentic::Affect::Motivation::Helpers::DriveState)
+    end
+
+    it 'starts with no goal motivations' do
+      expect(store.goal_motivations).to be_empty
+    end
+
+    it 'accepts an injected drive_state' do
+      ds = Legion::Extensions::Agentic::Affect::Motivation::Helpers::DriveState.new
+      s  = described_class.new(drive_state: ds)
+      expect(s.drive_state).to be(ds)
+    end
+  end
+
+  describe '#commit_goal' do
+    it 'commits a goal with valid drives' do
+      result = store.commit_goal('goal_1', %i[autonomy competence])
+      expect(result).to be true
+    end
+
+    it 'stores the goal with drives and energy' do
+      store.commit_goal('goal_1', %i[autonomy])
+      entry = store.goal_motivations['goal_1']
+      expect(entry).to include(:drives, :energy, :committed)
+    end
+
+    it 'returns false for empty valid drives' do
+      result = store.commit_goal('bad_goal', [:nonexistent_drive])
+      expect(result).to be false
+    end
+
+    it 'filters invalid drives from list' do
+      result = store.commit_goal('mixed', %i[autonomy fake_drive])
+      expect(result).to be true
+      expect(store.goal_motivations['mixed'][:drives]).to eq([:autonomy])
+    end
+
+    it 'overwrites existing goal on recommit' do
+      store.commit_goal('goal_a', [:autonomy])
+      store.commit_goal('goal_a', [:competence])
+      expect(store.goal_motivations['goal_a'][:drives]).to eq([:competence])
+    end
+  end
+
+  describe '#release_goal' do
+    it 'removes the goal from tracking' do
+      store.commit_goal('goal_to_remove', [:autonomy])
+      store.release_goal('goal_to_remove')
+      expect(store.goal_motivations).not_to have_key('goal_to_remove')
+    end
+
+    it 'returns true even for unknown goal ids' do
+      expect(store.release_goal('nonexistent')).to be true
+    end
+  end
+
+  describe '#goal_energy' do
+    it 'returns 0.0 for unknown goal' do
+      expect(store.goal_energy('unknown')).to eq(0.0)
+    end
+
+    it 'returns a Float between 0 and 1 for a committed goal' do
+      store.commit_goal('energized', %i[autonomy competence])
+      energy = store.goal_energy('energized')
+      expect(energy).to be_a(Float)
+      expect(energy).to be_between(0.0, 1.0)
+    end
+  end
+
+  describe '#most_motivated_goal' do
+    it 'returns nil result when no goals committed' do
+      result = store.most_motivated_goal
+      expect(result).to be_nil
+    end
+
+    it 'returns the goal with highest energy' do
+      store.commit_goal('low_goal', [:obligation])
+      store.commit_goal('high_goal', %i[autonomy competence relatedness novelty])
+      # Signal high drives for high_goal
+      %i[autonomy competence relatedness novelty].each do |d|
+        5.times { store.drive_state.update_drive(d, 1.0) }
+      end
+      result = store.most_motivated_goal
+      expect(result[:goal_id]).to eq('high_goal')
+    end
+
+    it 'includes goal_id, energy, and drives in result' do
+      store.commit_goal('g1', [:autonomy])
+      result = store.most_motivated_goal
+      expect(result).to include(:goal_id, :energy, :drives)
+    end
+  end
+
+  describe '#burnout_check' do
+    it 'returns burnout false initially' do
+      result = store.burnout_check
+      expect(result[:burnout]).to be false
+    end
+
+    it 'returns overall_level in result' do
+      result = store.burnout_check
+      expect(result[:overall_level]).to be_a(Float)
+    end
+
+    it 'returns low_motivation_ticks in result' do
+      result = store.burnout_check
+      expect(result).to have_key(:low_motivation_ticks)
+    end
+
+    it 'increments low_motivation_ticks when level is very low' do
+      Legion::Extensions::Agentic::Affect::Motivation::Helpers::Constants::DRIVE_TYPES.each do |d|
+        20.times { store.drive_state.update_drive(d, 0.0) }
+      end
+      store.burnout_check
+      result = store.burnout_check
+      expect(result[:low_motivation_ticks]).to be >= 1
+    end
+
+    it 'detects burnout after 10 consecutive low ticks' do
+      Legion::Extensions::Agentic::Affect::Motivation::Helpers::Constants::DRIVE_TYPES.each do |d|
+        20.times { store.drive_state.update_drive(d, 0.0) }
+      end
+      11.times { store.burnout_check }
+      result = store.burnout_check
+      expect(result[:burnout]).to be true
+    end
+
+    it 'resets counter when level recovers' do
+      Legion::Extensions::Agentic::Affect::Motivation::Helpers::Constants::DRIVE_TYPES.each do |d|
+        20.times { store.drive_state.update_drive(d, 0.0) }
+      end
+      5.times { store.burnout_check }
+
+      Legion::Extensions::Agentic::Affect::Motivation::Helpers::Constants::DRIVE_TYPES.each do |d|
+        10.times { store.drive_state.update_drive(d, 1.0) }
+      end
+      result = store.burnout_check
+      expect(result[:low_motivation_ticks]).to eq(0)
+    end
+  end
+
+  describe '#stats' do
+    it 'returns overall_level' do
+      expect(store.stats).to have_key(:overall_level)
+    end
+
+    it 'returns current_mode' do
+      expect(store.stats).to have_key(:current_mode)
+    end
+
+    it 'returns intrinsic_average' do
+      expect(store.stats).to have_key(:intrinsic_average)
+    end
+
+    it 'returns extrinsic_average' do
+      expect(store.stats).to have_key(:extrinsic_average)
+    end
+
+    it 'returns amotivated flag' do
+      expect(store.stats).to have_key(:amotivated)
+    end
+
+    it 'returns goal_count' do
+      store.commit_goal('g1', [:autonomy])
+      expect(store.stats[:goal_count]).to eq(1)
+    end
+  end
+
+  describe 'goal cap (MAX_GOALS)' do
+    it 'does not exceed MAX_GOALS entries' do
+      max = Legion::Extensions::Agentic::Affect::Motivation::Helpers::Constants::MAX_GOALS
+      (max + 5).times { |i| store.commit_goal("goal_#{i}", [:autonomy]) }
+      expect(store.goal_motivations.size).to be <= max
+    end
+  end
+end