lex-agentic-self 0.1.0

data/spec/legion/extensions/agentic/self/self_talk/helpers/dialogue_spec.rb

@@ -0,0 +1,191 @@
+# frozen_string_literal: true
+
+RSpec.describe Legion::Extensions::Agentic::Self::SelfTalk::Helpers::Dialogue do
+  subject(:dialogue) { described_class.new(topic: 'Should I refactor the cache layer?') }
+
+  let(:voice_id) { 'voice-abc' }
+
+  describe '#initialize' do
+    it 'assigns a UUID id' do
+      expect(dialogue.id).to match(/\A[0-9a-f-]{36}\z/)
+    end
+
+    it 'assigns topic' do
+      expect(dialogue.topic).to eq('Should I refactor the cache layer?')
+    end
+
+    it 'starts with empty turns' do
+      expect(dialogue.turns).to be_empty
+    end
+
+    it 'starts with :open status' do
+      expect(dialogue.status).to eq(:open)
+    end
+
+    it 'starts with nil conclusion' do
+      expect(dialogue.conclusion).to be_nil
+    end
+
+    it 'sets created_at' do
+      expect(dialogue.created_at).to be_a(Time)
+    end
+  end
+
+  describe '#add_turn!' do
+    it 'adds a turn and returns the DialogueTurn' do
+      turn = dialogue.add_turn!(voice_id: voice_id, content: 'Yes, it needs refactoring')
+      expect(turn).to be_a(Legion::Extensions::Agentic::Self::SelfTalk::Helpers::DialogueTurn)
+      expect(dialogue.turn_count).to eq(1)
+    end
+
+    it 'returns false when dialogue is not active' do
+      dialogue.conclude!('done')
+      result = dialogue.add_turn!(voice_id: voice_id, content: 'Late thought')
+      expect(result).to be false
+    end
+
+    it 'returns false when turn limit is reached' do
+      stub_const('Legion::Extensions::Agentic::Self::SelfTalk::Helpers::Constants::MAX_TURNS_PER_DIALOGUE', 2)
+      dialogue.add_turn!(voice_id: voice_id, content: 'Turn 1')
+      dialogue.add_turn!(voice_id: voice_id, content: 'Turn 2')
+      result = dialogue.add_turn!(voice_id: voice_id, content: 'Turn 3')
+      expect(result).to be false
+    end
+
+    it 'accepts position and strength' do
+      turn = dialogue.add_turn!(voice_id: voice_id, content: 'Oppose it', position: :oppose, strength: 0.8)
+      expect(turn.position).to eq(:oppose)
+      expect(turn.strength).to eq(0.8)
+    end
+  end
+
+  describe '#conclude!' do
+    it 'sets status to :concluded and stores summary' do
+      dialogue.conclude!('We should refactor')
+      expect(dialogue.status).to eq(:concluded)
+      expect(dialogue.conclusion).to eq('We should refactor')
+    end
+
+    it 'returns true on success' do
+      expect(dialogue.conclude!('done')).to be true
+    end
+
+    it 'returns false if already concluded' do
+      dialogue.conclude!('first')
+      expect(dialogue.conclude!('second')).to be false
+    end
+  end
+
+  describe '#deadlock!' do
+    it 'sets status to :deadlocked' do
+      dialogue.deadlock!
+      expect(dialogue.status).to eq(:deadlocked)
+    end
+
+    it 'returns true on success' do
+      expect(dialogue.deadlock!).to be true
+    end
+
+    it 'returns false if not active' do
+      dialogue.conclude!('done')
+      expect(dialogue.deadlock!).to be false
+    end
+  end
+
+  describe '#abandon!' do
+    it 'sets status to :abandoned' do
+      dialogue.abandon!
+      expect(dialogue.status).to eq(:abandoned)
+    end
+
+    it 'returns false if already closed' do
+      dialogue.deadlock!
+      expect(dialogue.abandon!).to be false
+    end
+  end
+
+  describe '#active?' do
+    it 'is true when status is :open' do
+      expect(dialogue.active?).to be true
+    end
+
+    it 'is false after conclusion' do
+      dialogue.conclude!('done')
+      expect(dialogue.active?).to be false
+    end
+  end
+
+  describe '#concluded?' do
+    it 'is false initially' do
+      expect(dialogue.concluded?).to be false
+    end
+
+    it 'is true after conclude!' do
+      dialogue.conclude!('done')
+      expect(dialogue.concluded?).to be true
+    end
+  end
+
+  describe '#voice_positions' do
+    it 'returns empty hash when no turns' do
+      expect(dialogue.voice_positions).to eq({})
+    end
+
+    it 'returns average strength per voice' do
+      dialogue.add_turn!(voice_id: 'v1', content: 'A', strength: 0.4)
+      dialogue.add_turn!(voice_id: 'v1', content: 'B', strength: 0.6)
+      positions = dialogue.voice_positions
+      expect(positions['v1']).to be_within(0.001).of(0.5)
+    end
+
+    it 'tracks multiple voices separately' do
+      dialogue.add_turn!(voice_id: 'v1', content: 'A', strength: 0.8)
+      dialogue.add_turn!(voice_id: 'v2', content: 'B', strength: 0.2)
+      positions = dialogue.voice_positions
+      expect(positions['v1']).to be > positions['v2']
+    end
+  end
+
+  describe '#consensus_score' do
+    it 'returns 1.0 when no turns' do
+      expect(dialogue.consensus_score).to eq(1.0)
+    end
+
+    it 'returns 0.5 when no support or oppose turns' do
+      dialogue.add_turn!(voice_id: voice_id, content: 'A question', position: :question)
+      expect(dialogue.consensus_score).to eq(0.5)
+    end
+
+    it 'returns high score when all turns support' do
+      dialogue.add_turn!(voice_id: voice_id, content: 'Support 1', position: :support, strength: 0.9)
+      dialogue.add_turn!(voice_id: voice_id, content: 'Support 2', position: :support, strength: 0.8)
+      expect(dialogue.consensus_score).to eq(1.0)
+    end
+
+    it 'returns ~0.5 when support and oppose are balanced' do
+      dialogue.add_turn!(voice_id: 'v1', content: 'Support', position: :support, strength: 0.5)
+      dialogue.add_turn!(voice_id: 'v2', content: 'Oppose', position: :oppose, strength: 0.5)
+      expect(dialogue.consensus_score).to be_within(0.01).of(0.5)
+    end
+  end
+
+  describe '#consensus_label' do
+    it 'returns a symbol from CONSENSUS_LABELS' do
+      valid = %i[unanimous agreement mixed disagreement conflict]
+      expect(valid).to include(dialogue.consensus_label)
+    end
+  end
+
+  describe '#to_h' do
+    it 'includes expected keys' do
+      h = dialogue.to_h
+      expect(h).to include(:id, :topic, :status, :conclusion, :turn_count, :consensus_score, :consensus_label, :created_at, :turns)
+    end
+
+    it 'turns is an array' do
+      dialogue.add_turn!(voice_id: voice_id, content: 'x')
+      expect(dialogue.to_h[:turns]).to be_an(Array)
+      expect(dialogue.to_h[:turns].size).to eq(1)
+    end
+  end
+end

data/spec/legion/extensions/agentic/self/self_talk/helpers/dialogue_turn_spec.rb

@@ -0,0 +1,78 @@
+# frozen_string_literal: true
+
+RSpec.describe Legion::Extensions::Agentic::Self::SelfTalk::Helpers::DialogueTurn do
+  let(:dialogue_id) { 'dlg-001' }
+  let(:voice_id)    { 'voice-001' }
+
+  subject(:turn) do
+    described_class.new(dialogue_id: dialogue_id, voice_id: voice_id, content: 'This is a thought')
+  end
+
+  describe '#initialize' do
+    it 'assigns a UUID id' do
+      expect(turn.id).to match(/\A[0-9a-f-]{36}\z/)
+    end
+
+    it 'assigns dialogue_id' do
+      expect(turn.dialogue_id).to eq(dialogue_id)
+    end
+
+    it 'assigns voice_id' do
+      expect(turn.voice_id).to eq(voice_id)
+    end
+
+    it 'assigns content' do
+      expect(turn.content).to eq('This is a thought')
+    end
+
+    it 'defaults position to :clarify' do
+      expect(turn.position).to eq(:clarify)
+    end
+
+    it 'defaults strength to 0.5' do
+      expect(turn.strength).to eq(0.5)
+    end
+
+    it 'accepts valid position' do
+      t = described_class.new(dialogue_id: dialogue_id, voice_id: voice_id, content: 'x', position: :support)
+      expect(t.position).to eq(:support)
+    end
+
+    it 'falls back to :clarify for unknown position' do
+      t = described_class.new(dialogue_id: dialogue_id, voice_id: voice_id, content: 'x', position: :unknown_pos)
+      expect(t.position).to eq(:clarify)
+    end
+
+    it 'clamps strength above 1.0' do
+      t = described_class.new(dialogue_id: dialogue_id, voice_id: voice_id, content: 'x', strength: 2.0)
+      expect(t.strength).to eq(1.0)
+    end
+
+    it 'clamps strength below 0.0' do
+      t = described_class.new(dialogue_id: dialogue_id, voice_id: voice_id, content: 'x', strength: -1.0)
+      expect(t.strength).to eq(0.0)
+    end
+
+    it 'sets created_at' do
+      expect(turn.created_at).to be_a(Time)
+    end
+  end
+
+  describe 'POSITIONS' do
+    it 'includes the four valid positions' do
+      expect(described_class::POSITIONS).to include(:support, :oppose, :question, :clarify)
+    end
+  end
+
+  describe '#to_h' do
+    it 'returns a hash with expected keys' do
+      h = turn.to_h
+      expect(h).to include(:id, :dialogue_id, :voice_id, :content, :position, :strength, :created_at)
+    end
+
+    it 'rounds strength to 10 decimal places' do
+      h = turn.to_h
+      expect(h[:strength]).to be_a(Float)
+    end
+  end
+end

data/spec/legion/extensions/agentic/self/self_talk/helpers/inner_voice_spec.rb

@@ -0,0 +1,172 @@
+# frozen_string_literal: true
+
+RSpec.describe Legion::Extensions::Agentic::Self::SelfTalk::Helpers::InnerVoice do
+  subject(:voice) { described_class.new(name: 'Critic', voice_type: :critic) }
+
+  describe '#initialize' do
+    it 'assigns a UUID id' do
+      expect(voice.id).to match(/\A[0-9a-f-]{36}\z/)
+    end
+
+    it 'assigns name' do
+      expect(voice.name).to eq('Critic')
+    end
+
+    it 'assigns voice_type' do
+      expect(voice.voice_type).to eq(:critic)
+    end
+
+    it 'defaults volume to DEFAULT_VOLUME' do
+      expect(voice.volume).to eq(0.5)
+    end
+
+    it 'accepts custom volume' do
+      v = described_class.new(name: 'Loud', voice_type: :encourager, volume: 0.9)
+      expect(v.volume).to eq(0.9)
+    end
+
+    it 'clamps volume above 1.0' do
+      v = described_class.new(name: 'Over', voice_type: :analyst, volume: 1.5)
+      expect(v.volume).to eq(1.0)
+    end
+
+    it 'clamps volume below 0.0' do
+      v = described_class.new(name: 'Under', voice_type: :rebel, volume: -0.5)
+      expect(v.volume).to eq(0.0)
+    end
+
+    it 'defaults active to true' do
+      expect(voice.active).to be true
+    end
+
+    it 'defaults bias_direction to nil' do
+      expect(voice.bias_direction).to be_nil
+    end
+
+    it 'accepts bias_direction' do
+      v = described_class.new(name: 'Biased', voice_type: :pragmatist, bias_direction: :conservative)
+      expect(v.bias_direction).to eq(:conservative)
+    end
+
+    it 'sets created_at' do
+      expect(voice.created_at).to be_a(Time)
+    end
+  end
+
+  describe '#amplify!' do
+    it 'increases volume by VOLUME_BOOST by default' do
+      before = voice.volume
+      voice.amplify!
+      expect(voice.volume).to be_within(0.001).of(before + 0.1)
+    end
+
+    it 'accepts custom amount' do
+      voice.amplify!(0.2)
+      expect(voice.volume).to be_within(0.001).of(0.7)
+    end
+
+    it 'clamps at 1.0' do
+      v = described_class.new(name: 'Max', voice_type: :visionary, volume: 0.95)
+      v.amplify!(0.2)
+      expect(v.volume).to eq(1.0)
+    end
+
+    it 'returns self for chaining' do
+      expect(voice.amplify!).to equal(voice)
+    end
+  end
+
+  describe '#dampen!' do
+    it 'decreases volume by VOLUME_DECAY by default' do
+      before = voice.volume
+      voice.dampen!
+      expect(voice.volume).to be_within(0.001).of(before - 0.05)
+    end
+
+    it 'accepts custom amount' do
+      voice.dampen!(0.3)
+      expect(voice.volume).to be_within(0.001).of(0.2)
+    end
+
+    it 'clamps at 0.0' do
+      v = described_class.new(name: 'Min', voice_type: :caretaker, volume: 0.02)
+      v.dampen!(0.1)
+      expect(v.volume).to eq(0.0)
+    end
+
+    it 'returns self for chaining' do
+      expect(voice.dampen!).to equal(voice)
+    end
+  end
+
+  describe '#mute!' do
+    it 'sets active to false' do
+      voice.mute!
+      expect(voice.active).to be false
+    end
+
+    it 'returns self for chaining' do
+      expect(voice.mute!).to equal(voice)
+    end
+  end
+
+  describe '#unmute!' do
+    it 'sets active to true after muting' do
+      voice.mute!
+      voice.unmute!
+      expect(voice.active).to be true
+    end
+
+    it 'returns self for chaining' do
+      expect(voice.unmute!).to equal(voice)
+    end
+  end
+
+  describe '#dominant?' do
+    it 'returns true when volume >= 0.7' do
+      v = described_class.new(name: 'Dom', voice_type: :analyst, volume: 0.7)
+      expect(v.dominant?).to be true
+    end
+
+    it 'returns false when volume < 0.7' do
+      v = described_class.new(name: 'Not', voice_type: :analyst, volume: 0.69)
+      expect(v.dominant?).to be false
+    end
+  end
+
+  describe '#quiet?' do
+    it 'returns true when volume <= 0.3' do
+      v = described_class.new(name: 'Quiet', voice_type: :caretaker, volume: 0.3)
+      expect(v.quiet?).to be true
+    end
+
+    it 'returns false when volume > 0.3' do
+      v = described_class.new(name: 'NotQuiet', voice_type: :caretaker, volume: 0.31)
+      expect(v.quiet?).to be false
+    end
+  end
+
+  describe '#volume_label' do
+    it 'returns :commanding for loud voices' do
+      v = described_class.new(name: 'L', voice_type: :rebel, volume: 0.9)
+      expect(v.volume_label).to eq(:commanding)
+    end
+
+    it 'returns :silent for muted-volume voices' do
+      v = described_class.new(name: 'S', voice_type: :rebel, volume: 0.05)
+      expect(v.volume_label).to eq(:silent)
+    end
+  end
+
+  describe '#to_h' do
+    it 'returns a hash with expected keys' do
+      h = voice.to_h
+      expect(h).to include(:id, :name, :voice_type, :volume, :volume_label, :bias_direction, :active, :dominant, :quiet, :created_at)
+    end
+
+    it 'rounds volume to 10 decimal places' do
+      h = voice.to_h
+      expect(h[:volume]).to be_a(Float)
+    end
+  end
+end

data/spec/legion/extensions/agentic/self/self_talk/helpers/llm_enhancer_spec.rb

@@ -0,0 +1,206 @@
+# frozen_string_literal: true
+
+RSpec.describe Legion::Extensions::Agentic::Self::SelfTalk::Helpers::LlmEnhancer do
+  describe '.available?' do
+    context 'when Legion::LLM is not defined' do
+      it 'returns false' do
+        hide_const('Legion::LLM')
+        expect(described_class.available?).to be false
+      end
+    end
+
+    context 'when Legion::LLM is defined but not started' do
+      it 'returns false' do
+        llm_double = double('Legion::LLM', started?: false)
+        stub_const('Legion::LLM', llm_double)
+        expect(described_class.available?).to be false
+      end
+    end
+
+    context 'when Legion::LLM is started' do
+      it 'returns true' do
+        llm_double = double('Legion::LLM', started?: true)
+        stub_const('Legion::LLM', llm_double)
+        expect(described_class.available?).to be true
+      end
+    end
+
+    context 'when Legion::LLM raises an error' do
+      it 'returns false' do
+        llm_double = double('Legion::LLM')
+        allow(llm_double).to receive(:respond_to?).and_raise(StandardError)
+        stub_const('Legion::LLM', llm_double)
+        expect(described_class.available?).to be false
+      end
+    end
+  end
+
+  describe '.generate_turn' do
+    let(:prior_turns) do
+      [
+        { voice_name: 'Analyst', voice_id: 'uuid-1', position: :support,  content: 'The data supports this.' },
+        { voice_name: 'Critic',  voice_id: 'uuid-2', position: :oppose,   content: 'There are serious risks.' }
+      ]
+    end
+
+    context 'when LLM returns a valid formatted response' do
+      it 'returns content and position hash' do
+        response_double = double('response', content: "POSITION: oppose\nCONTENT: The risks outweigh the benefits here.")
+        chat_double = double('chat')
+        allow(chat_double).to receive(:with_instructions)
+        allow(chat_double).to receive(:ask).and_return(response_double)
+        llm_double = double('Legion::LLM', started?: true)
+        allow(llm_double).to receive(:chat).and_return(chat_double)
+        stub_const('Legion::LLM', llm_double)
+
+        result = described_class.generate_turn(
+          voice_type:  :critic,
+          topic:       'Should we proceed with the plan?',
+          prior_turns: prior_turns
+        )
+
+        expect(result).to be_a(Hash)
+        expect(result[:content]).to eq('The risks outweigh the benefits here.')
+        expect(result[:position]).to eq(:oppose)
+      end
+    end
+
+    context 'when LLM returns a support position' do
+      it 'parses support correctly' do
+        response_double = double('response', content: "POSITION: support\nCONTENT: I think we should go forward.")
+        chat_double = double('chat')
+        allow(chat_double).to receive(:with_instructions)
+        allow(chat_double).to receive(:ask).and_return(response_double)
+        llm_double = double('Legion::LLM', started?: true)
+        allow(llm_double).to receive(:chat).and_return(chat_double)
+        stub_const('Legion::LLM', llm_double)
+
+        result = described_class.generate_turn(
+          voice_type:  :encourager,
+          topic:       'Should we proceed?',
+          prior_turns: []
+        )
+
+        expect(result[:position]).to eq(:support)
+      end
+    end
+
+    context 'when LLM returns unparseable response' do
+      it 'returns nil' do
+        response_double = double('response', content: 'This is not formatted correctly.')
+        chat_double = double('chat')
+        allow(chat_double).to receive(:with_instructions)
+        allow(chat_double).to receive(:ask).and_return(response_double)
+        llm_double = double('Legion::LLM', started?: true)
+        allow(llm_double).to receive(:chat).and_return(chat_double)
+        stub_const('Legion::LLM', llm_double)
+
+        result = described_class.generate_turn(
+          voice_type:  :analyst,
+          topic:       'test',
+          prior_turns: []
+        )
+
+        expect(result).to be_nil
+      end
+    end
+
+    context 'when LLM returns nil' do
+      it 'returns nil' do
+        chat_double = double('chat')
+        allow(chat_double).to receive(:with_instructions)
+        allow(chat_double).to receive(:ask).and_return(nil)
+        llm_double = double('Legion::LLM', started?: true)
+        allow(llm_double).to receive(:chat).and_return(chat_double)
+        stub_const('Legion::LLM', llm_double)
+
+        result = described_class.generate_turn(voice_type: :analyst, topic: 'test', prior_turns: [])
+        expect(result).to be_nil
+      end
+    end
+
+    context 'when an error occurs' do
+      it 'returns nil and logs a warning' do
+        llm_double = double('Legion::LLM', started?: true)
+        allow(llm_double).to receive(:chat).and_raise(StandardError, 'timeout')
+        stub_const('Legion::LLM', llm_double)
+
+        expect(Legion::Logging).to receive(:warn).with(/self_talk:llm.*generate_turn failed/)
+        result = described_class.generate_turn(voice_type: :critic, topic: 'test', prior_turns: [])
+        expect(result).to be_nil
+      end
+    end
+  end
+
+  describe '.summarize_dialogue' do
+    let(:turns) do
+      [
+        { voice_name: 'Analyst', voice_id: 'uuid-1', position: :support,  content: 'Evidence is strong.' },
+        { voice_name: 'Critic',  voice_id: 'uuid-2', position: :oppose,   content: 'Too risky.' },
+        { voice_name: 'Pragmatist', voice_id: 'uuid-3', position: :clarify, content: 'Let us scope this down.' }
+      ]
+    end
+
+    context 'when LLM returns a valid formatted response' do
+      it 'returns summary and recommendation hash' do
+        response_double = double('response',
+                                 content: "RECOMMENDATION: abstain\nSUMMARY: The dialogue was split. A smaller scope was suggested.")
+        chat_double = double('chat')
+        allow(chat_double).to receive(:with_instructions)
+        allow(chat_double).to receive(:ask).and_return(response_double)
+        llm_double = double('Legion::LLM', started?: true)
+        allow(llm_double).to receive(:chat).and_return(chat_double)
+        stub_const('Legion::LLM', llm_double)
+
+        result = described_class.summarize_dialogue(topic: 'Should we proceed?', turns: turns)
+
+        expect(result).to be_a(Hash)
+        expect(result[:recommendation]).to eq(:abstain)
+        expect(result[:summary]).to include('smaller scope')
+      end
+    end
+
+    context 'when LLM returns a support recommendation' do
+      it 'parses support correctly' do
+        response_double = double('response',
+                                 content: "RECOMMENDATION: support\nSUMMARY: The group agreed to move forward.")
+        chat_double = double('chat')
+        allow(chat_double).to receive(:with_instructions)
+        allow(chat_double).to receive(:ask).and_return(response_double)
+        llm_double = double('Legion::LLM', started?: true)
+        allow(llm_double).to receive(:chat).and_return(chat_double)
+        stub_const('Legion::LLM', llm_double)
+
+        result = described_class.summarize_dialogue(topic: 'test', turns: [])
+        expect(result[:recommendation]).to eq(:support)
+      end
+    end
+
+    context 'when LLM returns unparseable response' do
+      it 'returns nil' do
+        response_double = double('response', content: 'No clear structure here.')
+        chat_double = double('chat')
+        allow(chat_double).to receive(:with_instructions)
+        allow(chat_double).to receive(:ask).and_return(response_double)
+        llm_double = double('Legion::LLM', started?: true)
+        allow(llm_double).to receive(:chat).and_return(chat_double)
+        stub_const('Legion::LLM', llm_double)
+
+        result = described_class.summarize_dialogue(topic: 'test', turns: [])
+        expect(result).to be_nil
+      end
+    end
+
+    context 'when an error occurs' do
+      it 'returns nil and logs a warning' do
+        llm_double = double('Legion::LLM', started?: true)
+        allow(llm_double).to receive(:chat).and_raise(StandardError, 'network error')
+        stub_const('Legion::LLM', llm_double)
+
+        expect(Legion::Logging).to receive(:warn).with(/self_talk:llm.*summarize_dialogue failed/)
+        result = described_class.summarize_dialogue(topic: 'test', turns: [])
+        expect(result).to be_nil
+      end
+    end
+  end
+end