lex-cognitive-synthesis 0.1.0

data/spec/legion/extensions/cognitive_synthesis/helpers/synthesis_engine_spec.rb

@@ -0,0 +1,233 @@
+# frozen_string_literal: true
+
+RSpec.describe Legion::Extensions::CognitiveSynthesis::Helpers::SynthesisEngine do
+  subject(:engine) { described_class.new }
+
+  def add_stream(type: :emotional, content: { value: 1 }, weight: 0.7, confidence: 0.8)
+    engine.add_stream(stream_type: type, content: content, weight: weight, confidence: confidence)
+  end
+
+  describe '#add_stream' do
+    it 'returns success with stream_id' do
+      result = add_stream
+      expect(result[:success]).to be true
+      expect(result[:stream_id]).to match(/\A[0-9a-f-]{36}\z/)
+    end
+
+    it 'stores stream in @streams' do
+      add_stream
+      expect(engine.streams.size).to eq(1)
+    end
+
+    it 'rejects invalid stream_type' do
+      result = engine.add_stream(stream_type: :invalid, content: {})
+      expect(result[:success]).to be false
+      expect(result[:error]).to eq(:invalid_stream_type)
+    end
+
+    it 'accepts all valid stream types' do
+      %i[emotional perceptual memorial predictive reasoning social identity motor].each do |type|
+        result = engine.add_stream(stream_type: type, content: {})
+        expect(result[:success]).to be true
+      end
+    end
+
+    it 'prunes when exceeding MAX_STREAMS' do
+      51.times { add_stream }
+      expect(engine.streams.size).to eq(50)
+    end
+  end
+
+  describe '#remove_stream' do
+    it 'removes an existing stream' do
+      result = add_stream
+      remove = engine.remove_stream(stream_id: result[:stream_id])
+      expect(remove[:success]).to be true
+      expect(engine.streams).to be_empty
+    end
+
+    it 'returns not_found for missing stream' do
+      result = engine.remove_stream(stream_id: 'nonexistent')
+      expect(result[:success]).to be false
+      expect(result[:error]).to eq(:not_found)
+    end
+  end
+
+  describe '#synthesize!' do
+    it 'fails with fewer than MIN_STREAMS_FOR_SYNTHESIS active streams' do
+      add_stream
+      result = engine.synthesize!
+      expect(result[:success]).to be false
+      expect(result[:error]).to eq(:insufficient_streams)
+    end
+
+    it 'succeeds with enough streams' do
+      2.times { add_stream }
+      result = engine.synthesize!
+      expect(result[:success]).to be true
+      expect(result[:synthesis]).to have_key(:id)
+    end
+
+    it 'stores synthesis in history' do
+      2.times { add_stream }
+      engine.synthesize!
+      expect(engine.syntheses.size).to eq(1)
+    end
+
+    it 'includes coherence in result' do
+      2.times { add_stream }
+      result = engine.synthesize!
+      expect(result[:synthesis][:coherence]).to be_between(0.0, 1.0)
+    end
+
+    it 'includes novelty in result' do
+      2.times { add_stream }
+      result = engine.synthesize!
+      expect(result[:synthesis][:novelty]).to be_between(0.0, 1.0)
+    end
+
+    it 'includes confidence in result' do
+      2.times { add_stream }
+      result = engine.synthesize!
+      expect(result[:synthesis][:confidence]).to be_between(0.0, 1.0)
+    end
+
+    it 'marks first synthesis as maximally novel (no prior)' do
+      2.times { add_stream }
+      result = engine.synthesize!
+      expect(result[:synthesis][:novelty]).to eq(1.0)
+    end
+
+    it 'caps syntheses at MAX_SYNTHESES' do
+      2.times { add_stream }
+      201.times { engine.synthesize! }
+      expect(engine.syntheses.size).to eq(200)
+    end
+
+    it 'returns content with dominant_type' do
+      2.times { add_stream }
+      result = engine.synthesize!
+      expect(result[:synthesis][:content]).to have_key(:dominant_type)
+    end
+  end
+
+  describe '#decay_all!' do
+    it 'returns success' do
+      result = engine.decay_all!
+      expect(result[:success]).to be true
+    end
+
+    it 'reduces freshness on all streams' do
+      add_stream
+      stream = engine.streams.values.first
+      before = stream.freshness
+      engine.decay_all!
+      expect(stream.freshness).to be < before
+    end
+
+    it 'removes stale streams' do
+      add_stream
+      stream = engine.streams.values.first
+      46.times { stream.decay_freshness! }
+      engine.decay_all!
+      expect(engine.streams).to be_empty
+    end
+
+    it 'reports removed and remaining counts' do
+      2.times { add_stream }
+      result = engine.decay_all!
+      expect(result).to have_key(:streams_removed)
+      expect(result).to have_key(:streams_remaining)
+    end
+  end
+
+  describe '#stream_conflict?' do
+    let(:id_a) { add_stream(weight: 0.9, content: { signal: :danger })[:stream_id] }
+    let(:id_b) { add_stream(weight: 0.1, content: { signal: :safe })[:stream_id] }
+
+    it 'detects weight opposition' do
+      result = engine.stream_conflict?(stream_id_a: id_a, stream_id_b: id_b)
+      expect(result[:success]).to be true
+      expect(result[:weight_opposition]).to be true
+    end
+
+    it 'detects content conflict on shared keys' do
+      result = engine.stream_conflict?(stream_id_a: id_a, stream_id_b: id_b)
+      expect(result[:content_conflict]).to be true
+    end
+
+    it 'reports no conflict for compatible streams' do
+      a = add_stream(weight: 0.6, content: { value: 1 })[:stream_id]
+      b = add_stream(weight: 0.7, content: { value: 1 })[:stream_id]
+      result = engine.stream_conflict?(stream_id_a: a, stream_id_b: b)
+      expect(result[:conflict]).to be false
+    end
+
+    it 'returns not_found for missing stream' do
+      result = engine.stream_conflict?(stream_id_a: 'x', stream_id_b: 'y')
+      expect(result[:success]).to be false
+      expect(result[:error]).to eq(:stream_not_found)
+    end
+  end
+
+  describe '#dominant_stream' do
+    it 'returns no_streams error when empty' do
+      result = engine.dominant_stream
+      expect(result[:success]).to be false
+      expect(result[:error]).to eq(:no_streams)
+    end
+
+    it 'returns the stream with highest effective_weight' do
+      add_stream(weight: 0.3, confidence: 0.3)
+      id = add_stream(weight: 0.9, confidence: 0.95)[:stream_id]
+      result = engine.dominant_stream
+      expect(result[:success]).to be true
+      expect(result[:stream][:id]).to eq(id)
+    end
+  end
+
+  describe '#synthesis_history' do
+    it 'returns empty list when no syntheses' do
+      result = engine.synthesis_history
+      expect(result[:syntheses]).to be_empty
+      expect(result[:count]).to eq(0)
+    end
+
+    it 'returns last N syntheses' do
+      2.times { add_stream }
+      5.times { engine.synthesize! }
+      result = engine.synthesis_history(limit: 3)
+      expect(result[:count]).to eq(3)
+    end
+  end
+
+  describe '#average_coherence' do
+    it 'returns 0.0 when no syntheses' do
+      result = engine.average_coherence
+      expect(result[:average_coherence]).to eq(0.0)
+      expect(result[:sample_size]).to eq(0)
+    end
+
+    it 'computes average coherence over recent syntheses' do
+      2.times { add_stream }
+      3.times { engine.synthesize! }
+      result = engine.average_coherence
+      expect(result[:average_coherence]).to be_between(0.0, 1.0)
+      expect(result[:sample_size]).to eq(3)
+    end
+  end
+
+  describe '#to_h' do
+    it 'returns summary stats hash' do
+      add_stream(type: :emotional)
+      result = engine.to_h
+      expect(result).to include(:stream_count, :synthesis_count, :active_streams,
+                                :stale_streams, :average_coherence)
+    end
+
+    it 'reflects current stream count' do
+      3.times { add_stream }
+      expect(engine.to_h[:stream_count]).to eq(3)
+    end
+  end
+end

data/spec/legion/extensions/cognitive_synthesis/helpers/synthesis_spec.rb

@@ -0,0 +1,101 @@
+# frozen_string_literal: true
+
+RSpec.describe Legion::Extensions::CognitiveSynthesis::Helpers::Synthesis do
+  subject(:synthesis) do
+    described_class.new(
+      streams:    %w[abc def],
+      coherence:  0.75,
+      novelty:    0.8,
+      confidence: 0.7,
+      content:    { dominant_type: :emotional, stream_count: 2 }
+    )
+  end
+
+  describe '#initialize' do
+    it 'assigns a UUID id' do
+      expect(synthesis.id).to match(/\A[0-9a-f-]{36}\z/)
+    end
+
+    it 'stores stream ids' do
+      expect(synthesis.streams).to eq(%w[abc def])
+    end
+
+    it 'clamps coherence to 0-1' do
+      s = described_class.new(streams: [], coherence: 1.5, novelty: 0.5, confidence: 0.5, content: {})
+      expect(s.coherence).to eq(1.0)
+    end
+
+    it 'clamps novelty to 0-1' do
+      s = described_class.new(streams: [], coherence: 0.5, novelty: -0.5, confidence: 0.5, content: {})
+      expect(s.novelty).to eq(0.0)
+    end
+
+    it 'clamps confidence to 0-1' do
+      s = described_class.new(streams: [], coherence: 0.5, novelty: 0.5, confidence: 2.0, content: {})
+      expect(s.confidence).to eq(1.0)
+    end
+
+    it 'sets created_at as UTC time' do
+      expect(synthesis.created_at).to be_a(Time)
+    end
+  end
+
+  describe '#fragmented?' do
+    it 'returns false when coherence >= COHERENCE_THRESHOLD' do
+      expect(synthesis.fragmented?).to be false
+    end
+
+    it 'returns true when coherence < COHERENCE_THRESHOLD' do
+      s = described_class.new(streams: [], coherence: 0.4, novelty: 0.5, confidence: 0.5, content: {})
+      expect(s.fragmented?).to be true
+    end
+  end
+
+  describe '#novel?' do
+    it 'returns true when novelty > NOVELTY_THRESHOLD' do
+      expect(synthesis.novel?).to be true
+    end
+
+    it 'returns false when novelty <= NOVELTY_THRESHOLD' do
+      s = described_class.new(streams: [], coherence: 0.5, novelty: 0.5, confidence: 0.5, content: {})
+      expect(s.novel?).to be false
+    end
+  end
+
+  describe '#coherence_label' do
+    it 'returns :coherent for coherence 0.75' do
+      expect(synthesis.coherence_label).to eq(:coherent)
+    end
+
+    it 'returns :unified for coherence 0.9' do
+      s = described_class.new(streams: [], coherence: 0.9, novelty: 0.5, confidence: 0.5, content: {})
+      expect(s.coherence_label).to eq(:unified)
+    end
+  end
+
+  describe '#confidence_label' do
+    it 'returns :confident for confidence 0.7' do
+      expect(synthesis.confidence_label).to eq(:confident)
+    end
+  end
+
+  describe '#to_h' do
+    let(:hash) { synthesis.to_h }
+
+    it 'includes all expected keys' do
+      %i[id streams coherence novelty confidence content fragmented novel
+         coherence_label confidence_label created_at].each do |key|
+        expect(hash).to have_key(key)
+      end
+    end
+
+    it 'reflects fragmented state' do
+      s = described_class.new(streams: [], coherence: 0.3, novelty: 0.5, confidence: 0.5, content: {})
+      expect(s.to_h[:fragmented]).to be true
+    end
+
+    it 'reflects novel state' do
+      expect(hash[:novel]).to be true
+    end
+  end
+end

data/spec/legion/extensions/cognitive_synthesis/helpers/synthesis_stream_spec.rb

@@ -0,0 +1,116 @@
+# frozen_string_literal: true
+
+RSpec.describe Legion::Extensions::CognitiveSynthesis::Helpers::SynthesisStream do
+  subject(:stream) do
+    described_class.new(stream_type: :emotional, content: { mood: 'alert' }, weight: 0.8, confidence: 0.9)
+  end
+
+  describe '#initialize' do
+    it 'assigns a UUID id' do
+      expect(stream.id).to match(/\A[0-9a-f-]{36}\z/)
+    end
+
+    it 'sets stream_type' do
+      expect(stream.stream_type).to eq(:emotional)
+    end
+
+    it 'sets content' do
+      expect(stream.content).to eq({ mood: 'alert' })
+    end
+
+    it 'clamps weight to 0-1' do
+      s = described_class.new(stream_type: :perceptual, content: {}, weight: 1.5)
+      expect(s.weight).to eq(1.0)
+    end
+
+    it 'clamps confidence to 0-1' do
+      s = described_class.new(stream_type: :perceptual, content: {}, confidence: -0.1)
+      expect(s.confidence).to eq(0.0)
+    end
+
+    it 'initializes freshness at 1.0' do
+      expect(stream.freshness).to eq(1.0)
+    end
+
+    it 'sets created_at as UTC time' do
+      expect(stream.created_at).to be_a(Time)
+    end
+  end
+
+  describe '#decay_freshness!' do
+    it 'reduces freshness by FRESHNESS_DECAY' do
+      before = stream.freshness
+      stream.decay_freshness!
+      expect(stream.freshness).to be_within(0.001).of(before - 0.02)
+    end
+
+    it 'never drops below 0.0' do
+      60.times { stream.decay_freshness! }
+      expect(stream.freshness).to eq(0.0)
+    end
+  end
+
+  describe '#stale?' do
+    it 'returns false when freshness is high' do
+      expect(stream.stale?).to be false
+    end
+
+    it 'returns true when freshness drops below 0.1' do
+      46.times { stream.decay_freshness! }
+      expect(stream.stale?).to be true
+    end
+  end
+
+  describe '#effective_weight' do
+    it 'equals weight * freshness * confidence' do
+      expected = (0.8 * 1.0 * 0.9).round(10)
+      expect(stream.effective_weight).to eq(expected)
+    end
+
+    it 'decreases after decay' do
+      before = stream.effective_weight
+      stream.decay_freshness!
+      expect(stream.effective_weight).to be < before
+    end
+  end
+
+  describe '#coherence_label' do
+    it 'returns :unified for weight 0.9' do
+      s = described_class.new(stream_type: :memorial, content: {}, weight: 0.9)
+      expect(s.coherence_label).to eq(:unified)
+    end
+
+    it 'returns :chaotic for weight 0.1' do
+      s = described_class.new(stream_type: :memorial, content: {}, weight: 0.1)
+      expect(s.coherence_label).to eq(:chaotic)
+    end
+  end
+
+  describe '#confidence_label' do
+    it 'returns :certain for confidence 0.95' do
+      s = described_class.new(stream_type: :memorial, content: {}, confidence: 0.95)
+      expect(s.confidence_label).to eq(:certain)
+    end
+
+    it 'returns :guessing for confidence 0.1' do
+      s = described_class.new(stream_type: :memorial, content: {}, confidence: 0.1)
+      expect(s.confidence_label).to eq(:guessing)
+    end
+  end
+
+  describe '#to_h' do
+    let(:hash) { stream.to_h }
+
+    it 'includes all expected keys' do
+      %i[id stream_type content weight confidence freshness effective_weight
+         stale coherence_label confidence_label created_at].each do |key|
+        expect(hash).to have_key(key)
+      end
+    end
+
+    it 'reflects current freshness' do
+      stream.decay_freshness!
+      expect(stream.to_h[:freshness]).to be < 1.0
+    end
+  end
+end

data/spec/legion/extensions/cognitive_synthesis/runners/cognitive_synthesis_spec.rb

@@ -0,0 +1,181 @@
+# frozen_string_literal: true
+
+require 'legion/extensions/cognitive_synthesis/client'
+
+RSpec.describe Legion::Extensions::CognitiveSynthesis::Runners::CognitiveSynthesis do
+  let(:client) { Legion::Extensions::CognitiveSynthesis::Client.new }
+
+  def add_two_streams
+    client.add_stream(stream_type: :emotional, content: { mood: :alert }, weight: 0.8, confidence: 0.9)
+    client.add_stream(stream_type: :perceptual, content: { threat: :detected }, weight: 0.6, confidence: 0.7)
+  end
+
+  describe '#add_stream' do
+    it 'adds a valid stream and returns success' do
+      result = client.add_stream(stream_type: :emotional, content: { mood: :calm })
+      expect(result[:success]).to be true
+      expect(result[:stream_id]).to match(/\A[0-9a-f-]{36}\z/)
+    end
+
+    it 'rejects an invalid stream type' do
+      result = client.add_stream(stream_type: :bogus, content: {})
+      expect(result[:success]).to be false
+      expect(result[:error]).to eq(:invalid_stream_type)
+    end
+
+    it 'accepts all valid stream types' do
+      %i[emotional perceptual memorial predictive reasoning social identity motor].each do |type|
+        result = client.add_stream(stream_type: type, content: {})
+        expect(result[:success]).to be true
+      end
+    end
+
+    it 'accepts injected engine kwarg' do
+      engine = Legion::Extensions::CognitiveSynthesis::Helpers::SynthesisEngine.new
+      result = client.add_stream(stream_type: :reasoning, content: {}, engine: engine)
+      expect(result[:success]).to be true
+      expect(engine.streams.size).to eq(1)
+    end
+  end
+
+  describe '#remove_stream' do
+    it 'removes an existing stream' do
+      add_result = client.add_stream(stream_type: :emotional, content: {})
+      remove_result = client.remove_stream(stream_id: add_result[:stream_id])
+      expect(remove_result[:success]).to be true
+    end
+
+    it 'returns not_found for unknown stream' do
+      result = client.remove_stream(stream_id: 'nonexistent-id')
+      expect(result[:success]).to be false
+      expect(result[:error]).to eq(:not_found)
+    end
+  end
+
+  describe '#synthesize' do
+    it 'returns insufficient_streams when fewer than 2 active streams' do
+      client.add_stream(stream_type: :emotional, content: {})
+      result = client.synthesize
+      expect(result[:success]).to be false
+      expect(result[:error]).to eq(:insufficient_streams)
+    end
+
+    it 'succeeds with 2+ active streams' do
+      add_two_streams
+      result = client.synthesize
+      expect(result[:success]).to be true
+      expect(result[:synthesis]).to have_key(:id)
+    end
+
+    it 'returns coherence between 0 and 1' do
+      add_two_streams
+      result = client.synthesize
+      expect(result[:synthesis][:coherence]).to be_between(0.0, 1.0)
+    end
+
+    it 'returns novelty = 1.0 for first synthesis' do
+      add_two_streams
+      result = client.synthesize
+      expect(result[:synthesis][:novelty]).to eq(1.0)
+    end
+
+    it 'uses injected engine when provided' do
+      engine = Legion::Extensions::CognitiveSynthesis::Helpers::SynthesisEngine.new
+      2.times { engine.add_stream(stream_type: :emotional, content: {}) }
+      result = client.synthesize(engine: engine)
+      expect(result[:success]).to be true
+    end
+  end
+
+  describe '#decay_streams' do
+    it 'returns success' do
+      result = client.decay_streams
+      expect(result[:success]).to be true
+    end
+
+    it 'reports removed count' do
+      result = client.decay_streams
+      expect(result).to have_key(:streams_removed)
+    end
+  end
+
+  describe '#check_conflict' do
+    it 'detects conflict between opposing streams' do
+      a = client.add_stream(stream_type: :emotional, content: { signal: :danger }, weight: 0.9)
+      b = client.add_stream(stream_type: :perceptual, content: { signal: :safe }, weight: 0.1)
+      result = client.check_conflict(stream_id_a: a[:stream_id], stream_id_b: b[:stream_id])
+      expect(result[:success]).to be true
+      expect(result[:conflict]).to be true
+    end
+
+    it 'reports no conflict for similar streams' do
+      a = client.add_stream(stream_type: :emotional, content: { value: 1 }, weight: 0.6)
+      b = client.add_stream(stream_type: :perceptual, content: { value: 1 }, weight: 0.65)
+      result = client.check_conflict(stream_id_a: a[:stream_id], stream_id_b: b[:stream_id])
+      expect(result[:conflict]).to be false
+    end
+
+    it 'returns error for missing stream ids' do
+      result = client.check_conflict(stream_id_a: 'x', stream_id_b: 'y')
+      expect(result[:success]).to be false
+    end
+  end
+
+  describe '#dominant_stream' do
+    it 'returns error when no streams present' do
+      result = client.dominant_stream
+      expect(result[:success]).to be false
+      expect(result[:error]).to eq(:no_streams)
+    end
+
+    it 'returns stream with highest effective_weight' do
+      client.add_stream(stream_type: :emotional, content: {}, weight: 0.2, confidence: 0.2)
+      high = client.add_stream(stream_type: :memorial, content: {}, weight: 0.95, confidence: 0.95)
+      result = client.dominant_stream
+      expect(result[:stream][:id]).to eq(high[:stream_id])
+    end
+  end
+
+  describe '#synthesis_history' do
+    it 'returns empty list initially' do
+      result = client.synthesis_history
+      expect(result[:syntheses]).to be_empty
+    end
+
+    it 'returns syntheses after multiple runs' do
+      add_two_streams
+      3.times { client.synthesize }
+      result = client.synthesis_history(limit: 2)
+      expect(result[:count]).to eq(2)
+    end
+  end
+
+  describe '#average_coherence' do
+    it 'returns 0.0 when no syntheses' do
+      result = client.average_coherence
+      expect(result[:average_coherence]).to eq(0.0)
+    end
+
+    it 'returns coherence value after syntheses' do
+      add_two_streams
+      3.times { client.synthesize }
+      result = client.average_coherence
+      expect(result[:average_coherence]).to be_between(0.0, 1.0)
+    end
+  end
+
+  describe '#status' do
+    it 'returns success with stats' do
+      result = client.status
+      expect(result[:success]).to be true
+      expect(result).to have_key(:stream_count)
+      expect(result).to have_key(:synthesis_count)
+    end
+
+    it 'reflects added streams' do
+      add_two_streams
+      result = client.status
+      expect(result[:stream_count]).to eq(2)
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+require 'bundler/setup'
+
+module Legion
+  module Logging
+    def self.debug(_msg); end
+    def self.info(_msg); end
+    def self.warn(_msg); end
+    def self.error(_msg); end
+  end
+end
+
+require 'legion/extensions/cognitive_synthesis'
+
+RSpec.configure do |config|
+  config.example_status_persistence_file_path = '.rspec_status'
+  config.disable_monkey_patching!
+  config.expect_with(:rspec) { |c| c.syntax = :expect }
+end