lex-agentic-integration 0.1.0

data/spec/legion/extensions/agentic/integration/synthesis/helpers/synthesis_stream_spec.rb

@@ -0,0 +1,116 @@
+# frozen_string_literal: true
+
+RSpec.describe Legion::Extensions::Agentic::Integration::Synthesis::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/agentic/integration/synthesis/runners/cognitive_synthesis_spec.rb

@@ -0,0 +1,181 @@
+# frozen_string_literal: true
+
+require 'legion/extensions/agentic/integration/synthesis/client'
+
+RSpec.describe Legion::Extensions::Agentic::Integration::Synthesis::Runners::CognitiveSynthesis do
+  let(:client) { Legion::Extensions::Agentic::Integration::Synthesis::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::Agentic::Integration::Synthesis::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::Agentic::Integration::Synthesis::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/legion/extensions/agentic/integration/tapestry/client_spec.rb

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+RSpec.describe Legion::Extensions::Agentic::Integration::Tapestry::Client do
+  subject(:client) { described_class.new }
+
+  let(:engine) { Legion::Extensions::Agentic::Integration::Tapestry::Helpers::LoomEngine.new }
+
+  it 'includes Runners::CognitiveTapestry' do
+    expect(client).to respond_to(:spin_thread)
+    expect(client).to respond_to(:create_tapestry)
+    expect(client).to respond_to(:weave)
+    expect(client).to respond_to(:list_tapestries)
+    expect(client).to respond_to(:loom_status)
+  end
+
+  describe '#spin_thread via client' do
+    it 'returns a successful result' do
+      result = client.spin_thread(
+        thread_type: :memory, domain: :past, content: 'childhood memory', engine: engine
+      )
+      expect(result[:success]).to be true
+    end
+  end
+
+  describe '#create_tapestry via client' do
+    it 'returns a successful result' do
+      result = client.create_tapestry(name: 'autobiography', pattern: :twill, engine: engine)
+      expect(result[:success]).to be true
+    end
+  end
+
+  describe '#weave via client' do
+    it 'weaves thread into tapestry' do
+      t   = engine.spin_thread(thread_type: :emotion, domain: :x, content: 'joy')
+      tap = engine.create_tapestry(name: 'canvas', pattern: :satin)
+      result = client.weave(thread_id: t.id, tapestry_id: tap.id, engine: engine)
+      expect(result[:success]).to be true
+    end
+  end
+
+  describe '#list_tapestries via client' do
+    it 'returns empty tapestries on fresh engine' do
+      result = client.list_tapestries(engine: engine)
+      expect(result[:count]).to eq(0)
+    end
+  end
+
+  describe '#loom_status via client' do
+    it 'returns status report' do
+      result = client.loom_status(engine: engine)
+      expect(result[:success]).to be true
+      expect(result[:report]).to be_a(Hash)
+    end
+  end
+end

data/spec/legion/extensions/agentic/integration/tapestry/helpers/constants_spec.rb

@@ -0,0 +1,88 @@
+# frozen_string_literal: true
+
+RSpec.describe Legion::Extensions::Agentic::Integration::Tapestry::Helpers::Constants do
+  describe 'THREAD_TYPES' do
+    it 'contains expected types' do
+      expect(described_class::THREAD_TYPES).to include(:experience, :belief, :memory, :emotion, :narrative)
+    end
+
+    it 'has five types' do
+      expect(described_class::THREAD_TYPES.size).to eq(5)
+    end
+
+    it 'is frozen' do
+      expect(described_class::THREAD_TYPES).to be_frozen
+    end
+  end
+
+  describe 'WEAVE_PATTERNS' do
+    it 'contains expected patterns' do
+      expect(described_class::WEAVE_PATTERNS).to include(:plain, :twill, :satin, :brocade)
+    end
+
+    it 'has four patterns' do
+      expect(described_class::WEAVE_PATTERNS.size).to eq(4)
+    end
+
+    it 'is frozen' do
+      expect(described_class::WEAVE_PATTERNS).to be_frozen
+    end
+  end
+
+  describe 'capacity constants' do
+    it 'defines MAX_THREADS as 500' do
+      expect(described_class::MAX_THREADS).to eq(500)
+    end
+
+    it 'defines MAX_TAPESTRIES as 50' do
+      expect(described_class::MAX_TAPESTRIES).to eq(50)
+    end
+
+    it 'defines TENSION_RATE as 0.05' do
+      expect(described_class::TENSION_RATE).to eq(0.05)
+    end
+
+    it 'defines FRAY_RATE as 0.03' do
+      expect(described_class::FRAY_RATE).to eq(0.03)
+    end
+  end
+
+  describe 'INTEGRITY_LABELS' do
+    it 'labels high strength as masterwork' do
+      expect(described_class.label_for(described_class::INTEGRITY_LABELS, 0.95)).to eq(:masterwork)
+    end
+
+    it 'labels near-zero strength as rags' do
+      expect(described_class.label_for(described_class::INTEGRITY_LABELS, 0.05)).to eq(:rags)
+    end
+
+    it 'labels mid strength as woven' do
+      expect(described_class.label_for(described_class::INTEGRITY_LABELS, 0.55)).to eq(:woven)
+    end
+
+    it 'labels fraying range correctly' do
+      expect(described_class.label_for(described_class::INTEGRITY_LABELS, 0.35)).to eq(:fraying)
+    end
+  end
+
+  describe 'COMPLEXITY_LABELS' do
+    it 'labels high complexity as baroque' do
+      expect(described_class.label_for(described_class::COMPLEXITY_LABELS, 0.95)).to eq(:baroque)
+    end
+
+    it 'labels low complexity as simple' do
+      expect(described_class.label_for(described_class::COMPLEXITY_LABELS, 0.1)).to eq(:simple)
+    end
+
+    it 'labels mid complexity as patterned' do
+      expect(described_class.label_for(described_class::COMPLEXITY_LABELS, 0.5)).to eq(:patterned)
+    end
+  end
+
+  describe '.label_for' do
+    it 'returns last label as fallback for out-of-range values' do
+      result = described_class.label_for(described_class::INTEGRITY_LABELS, -1.0)
+      expect(result).to eq(:rags)
+    end
+  end
+end

data/spec/legion/extensions/agentic/integration/tapestry/helpers/loom_engine_spec.rb

@@ -0,0 +1,225 @@
+# frozen_string_literal: true
+
+RSpec.describe Legion::Extensions::Agentic::Integration::Tapestry::Helpers::LoomEngine do
+  subject(:engine) { described_class.new }
+
+  def spin(type: :experience, domain: :test, content: 'data', strength: 0.5)
+    engine.spin_thread(thread_type: type, domain: domain, content: content, strength: strength)
+  end
+
+  def create_tap(name: 'story', pattern: :plain, capacity: 10)
+    engine.create_tapestry(name: name, pattern: pattern, capacity: capacity)
+  end
+
+  describe '#spin_thread' do
+    it 'returns a Thread instance' do
+      expect(spin).to be_a(Legion::Extensions::Agentic::Integration::Tapestry::Helpers::Thread)
+    end
+
+    it 'stores the thread internally' do
+      t = spin
+      expect(engine.all_threads).to include(t)
+    end
+
+    it 'raises ArgumentError for invalid thread_type' do
+      expect { engine.spin_thread(thread_type: :bogus, domain: :x, content: 'y') }
+        .to raise_error(ArgumentError)
+    end
+
+    it 'raises ArgumentError when limit reached' do
+      stub_const('Legion::Extensions::Agentic::Integration::Tapestry::Helpers::Constants::MAX_THREADS', 1)
+      engine.spin_thread(thread_type: :belief, domain: :x, content: '1')
+      expect { engine.spin_thread(thread_type: :belief, domain: :x, content: '2') }
+        .to raise_error(ArgumentError, /limit/)
+    end
+  end
+
+  describe '#create_tapestry' do
+    it 'returns a Tapestry instance' do
+      expect(create_tap).to be_a(Legion::Extensions::Agentic::Integration::Tapestry::Helpers::Tapestry)
+    end
+
+    it 'stores the tapestry internally' do
+      tap = create_tap
+      expect(engine.all_tapestries).to include(tap)
+    end
+
+    it 'raises ArgumentError for invalid pattern' do
+      expect { engine.create_tapestry(name: 'x', pattern: :invalid) }
+        .to raise_error(ArgumentError)
+    end
+
+    it 'raises ArgumentError when limit reached' do
+      stub_const('Legion::Extensions::Agentic::Integration::Tapestry::Helpers::Constants::MAX_TAPESTRIES', 1)
+      engine.create_tapestry(name: 'one', pattern: :plain)
+      expect { engine.create_tapestry(name: 'two', pattern: :plain) }
+        .to raise_error(ArgumentError, /limit/)
+    end
+  end
+
+  describe '#weave' do
+    let(:t)   { spin }
+    let(:tap) { create_tap }
+
+    it 'returns the Thread' do
+      result = engine.weave(thread_id: t.id, tapestry_id: tap.id)
+      expect(result).to be_a(Legion::Extensions::Agentic::Integration::Tapestry::Helpers::Thread)
+    end
+
+    it 'marks the thread as woven' do
+      engine.weave(thread_id: t.id, tapestry_id: tap.id)
+      expect(t.woven?).to be true
+    end
+
+    it 'adds thread id to tapestry' do
+      engine.weave(thread_id: t.id, tapestry_id: tap.id)
+      expect(tap.thread_ids).to include(t.id)
+    end
+
+    it 'raises ArgumentError when thread already woven' do
+      engine.weave(thread_id: t.id, tapestry_id: tap.id)
+      tap2 = create_tap(name: 'second', pattern: :twill)
+      expect { engine.weave(thread_id: t.id, tapestry_id: tap2.id) }
+        .to raise_error(ArgumentError, /already woven/)
+    end
+
+    it 'raises ArgumentError when tapestry is full' do
+      small_tap = engine.create_tapestry(name: 'tiny', pattern: :plain, capacity: 1)
+      t1 = spin(content: 'a')
+      t2 = spin(content: 'b')
+      engine.weave(thread_id: t1.id, tapestry_id: small_tap.id)
+      expect { engine.weave(thread_id: t2.id, tapestry_id: small_tap.id) }
+        .to raise_error(ArgumentError, /full/)
+    end
+
+    it 'raises ArgumentError for missing thread' do
+      expect { engine.weave(thread_id: 'nope', tapestry_id: tap.id) }
+        .to raise_error(ArgumentError, /thread not found/)
+    end
+
+    it 'raises ArgumentError for missing tapestry' do
+      expect { engine.weave(thread_id: t.id, tapestry_id: 'nope') }
+        .to raise_error(ArgumentError, /tapestry not found/)
+    end
+  end
+
+  describe '#unravel' do
+    let(:t)   { spin }
+    let(:tap) { create_tap }
+
+    before { engine.weave(thread_id: t.id, tapestry_id: tap.id) }
+
+    it 'returns the Thread' do
+      result = engine.unravel(thread_id: t.id, tapestry_id: tap.id)
+      expect(result).to be_a(Legion::Extensions::Agentic::Integration::Tapestry::Helpers::Thread)
+    end
+
+    it 'marks thread as loose' do
+      engine.unravel(thread_id: t.id, tapestry_id: tap.id)
+      expect(t.loose?).to be true
+    end
+
+    it 'removes thread from tapestry' do
+      engine.unravel(thread_id: t.id, tapestry_id: tap.id)
+      expect(tap.thread_ids).not_to include(t.id)
+    end
+  end
+
+  describe '#fray_all!' do
+    it 'returns stats hash' do
+      spin
+      result = engine.fray_all!
+      expect(result).to have_key(:total)
+      expect(result).to have_key(:snapped)
+    end
+
+    it 'decreases thread strengths' do
+      t = spin(strength: 0.5)
+      engine.fray_all!
+      expect(t.strength).to be < 0.5
+    end
+
+    it 'counts snapped threads' do
+      t = spin(strength: 0.0)
+      result = engine.fray_all!
+      expect(result[:snapped]).to be >= 1
+      expect(t).to be_snap
+    end
+  end
+
+  describe '#most_complete' do
+    it 'returns tapestries sorted by completeness descending' do
+      tap1 = create_tap(name: 'a', pattern: :plain, capacity: 2)
+      create_tap(name: 'b', pattern: :twill, capacity: 10)
+      engine.spin_thread(thread_type: :experience, domain: :x, content: 'c').tap do |t|
+        engine.weave(thread_id: t.id, tapestry_id: tap1.id)
+      end
+      result = engine.most_complete(limit: 2)
+      expect(result.first.id).to eq(tap1.id)
+    end
+
+    it 'respects the limit' do
+      3.times { |i| create_tap(name: "t#{i}", pattern: :plain) }
+      expect(engine.most_complete(limit: 2).size).to eq(2)
+    end
+  end
+
+  describe '#most_coherent' do
+    it 'returns tapestries' do
+      create_tap
+      result = engine.most_coherent(limit: 1)
+      expect(result).not_to be_empty
+    end
+  end
+
+  describe '#thread_inventory' do
+    it 'returns counts per thread type' do
+      spin(type: :belief)
+      spin(type: :memory)
+      inv = engine.thread_inventory
+      expect(inv[:belief]).to eq(1)
+      expect(inv[:memory]).to eq(1)
+      expect(inv[:experience]).to eq(0)
+    end
+  end
+
+  describe '#tapestry_report' do
+    it 'includes expected keys' do
+      result = engine.tapestry_report
+      %i[total_threads total_tapestries loose_count by_type fraying_count avg_completeness].each do |k|
+        expect(result).to have_key(k)
+      end
+    end
+
+    it 'counts loose threads' do
+      spin
+      expect(engine.tapestry_report[:loose_count]).to eq(1)
+    end
+  end
+
+  describe '#loose_threads' do
+    it 'returns unplaced threads' do
+      t = spin
+      expect(engine.loose_threads).to include(t)
+    end
+
+    it 'excludes woven threads' do
+      t   = spin
+      tap = create_tap
+      engine.weave(thread_id: t.id, tapestry_id: tap.id)
+      expect(engine.loose_threads).not_to include(t)
+    end
+  end
+
+  describe '#all_threads and #all_tapestries' do
+    it 'returns all threads' do
+      spin
+      expect(engine.all_threads.size).to eq(1)
+    end
+
+    it 'returns all tapestries' do
+      create_tap
+      expect(engine.all_tapestries.size).to eq(1)
+    end
+  end
+end