lex-agentic-affect 0.1.0

data/spec/legion/extensions/agentic/affect/reappraisal/helpers/llm_enhancer_spec.rb

@@ -0,0 +1,161 @@
+# frozen_string_literal: true
+
+RSpec.describe Legion::Extensions::Agentic::Affect::Reappraisal::Helpers::LlmEnhancer do
+  subject(:enhancer) { described_class }
+
+  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 '.generate_reappraisal' do
+    let(:mock_response) do
+      content = "REAPPRAISAL: This outage is an opportunity to strengthen the system's resilience and learn " \
+                'from the failure patterns that emerged under load.'
+      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 a hash with new_appraisal' do
+      result = enhancer.generate_reappraisal(
+        event_content:     'production outage',
+        initial_appraisal: 'catastrophic failure',
+        strategy:          :benefit_finding,
+        valence:           -0.7,
+        intensity:         0.5
+      )
+      expect(result).to be_a(Hash)
+      expect(result[:new_appraisal]).to be_a(String)
+      expect(result[:new_appraisal]).not_to be_empty
+    end
+
+    it 'strips leading/trailing whitespace from the reappraisal' do
+      result = enhancer.generate_reappraisal(
+        event_content:     'production outage',
+        initial_appraisal: 'catastrophic failure',
+        strategy:          :benefit_finding,
+        valence:           -0.7,
+        intensity:         0.5
+      )
+      expect(result[:new_appraisal]).to eq(result[:new_appraisal].strip)
+    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 error')
+      end
+
+      it 'returns nil' do
+        result = enhancer.generate_reappraisal(
+          event_content:     'test event',
+          initial_appraisal: 'bad',
+          strategy:          :reinterpretation,
+          valence:           -0.5,
+          intensity:         0.4
+        )
+        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.generate_reappraisal(
+          event_content:     'test',
+          initial_appraisal: 'test',
+          strategy:          :distancing,
+          valence:           -0.3,
+          intensity:         0.5
+        )
+        expect(result).to be_nil
+      end
+    end
+
+    context 'when response lacks REAPPRAISAL marker' do
+      before do
+        bad_response = double('response', content: 'Just some text without the format marker.')
+        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.generate_reappraisal(
+          event_content:     'test',
+          initial_appraisal: 'test',
+          strategy:          :normalizing,
+          valence:           -0.4,
+          intensity:         0.3
+        )
+        expect(result).to be_nil
+      end
+    end
+
+    context 'with different strategies' do
+      %i[reinterpretation distancing benefit_finding normalizing perspective_taking temporal_distancing].each do |strategy|
+        it "works with strategy #{strategy}" do
+          result = enhancer.generate_reappraisal(
+            event_content:     'a difficult situation',
+            initial_appraisal: 'overwhelming',
+            strategy:          strategy,
+            valence:           -0.6,
+            intensity:         0.7
+          )
+          expect(result).to be_a(Hash)
+          expect(result[:new_appraisal]).to be_a(String)
+        end
+      end
+    end
+  end
+end

data/spec/legion/extensions/agentic/affect/reappraisal/helpers/reappraisal_engine_spec.rb

@@ -0,0 +1,211 @@
+# frozen_string_literal: true
+
+RSpec.describe Legion::Extensions::Agentic::Affect::Reappraisal::Helpers::ReappraisalEngine do
+  subject(:engine) { described_class.new }
+
+  let(:neg_event_id) do
+    engine.register_event(content: 'failure', valence: -0.7, intensity: 0.4, appraisal: 'terrible').id
+  end
+
+  let(:pos_event_id) do
+    engine.register_event(content: 'success', valence: 0.6, intensity: 0.3, appraisal: 'great').id
+  end
+
+  describe '#register_event' do
+    it 'returns an EmotionalEvent' do
+      event = engine.register_event(content: 'test', valence: -0.5, intensity: 0.4, appraisal: 'bad')
+      expect(event).to be_a(Legion::Extensions::Agentic::Affect::Reappraisal::Helpers::EmotionalEvent)
+    end
+
+    it 'stores the event by id' do
+      event = engine.register_event(content: 'test', valence: -0.5, intensity: 0.4, appraisal: 'bad')
+      expect(engine.events[event.id]).to eq(event)
+    end
+
+    it 'increments event count' do
+      expect { engine.register_event(content: 'x', valence: 0.0, intensity: 0.5, appraisal: 'neutral') }
+        .to change { engine.events.size }.by(1)
+    end
+  end
+
+  describe '#reappraise' do
+    it 'returns success for valid inputs' do
+      result = engine.reappraise(event_id: neg_event_id, strategy: :reinterpretation, new_appraisal: 'reframed')
+      expect(result[:success]).to be true
+    end
+
+    it 'returns event_id and strategy in response' do
+      result = engine.reappraise(event_id: neg_event_id, strategy: :distancing, new_appraisal: 'distant view')
+      expect(result[:event_id]).to eq(neg_event_id)
+      expect(result[:strategy]).to eq(:distancing)
+    end
+
+    it 'returns current_valence after reappraisal' do
+      result = engine.reappraise(event_id: neg_event_id, strategy: :benefit_finding, new_appraisal: 'learned')
+      expect(result[:current_valence]).to be_a(Float)
+    end
+
+    it 'fails with :event_not_found for unknown id' do
+      result = engine.reappraise(event_id: 'unknown-id', strategy: :reinterpretation, new_appraisal: 'x')
+      expect(result[:success]).to be false
+      expect(result[:reason]).to eq(:event_not_found)
+    end
+
+    it 'fails with :invalid_strategy for bad strategy' do
+      result = engine.reappraise(event_id: neg_event_id, strategy: :magic, new_appraisal: 'x')
+      expect(result[:success]).to be false
+      expect(result[:reason]).to eq(:invalid_strategy)
+    end
+
+    it 'logs the reappraisal in reappraisal_log' do
+      engine.reappraise(event_id: neg_event_id, strategy: :normalizing, new_appraisal: 'normal')
+      expect(engine.reappraisal_log.size).to eq(1)
+      expect(engine.reappraisal_log.first[:strategy]).to eq(:normalizing)
+    end
+
+    it 'records valence_change and intensity_change in log' do
+      engine.reappraise(event_id: neg_event_id, strategy: :reinterpretation, new_appraisal: 'changed')
+      log = engine.reappraisal_log.first
+      expect(log[:valence_change]).to be_a(Float)
+      expect(log[:intensity_change]).to be_a(Float)
+    end
+  end
+
+  describe '#auto_reappraise' do
+    it 'succeeds for a valid event' do
+      result = engine.auto_reappraise(event_id: neg_event_id)
+      expect(result[:success]).to be true
+    end
+
+    it 'selects distancing for intense negative event' do
+      intense_neg_id = engine.register_event(content: 'crisis', valence: -0.8, intensity: 0.9, appraisal: 'worst').id
+      result = engine.auto_reappraise(event_id: intense_neg_id)
+      expect(result[:strategy]).to eq(:distancing)
+    end
+
+    it 'selects reinterpretation for non-intense negative event' do
+      result = engine.auto_reappraise(event_id: neg_event_id)
+      expect(result[:strategy]).to eq(:reinterpretation)
+    end
+
+    it 'selects benefit_finding for mild positive events' do
+      result = engine.auto_reappraise(event_id: pos_event_id)
+      expect(result[:strategy]).to eq(:benefit_finding)
+    end
+
+    it 'fails for unknown event_id' do
+      result = engine.auto_reappraise(event_id: 'missing')
+      expect(result[:success]).to be false
+      expect(result[:reason]).to eq(:event_not_found)
+    end
+  end
+
+  describe '#negative_events' do
+    it 'returns events with negative current_valence' do
+      neg_event_id
+      pos_event_id
+      expect(engine.negative_events.size).to eq(1)
+      expect(engine.negative_events.first.negative?).to be true
+    end
+
+    it 'returns empty array when no negative events' do
+      pos_event_id
+      expect(engine.negative_events).to be_empty
+    end
+  end
+
+  describe '#intense_events' do
+    it 'returns events with high intensity' do
+      engine.register_event(content: 'crisis', valence: -0.8, intensity: 0.9, appraisal: 'worst')
+      engine.register_event(content: 'calm', valence: 0.2, intensity: 0.2, appraisal: 'fine')
+      expect(engine.intense_events.size).to eq(1)
+    end
+  end
+
+  describe '#most_regulated' do
+    before do
+      # Register two events and reappraise one multiple times
+      @event_a_id = engine.register_event(content: 'a', valence: -0.6, intensity: 0.4, appraisal: 'bad').id
+      @event_b_id = engine.register_event(content: 'b', valence: -0.4, intensity: 0.3, appraisal: 'ok').id
+      3.times { engine.reappraise(event_id: @event_a_id, strategy: :reinterpretation, new_appraisal: 'better') }
+    end
+
+    it 'returns events sorted by regulation_amount descending' do
+      regulated = engine.most_regulated(limit: 2)
+      expect(regulated.first.id).to eq(@event_a_id)
+    end
+
+    it 'respects limit parameter' do
+      expect(engine.most_regulated(limit: 1).size).to eq(1)
+    end
+  end
+
+  describe '#strategy_effectiveness' do
+    before do
+      engine.reappraise(event_id: neg_event_id, strategy: :reinterpretation, new_appraisal: 'view 1')
+      engine.reappraise(event_id: neg_event_id, strategy: :reinterpretation, new_appraisal: 'view 2')
+      engine.reappraise(event_id: neg_event_id, strategy: :distancing, new_appraisal: 'distant')
+    end
+
+    it 'returns a hash keyed by strategy' do
+      eff = engine.strategy_effectiveness
+      expect(eff).to have_key(:reinterpretation)
+      expect(eff).to have_key(:distancing)
+    end
+
+    it 'computes average valence_change per strategy' do
+      eff = engine.strategy_effectiveness
+      expect(eff[:reinterpretation]).to be_a(Float)
+    end
+  end
+
+  describe '#average_regulation' do
+    it 'returns 0.0 for empty engine' do
+      expect(engine.average_regulation).to eq(0.0)
+    end
+
+    it 'returns positive value after events and reappraisals' do
+      neg_event_id
+      engine.reappraise(event_id: neg_event_id, strategy: :reinterpretation, new_appraisal: 'better')
+      expect(engine.average_regulation).to be > 0.0
+    end
+  end
+
+  describe '#overall_regulation_ability' do
+    it 'returns 0.0 for empty engine' do
+      expect(engine.overall_regulation_ability).to eq(0.0)
+    end
+
+    it 'returns value between 0 and 1' do
+      neg_event_id
+      engine.reappraise(event_id: neg_event_id, strategy: :benefit_finding, new_appraisal: 'learned')
+      expect(engine.overall_regulation_ability).to be_between(0.0, 1.0)
+    end
+  end
+
+  describe '#reappraisal_report' do
+    it 'returns a hash with all expected keys' do
+      report = engine.reappraisal_report
+      expect(report).to include(:total_events, :total_reappraisals, :negative_events,
+                                :intense_events, :average_regulation,
+                                :overall_regulation_ability, :strategy_effectiveness, :most_regulated)
+    end
+
+    it 'reflects actual counts' do
+      neg_event_id
+      pos_event_id
+      engine.reappraise(event_id: neg_event_id, strategy: :normalizing, new_appraisal: 'normal')
+      report = engine.reappraisal_report
+      expect(report[:total_events]).to eq(2)
+      expect(report[:total_reappraisals]).to eq(1)
+    end
+  end
+
+  describe '#to_h' do
+    it 'returns a hash with expected keys' do
+      h = engine.to_h
+      expect(h).to include(:events, :reappraisal_log, :average_regulation,
+                           :overall_regulation_ability, :strategy_effectiveness)
+    end
+  end
+end

data/spec/legion/extensions/agentic/affect/reappraisal/runners/cognitive_reappraisal_spec.rb

@@ -0,0 +1,312 @@
+# frozen_string_literal: true
+
+require 'legion/extensions/agentic/affect/reappraisal/client'
+
+RSpec.describe Legion::Extensions::Agentic::Affect::Reappraisal::Runners::CognitiveReappraisal do
+  let(:engine)   { Legion::Extensions::Agentic::Affect::Reappraisal::Helpers::ReappraisalEngine.new }
+  let(:client)   { Legion::Extensions::Agentic::Affect::Reappraisal::Client.new(engine: engine) }
+  let(:enhancer) { Legion::Extensions::Agentic::Affect::Reappraisal::Helpers::LlmEnhancer }
+
+  let(:registered) do
+    client.register_event(
+      content:   'production outage',
+      valence:   -0.7,
+      intensity: 0.5,
+      appraisal: 'catastrophic failure',
+      engine:    engine
+    )
+  end
+
+  describe '#register_event' do
+    it 'returns success: true' do
+      expect(registered[:success]).to be true
+    end
+
+    it 'returns a valid UUID event_id' do
+      expect(registered[:event_id]).to match(/\A[0-9a-f-]{36}\z/)
+    end
+
+    it 'returns valence and intensity' do
+      expect(registered[:valence]).to be_a(Float)
+      expect(registered[:intensity]).to be_a(Float)
+    end
+
+    it 'reports negative: true for negative event' do
+      expect(registered[:negative]).to be true
+    end
+
+    it 'reports intense: false for moderate intensity' do
+      expect(registered[:intense]).to be false
+    end
+
+    it 'reports intense: true for high intensity' do
+      result = client.register_event(
+        content: 'extreme', valence: -0.9, intensity: 0.9, appraisal: 'worst', engine: engine
+      )
+      expect(result[:intense]).to be true
+    end
+  end
+
+  describe '#reappraise_event' do
+    it 'succeeds with valid event_id and strategy' do
+      result = client.reappraise_event(
+        event_id:      registered[:event_id],
+        strategy:      :reinterpretation,
+        new_appraisal: 'learning opportunity',
+        engine:        engine
+      )
+      expect(result[:success]).to be true
+    end
+
+    it 'returns current_valence after reappraisal' do
+      result = client.reappraise_event(
+        event_id:      registered[:event_id],
+        strategy:      :benefit_finding,
+        new_appraisal: 'builds resilience',
+        engine:        engine
+      )
+      expect(result[:current_valence]).to be_a(Float)
+    end
+
+    it 'rejects invalid strategy' do
+      result = client.reappraise_event(
+        event_id:      registered[:event_id],
+        strategy:      :magic_thinking,
+        new_appraisal: 'irrelevant',
+        engine:        engine
+      )
+      expect(result[:success]).to be false
+      expect(result[:reason]).to eq(:invalid_strategy)
+      expect(result[:valid_strategies]).to eq(Legion::Extensions::Agentic::Affect::Reappraisal::Helpers::Constants::STRATEGIES)
+    end
+
+    it 'rejects unknown event_id' do
+      result = client.reappraise_event(
+        event_id:      'does-not-exist',
+        strategy:      :distancing,
+        new_appraisal: 'distant',
+        engine:        engine
+      )
+      expect(result[:success]).to be false
+    end
+  end
+
+  describe '#auto_reappraise_event' do
+    it 'succeeds for a known event' do
+      result = client.auto_reappraise_event(event_id: registered[:event_id], engine: engine)
+      expect(result[:success]).to be true
+    end
+
+    it 'selects an appropriate strategy automatically' do
+      result = client.auto_reappraise_event(event_id: registered[:event_id], engine: engine)
+      expect(Legion::Extensions::Agentic::Affect::Reappraisal::Helpers::Constants::STRATEGIES).to include(result[:strategy])
+    end
+
+    it 'fails gracefully for unknown event' do
+      result = client.auto_reappraise_event(event_id: 'missing', engine: engine)
+      expect(result[:success]).to be false
+    end
+
+    context 'when LLM is available' do
+      let(:llm_appraisal) { 'This outage reveals systemic resilience that can be strengthened.' }
+
+      before do
+        allow(enhancer).to receive(:available?).and_return(true)
+        allow(enhancer).to receive(:generate_reappraisal).and_return({ new_appraisal: llm_appraisal })
+      end
+
+      it 'uses the LLM-generated appraisal text' do
+        result = client.auto_reappraise_event(event_id: registered[:event_id], engine: engine)
+        expect(result[:success]).to be true
+        expect(engine.events[registered[:event_id]].appraisal).to eq(llm_appraisal)
+      end
+
+      it 'calls the LLM enhancer with event details' do
+        expect(enhancer).to receive(:generate_reappraisal).with(
+          hash_including(
+            event_content:     'production outage',
+            initial_appraisal: 'catastrophic failure'
+          )
+        ).and_return({ new_appraisal: llm_appraisal })
+        client.auto_reappraise_event(event_id: registered[:event_id], engine: engine)
+      end
+    end
+
+    context 'when LLM is unavailable' do
+      before do
+        allow(enhancer).to receive(:available?).and_return(false)
+      end
+
+      it 'falls back to mechanical appraisal stub' do
+        result = client.auto_reappraise_event(event_id: registered[:event_id], engine: engine)
+        expect(result[:success]).to be true
+        expect(engine.events[registered[:event_id]].appraisal).to match(/auto-reappraised via/)
+      end
+    end
+
+    context 'when LLM returns nil' do
+      before do
+        allow(enhancer).to receive(:available?).and_return(true)
+        allow(enhancer).to receive(:generate_reappraisal).and_return(nil)
+      end
+
+      it 'falls back to mechanical appraisal stub' do
+        result = client.auto_reappraise_event(event_id: registered[:event_id], engine: engine)
+        expect(result[:success]).to be true
+        expect(engine.events[registered[:event_id]].appraisal).to match(/auto-reappraised via/)
+      end
+    end
+  end
+
+  describe '#negative_events' do
+    before { registered }
+
+    it 'returns count and events array' do
+      result = client.negative_events(engine: engine)
+      expect(result).to have_key(:events)
+      expect(result).to have_key(:count)
+    end
+
+    it 'includes the registered negative event' do
+      result = client.negative_events(engine: engine)
+      expect(result[:count]).to be >= 1
+    end
+  end
+
+  describe '#intense_events' do
+    it 'returns empty when no intense events' do
+      registered
+      result = client.intense_events(engine: engine)
+      expect(result[:count]).to eq(0)
+    end
+
+    it 'returns intense events when present' do
+      client.register_event(content: 'crisis', valence: -0.9, intensity: 0.95, appraisal: 'awful', engine: engine)
+      result = client.intense_events(engine: engine)
+      expect(result[:count]).to be >= 1
+    end
+  end
+
+  describe '#most_regulated_events' do
+    before do
+      registered
+      3.times do
+        client.reappraise_event(
+          event_id:      registered[:event_id],
+          strategy:      :reinterpretation,
+          new_appraisal: 'better each time',
+          engine:        engine
+        )
+      end
+    end
+
+    it 'returns events and count' do
+      result = client.most_regulated_events(limit: 3, engine: engine)
+      expect(result).to have_key(:events)
+      expect(result).to have_key(:count)
+    end
+
+    it 'respects the limit' do
+      result = client.most_regulated_events(limit: 1, engine: engine)
+      expect(result[:events].size).to eq(1)
+    end
+  end
+
+  describe '#reappraisal_status' do
+    before { registered }
+
+    it 'returns overall_regulation_ability' do
+      result = client.reappraisal_status(engine: engine)
+      expect(result).to have_key(:overall_regulation_ability)
+    end
+
+    it 'returns total_events count' do
+      result = client.reappraisal_status(engine: engine)
+      expect(result[:total_events]).to be >= 1
+    end
+
+    it 'returns strategy_effectiveness hash' do
+      result = client.reappraisal_status(engine: engine)
+      expect(result[:strategy_effectiveness]).to be_a(Hash)
+    end
+  end
+
+  describe '#reappraisal_report' do
+    before do
+      registered
+      client.reappraise_event(
+        event_id:      registered[:event_id],
+        strategy:      :perspective_taking,
+        new_appraisal: 'systemic issue, not personal failure',
+        engine:        engine
+      )
+    end
+
+    it 'returns success: true' do
+      result = client.reappraisal_report(engine: engine)
+      expect(result[:success]).to be true
+    end
+
+    it 'includes a report hash' do
+      result = client.reappraisal_report(engine: engine)
+      expect(result[:report]).to be_a(Hash)
+    end
+
+    it 'report includes total_events and total_reappraisals' do
+      result = client.reappraisal_report(engine: engine)
+      expect(result[:report][:total_events]).to eq(1)
+      expect(result[:report][:total_reappraisals]).to eq(1)
+    end
+  end
+
+  describe '#regulate_pending_events' do
+    it 'returns checked, regulated, and event_ids keys' do
+      result = client.regulate_pending_events(engine: engine)
+      expect(result).to include(:checked, :regulated, :event_ids)
+    end
+
+    it 'returns zero regulated when no events registered' do
+      result = client.regulate_pending_events(engine: engine)
+      expect(result[:regulated]).to eq(0)
+      expect(result[:event_ids]).to eq([])
+    end
+
+    it 'regulates negative unreappraisals events' do
+      registered
+      result = client.regulate_pending_events(engine: engine)
+      expect(result[:regulated]).to eq(1)
+      expect(result[:event_ids]).to include(registered[:event_id])
+    end
+
+    it 'skips events that have already been reappraised' do
+      registered
+      client.reappraise_event(
+        event_id:      registered[:event_id],
+        strategy:      :reinterpretation,
+        new_appraisal: 'already handled',
+        engine:        engine
+      )
+      result = client.regulate_pending_events(engine: engine)
+      expect(result[:regulated]).to eq(0)
+    end
+
+    it 'skips positive events' do
+      client.register_event(
+        content:   'great news',
+        valence:   0.8,
+        intensity: 0.3,
+        appraisal: 'wonderful',
+        engine:    engine
+      )
+      result = client.regulate_pending_events(engine: engine)
+      expect(result[:regulated]).to eq(0)
+    end
+
+    it 'returns checked equal to total event count' do
+      registered
+      client.register_event(content: 'another', valence: 0.5, intensity: 0.2, appraisal: 'fine', engine: engine)
+      result = client.regulate_pending_events(engine: engine)
+      expect(result[:checked]).to eq(2)
+    end
+  end
+end