lex-conflict 0.1.1

data/spec/legion/extensions/conflict/helpers/conflict_log_spec.rb

@@ -0,0 +1,232 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+RSpec.describe Legion::Extensions::Conflict::Helpers::ConflictLog do
+  subject(:log) { described_class.new }
+
+  let(:parties)     { %w[agent human] }
+  let(:severity)    { :high }
+  let(:description) { 'disagreement over shutdown procedure' }
+
+  describe '#initialize' do
+    it 'starts with an empty conflicts hash' do
+      expect(log.conflicts).to eq({})
+    end
+  end
+
+  describe '#record' do
+    it 'returns a UUID string' do
+      id = log.record(parties: parties, severity: severity, description: description)
+      expect(id).to match(/\A[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}\z/)
+    end
+
+    it 'stores the conflict under the returned id' do
+      id = log.record(parties: parties, severity: severity, description: description)
+      expect(log.conflicts[id]).not_to be_nil
+    end
+
+    it 'sets conflict_id on the record' do
+      id = log.record(parties: parties, severity: severity, description: description)
+      expect(log.conflicts[id][:conflict_id]).to eq(id)
+    end
+
+    it 'stores the parties array' do
+      id = log.record(parties: parties, severity: severity, description: description)
+      expect(log.conflicts[id][:parties]).to eq(parties)
+    end
+
+    it 'stores the severity' do
+      id = log.record(parties: parties, severity: severity, description: description)
+      expect(log.conflicts[id][:severity]).to eq(:high)
+    end
+
+    it 'stores the description' do
+      id = log.record(parties: parties, severity: severity, description: description)
+      expect(log.conflicts[id][:description]).to eq(description)
+    end
+
+    it 'sets status to :active' do
+      id = log.record(parties: parties, severity: severity, description: description)
+      expect(log.conflicts[id][:status]).to eq(:active)
+    end
+
+    it 'sets outcome to nil' do
+      id = log.record(parties: parties, severity: severity, description: description)
+      expect(log.conflicts[id][:outcome]).to be_nil
+    end
+
+    it 'sets resolved_at to nil' do
+      id = log.record(parties: parties, severity: severity, description: description)
+      expect(log.conflicts[id][:resolved_at]).to be_nil
+    end
+
+    it 'initializes exchanges to an empty array' do
+      id = log.record(parties: parties, severity: severity, description: description)
+      expect(log.conflicts[id][:exchanges]).to eq([])
+    end
+
+    it 'sets created_at to a recent UTC time' do
+      before = Time.now.utc
+      id = log.record(parties: parties, severity: severity, description: description)
+      expect(log.conflicts[id][:created_at]).to be >= before
+    end
+
+    it 'auto-assigns posture via recommended_posture when no posture given' do
+      id = log.record(parties: parties, severity: :critical, description: description)
+      expect(log.conflicts[id][:posture]).to eq(:stubborn_presence)
+    end
+
+    it 'uses the provided posture when explicitly passed' do
+      id = log.record(parties: parties, severity: :low, description: description, posture: :persistent_engagement)
+      expect(log.conflicts[id][:posture]).to eq(:persistent_engagement)
+    end
+
+    it 'each call returns a unique id' do
+      id1 = log.record(parties: parties, severity: :low, description: 'a')
+      id2 = log.record(parties: parties, severity: :low, description: 'b')
+      expect(id1).not_to eq(id2)
+    end
+  end
+
+  describe '#add_exchange' do
+    let!(:conflict_id) { log.record(parties: parties, severity: severity, description: description) }
+
+    it 'appends to the exchanges array' do
+      log.add_exchange(conflict_id, speaker: 'agent', message: 'I object')
+      expect(log.conflicts[conflict_id][:exchanges].size).to eq(1)
+    end
+
+    it 'stores the speaker' do
+      log.add_exchange(conflict_id, speaker: 'human', message: 'proceed anyway')
+      exchange = log.conflicts[conflict_id][:exchanges].last
+      expect(exchange[:speaker]).to eq('human')
+    end
+
+    it 'stores the message' do
+      log.add_exchange(conflict_id, speaker: 'agent', message: 'I strongly disagree')
+      exchange = log.conflicts[conflict_id][:exchanges].last
+      expect(exchange[:message]).to eq('I strongly disagree')
+    end
+
+    it 'sets :at to a recent UTC time' do
+      before = Time.now.utc
+      log.add_exchange(conflict_id, speaker: 'agent', message: 'noted')
+      exchange = log.conflicts[conflict_id][:exchanges].last
+      expect(exchange[:at]).to be >= before
+    end
+
+    it 'supports multiple sequential exchanges' do
+      log.add_exchange(conflict_id, speaker: 'agent', message: 'message 1')
+      log.add_exchange(conflict_id, speaker: 'human', message: 'message 2')
+      log.add_exchange(conflict_id, speaker: 'agent', message: 'message 3')
+      expect(log.conflicts[conflict_id][:exchanges].size).to eq(3)
+    end
+
+    it 'returns nil for a non-existent conflict_id' do
+      result = log.add_exchange('no-such-id', speaker: 'agent', message: 'hello')
+      expect(result).to be_nil
+    end
+
+    it 'does not modify exchanges when conflict_id is missing' do
+      log.add_exchange('ghost-id', speaker: 'x', message: 'y')
+      expect(log.conflicts.values.flat_map { |c| c[:exchanges] }).to be_empty
+    end
+  end
+
+  describe '#resolve' do
+    let!(:conflict_id) { log.record(parties: parties, severity: severity, description: description) }
+
+    it 'returns the updated conflict hash' do
+      result = log.resolve(conflict_id, outcome: :compromise)
+      expect(result).to be_a(Hash)
+      expect(result[:conflict_id]).to eq(conflict_id)
+    end
+
+    it 'sets status to :resolved' do
+      log.resolve(conflict_id, outcome: :compromise)
+      expect(log.conflicts[conflict_id][:status]).to eq(:resolved)
+    end
+
+    it 'stores the outcome' do
+      log.resolve(conflict_id, outcome: :agreement)
+      expect(log.conflicts[conflict_id][:outcome]).to eq(:agreement)
+    end
+
+    it 'sets resolved_at to a recent UTC time' do
+      before = Time.now.utc
+      log.resolve(conflict_id, outcome: :withdrawn)
+      expect(log.conflicts[conflict_id][:resolved_at]).to be >= before
+    end
+
+    it 'stores resolution_notes when provided' do
+      log.resolve(conflict_id, outcome: :compromise, resolution_notes: 'both parties agreed to defer')
+      expect(log.conflicts[conflict_id][:resolution_notes]).to eq('both parties agreed to defer')
+    end
+
+    it 'stores nil resolution_notes when not provided' do
+      log.resolve(conflict_id, outcome: :compromise)
+      expect(log.conflicts[conflict_id][:resolution_notes]).to be_nil
+    end
+
+    it 'returns nil for a non-existent conflict_id' do
+      result = log.resolve('ghost-id', outcome: :compromise)
+      expect(result).to be_nil
+    end
+  end
+
+  describe '#active_conflicts' do
+    it 'returns empty array when no conflicts exist' do
+      expect(log.active_conflicts).to be_empty
+    end
+
+    it 'returns all unresolved conflicts' do
+      3.times { log.record(parties: parties, severity: :low, description: 'test') }
+      expect(log.active_conflicts.size).to eq(3)
+    end
+
+    it 'excludes resolved conflicts' do
+      id = log.record(parties: parties, severity: :low, description: 'resolved one')
+      log.record(parties: parties, severity: :high, description: 'still active')
+      log.resolve(id, outcome: :withdrawn)
+      expect(log.active_conflicts.size).to eq(1)
+    end
+
+    it 'returns conflict hashes with status :active' do
+      log.record(parties: parties, severity: :medium, description: 'check status')
+      log.active_conflicts.each do |conflict|
+        expect(conflict[:status]).to eq(:active)
+      end
+    end
+  end
+
+  describe '#get' do
+    it 'returns the conflict hash for a known id' do
+      id = log.record(parties: parties, severity: severity, description: description)
+      result = log.get(id)
+      expect(result[:conflict_id]).to eq(id)
+    end
+
+    it 'returns nil for an unknown id' do
+      expect(log.get('missing-id')).to be_nil
+    end
+  end
+
+  describe '#count' do
+    it 'returns 0 for a new log' do
+      expect(log.count).to eq(0)
+    end
+
+    it 'returns the total number of recorded conflicts' do
+      3.times { log.record(parties: parties, severity: :low, description: 'x') }
+      expect(log.count).to eq(3)
+    end
+
+    it 'counts resolved conflicts as well as active ones' do
+      id = log.record(parties: parties, severity: :low, description: 'resolve me')
+      log.resolve(id, outcome: :agreement)
+      log.record(parties: parties, severity: :high, description: 'still active')
+      expect(log.count).to eq(2)
+    end
+  end
+end

data/spec/legion/extensions/conflict/helpers/llm_enhancer_spec.rb

@@ -0,0 +1,189 @@
+# frozen_string_literal: true
+
+RSpec.describe Legion::Extensions::Conflict::Helpers::LlmEnhancer do
+  describe '.available?' do
+    context 'when Legion::LLM is not defined' do
+      it 'returns a falsy value' do
+        # Legion::LLM is not defined in the test environment
+        expect(described_class.available?).to be_falsy
+      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(described_class.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(described_class.available?).to be true
+      end
+    end
+
+    context 'when an error is raised' do
+      before do
+        stub_const('Legion::LLM', double)
+        allow(Legion::LLM).to receive(:respond_to?).and_raise(StandardError)
+      end
+
+      it 'returns false' do
+        expect(described_class.available?).to be false
+      end
+    end
+  end
+
+  describe '.suggest_resolution' do
+    let(:fake_response) do
+      double(content: <<~TEXT)
+        OUTCOME: resolved
+        NOTES: Both parties agreed to table the discussion for 48 hours. The agent will document its reasoning and the human partner will review before resuming.
+      TEXT
+    end
+    let(:fake_chat) { double }
+
+    before do
+      stub_const('Legion::LLM', double)
+      allow(Legion::LLM).to receive(:chat).and_return(fake_chat)
+      allow(fake_chat).to receive(:with_instructions)
+      allow(fake_chat).to receive(:ask).and_return(fake_response)
+    end
+
+    it 'returns resolution_notes and suggested_outcome' do
+      result = described_class.suggest_resolution(
+        description: 'Agent and human disagree on approach',
+        severity:    :high,
+        exchanges:   [{ speaker: :agent, message: 'I think we should proceed' },
+                      { speaker: :human, message: 'I disagree with that approach' }]
+      )
+      expect(result).to be_a(Hash)
+      expect(result[:resolution_notes]).to be_a(String)
+      expect(result[:resolution_notes]).not_to be_empty
+      expect(result[:suggested_outcome]).to eq(:resolved)
+    end
+
+    it 'handles deferred outcome' do
+      allow(fake_chat).to receive(:ask).and_return(
+        double(content: "OUTCOME: deferred\nNOTES: Issue requires more context before resolution.")
+      )
+      result = described_class.suggest_resolution(
+        description: 'Ongoing concern', severity: :medium, exchanges: []
+      )
+      expect(result[:suggested_outcome]).to eq(:deferred)
+    end
+
+    it 'handles escalated outcome' do
+      allow(fake_chat).to receive(:ask).and_return(
+        double(content: "OUTCOME: escalated\nNOTES: Critical disagreement requires governance council review.")
+      )
+      result = described_class.suggest_resolution(
+        description: 'Safety concern', severity: :critical, exchanges: []
+      )
+      expect(result[:suggested_outcome]).to eq(:escalated)
+    end
+
+    context 'when LLM returns nil content' do
+      before { allow(fake_chat).to receive(:ask).and_return(double(content: nil)) }
+
+      it 'returns nil' do
+        result = described_class.suggest_resolution(
+          description: 'test', severity: :low, exchanges: []
+        )
+        expect(result).to be_nil
+      end
+    end
+
+    context 'when LLM raises an error' do
+      before { allow(fake_chat).to receive(:ask).and_raise(StandardError, 'LLM unavailable') }
+
+      it 'returns nil and logs a warning' do
+        expect(Legion::Logging).to receive(:warn).with(/suggest_resolution failed/)
+        result = described_class.suggest_resolution(
+          description: 'test', severity: :low, exchanges: []
+        )
+        expect(result).to be_nil
+      end
+    end
+  end
+
+  describe '.analyze_stale_conflict' do
+    let(:fake_response) do
+      double(content: <<~TEXT)
+        RECOMMENDATION: escalate
+        ANALYSIS: This conflict has persisted for 36 hours without progress. The critical severity and lack of exchanges suggests governance council intervention.
+      TEXT
+    end
+    let(:fake_chat) { double }
+
+    before do
+      stub_const('Legion::LLM', double)
+      allow(Legion::LLM).to receive(:chat).and_return(fake_chat)
+      allow(fake_chat).to receive(:with_instructions)
+      allow(fake_chat).to receive(:ask).and_return(fake_response)
+    end
+
+    it 'returns analysis and recommendation' do
+      result = described_class.analyze_stale_conflict(
+        description:    'Critical safety disagreement',
+        severity:       :critical,
+        age_hours:      36.5,
+        exchange_count: 2
+      )
+      expect(result).to be_a(Hash)
+      expect(result[:analysis]).to be_a(String)
+      expect(result[:analysis]).not_to be_empty
+      expect(result[:recommendation]).to eq(:escalate)
+    end
+
+    it 'handles retry recommendation' do
+      allow(fake_chat).to receive(:ask).and_return(
+        double(content: "RECOMMENDATION: retry\nANALYSIS: The conflict may be resolvable with a fresh attempt after cooling off.")
+      )
+      result = described_class.analyze_stale_conflict(
+        description: 'Minor dispute', severity: :low, age_hours: 25.0, exchange_count: 1
+      )
+      expect(result[:recommendation]).to eq(:retry)
+    end
+
+    it 'handles close recommendation' do
+      allow(fake_chat).to receive(:ask).and_return(
+        double(content: "RECOMMENDATION: close\nANALYSIS: The issue is no longer relevant and can be safely closed.")
+      )
+      result = described_class.analyze_stale_conflict(
+        description: 'Old dispute', severity: :low, age_hours: 48.0, exchange_count: 0
+      )
+      expect(result[:recommendation]).to eq(:close)
+    end
+
+    context 'when LLM returns nil content' do
+      before { allow(fake_chat).to receive(:ask).and_return(double(content: nil)) }
+
+      it 'returns nil' do
+        result = described_class.analyze_stale_conflict(
+          description: 'test', severity: :low, age_hours: 25.0, exchange_count: 0
+        )
+        expect(result).to be_nil
+      end
+    end
+
+    context 'when LLM raises an error' do
+      before { allow(fake_chat).to receive(:ask).and_raise(StandardError, 'connection refused') }
+
+      it 'returns nil and logs a warning' do
+        expect(Legion::Logging).to receive(:warn).with(/analyze_stale_conflict failed/)
+        result = described_class.analyze_stale_conflict(
+          description: 'test', severity: :medium, age_hours: 30.0, exchange_count: 3
+        )
+        expect(result).to be_nil
+      end
+    end
+  end
+end

data/spec/legion/extensions/conflict/helpers/severity_spec.rb

@@ -0,0 +1,215 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+RSpec.describe Legion::Extensions::Conflict::Helpers::Severity do
+  describe 'LEVELS' do
+    it 'is a frozen array of symbols' do
+      expect(described_class::LEVELS).to be_a(Array)
+      expect(described_class::LEVELS).to be_frozen
+    end
+
+    it 'contains exactly four levels' do
+      expect(described_class::LEVELS.size).to eq(4)
+    end
+
+    it 'includes :low' do
+      expect(described_class::LEVELS).to include(:low)
+    end
+
+    it 'includes :medium' do
+      expect(described_class::LEVELS).to include(:medium)
+    end
+
+    it 'includes :high' do
+      expect(described_class::LEVELS).to include(:high)
+    end
+
+    it 'includes :critical' do
+      expect(described_class::LEVELS).to include(:critical)
+    end
+
+    it 'is ordered from least to most severe' do
+      expect(described_class::LEVELS).to eq(%i[low medium high critical])
+    end
+  end
+
+  describe 'POSTURES' do
+    it 'is a frozen array of symbols' do
+      expect(described_class::POSTURES).to be_a(Array)
+      expect(described_class::POSTURES).to be_frozen
+    end
+
+    it 'contains exactly three postures' do
+      expect(described_class::POSTURES.size).to eq(3)
+    end
+
+    it 'includes :speak_once' do
+      expect(described_class::POSTURES).to include(:speak_once)
+    end
+
+    it 'includes :persistent_engagement' do
+      expect(described_class::POSTURES).to include(:persistent_engagement)
+    end
+
+    it 'includes :stubborn_presence' do
+      expect(described_class::POSTURES).to include(:stubborn_presence)
+    end
+  end
+
+  describe 'LEVEL_ORDER' do
+    it 'is a frozen hash' do
+      expect(described_class::LEVEL_ORDER).to be_a(Hash)
+      expect(described_class::LEVEL_ORDER).to be_frozen
+    end
+
+    it 'assigns :low the lowest numeric value' do
+      expect(described_class::LEVEL_ORDER[:low]).to eq(0)
+    end
+
+    it 'assigns :medium a higher value than :low' do
+      expect(described_class::LEVEL_ORDER[:medium]).to be > described_class::LEVEL_ORDER[:low]
+    end
+
+    it 'assigns :high a higher value than :medium' do
+      expect(described_class::LEVEL_ORDER[:high]).to be > described_class::LEVEL_ORDER[:medium]
+    end
+
+    it 'assigns :critical the highest numeric value' do
+      expect(described_class::LEVEL_ORDER[:critical]).to be > described_class::LEVEL_ORDER[:high]
+    end
+
+    it 'covers all LEVELS' do
+      described_class::LEVELS.each do |level|
+        expect(described_class::LEVEL_ORDER).to have_key(level)
+      end
+    end
+  end
+
+  describe '.valid_level?' do
+    it 'returns true for :low' do
+      expect(described_class.valid_level?(:low)).to be true
+    end
+
+    it 'returns true for :medium' do
+      expect(described_class.valid_level?(:medium)).to be true
+    end
+
+    it 'returns true for :high' do
+      expect(described_class.valid_level?(:high)).to be true
+    end
+
+    it 'returns true for :critical' do
+      expect(described_class.valid_level?(:critical)).to be true
+    end
+
+    it 'returns false for an unknown symbol' do
+      expect(described_class.valid_level?(:catastrophic)).to be false
+    end
+
+    it 'returns false for a string form of a valid level' do
+      expect(described_class.valid_level?('high')).to be false
+    end
+
+    it 'returns false for nil' do
+      expect(described_class.valid_level?(nil)).to be false
+    end
+
+    it 'returns true for every member of LEVELS' do
+      described_class::LEVELS.each do |level|
+        expect(described_class.valid_level?(level)).to be true
+      end
+    end
+  end
+
+  describe '.valid_posture?' do
+    it 'returns true for :speak_once' do
+      expect(described_class.valid_posture?(:speak_once)).to be true
+    end
+
+    it 'returns true for :persistent_engagement' do
+      expect(described_class.valid_posture?(:persistent_engagement)).to be true
+    end
+
+    it 'returns true for :stubborn_presence' do
+      expect(described_class.valid_posture?(:stubborn_presence)).to be true
+    end
+
+    it 'returns false for an unknown posture symbol' do
+      expect(described_class.valid_posture?(:passive)).to be false
+    end
+
+    it 'returns false for nil' do
+      expect(described_class.valid_posture?(nil)).to be false
+    end
+
+    it 'returns true for every member of POSTURES' do
+      described_class::POSTURES.each do |posture|
+        expect(described_class.valid_posture?(posture)).to be true
+      end
+    end
+  end
+
+  describe '.recommended_posture' do
+    it 'returns :stubborn_presence for :critical' do
+      expect(described_class.recommended_posture(:critical)).to eq(:stubborn_presence)
+    end
+
+    it 'returns :persistent_engagement for :high' do
+      expect(described_class.recommended_posture(:high)).to eq(:persistent_engagement)
+    end
+
+    it 'returns :speak_once for :medium' do
+      expect(described_class.recommended_posture(:medium)).to eq(:speak_once)
+    end
+
+    it 'returns :speak_once for :low' do
+      expect(described_class.recommended_posture(:low)).to eq(:speak_once)
+    end
+
+    it 'returns :speak_once for an unrecognized severity' do
+      expect(described_class.recommended_posture(:unknown)).to eq(:speak_once)
+    end
+
+    it 'returns a posture that is a member of POSTURES for every valid level' do
+      described_class::LEVELS.each do |level|
+        posture = described_class.recommended_posture(level)
+        expect(described_class::POSTURES).to include(posture)
+      end
+    end
+  end
+
+  describe '.severity_gte?' do
+    it 'returns true when left equals right' do
+      expect(described_class.severity_gte?(:medium, :medium)).to be true
+    end
+
+    it 'returns true when left is strictly greater' do
+      expect(described_class.severity_gte?(:high, :medium)).to be true
+    end
+
+    it 'returns false when left is strictly less' do
+      expect(described_class.severity_gte?(:low, :medium)).to be false
+    end
+
+    it ':critical >= :high is true' do
+      expect(described_class.severity_gte?(:critical, :high)).to be true
+    end
+
+    it ':critical >= :critical is true' do
+      expect(described_class.severity_gte?(:critical, :critical)).to be true
+    end
+
+    it ':low >= :critical is false' do
+      expect(described_class.severity_gte?(:low, :critical)).to be false
+    end
+
+    it 'treats an unknown left level as order 0 (same as :low)' do
+      expect(described_class.severity_gte?(:unknown, :medium)).to be false
+    end
+
+    it 'treats an unknown right level as order 0, so any valid level >= it' do
+      expect(described_class.severity_gte?(:low, :unknown)).to be true
+    end
+  end
+end