lex-agentic-integration 0.1.0

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

@@ -0,0 +1,229 @@
+# frozen_string_literal: true
+
+RSpec.describe Legion::Extensions::Agentic::Integration::Tapestry::Helpers::Tapestry do
+  subject(:tapestry) do
+    described_class.new(name: 'life story', pattern: :brocade, capacity: 10)
+  end
+
+  let(:thread_klass) { Legion::Extensions::Agentic::Integration::Tapestry::Helpers::Thread }
+
+  def make_thread(type: :experience, strength: 0.5)
+    thread_klass.new(thread_type: type, domain: :reasoning, content: 'event', strength: strength)
+  end
+
+  describe '#initialize' do
+    it 'sets name' do
+      expect(tapestry.name).to eq('life story')
+    end
+
+    it 'sets pattern' do
+      expect(tapestry.pattern).to eq(:brocade)
+    end
+
+    it 'sets capacity' do
+      expect(tapestry.capacity).to eq(10)
+    end
+
+    it 'generates a uuid id' do
+      expect(tapestry.id).to match(/\A[0-9a-f-]{36}\z/)
+    end
+
+    it 'starts empty' do
+      expect(tapestry.empty?).to be true
+    end
+
+    it 'starts not full' do
+      expect(tapestry.full?).to be false
+    end
+
+    it 'records created_at' do
+      expect(tapestry.created_at).to be_a(Time)
+    end
+
+    it 'rejects unknown pattern' do
+      expect do
+        described_class.new(name: 'x', pattern: :zigzag)
+      end.to raise_error(ArgumentError, /unknown pattern/)
+    end
+
+    it 'clamps capacity to at least 1' do
+      t = described_class.new(name: 'x', pattern: :plain, capacity: 0)
+      expect(t.capacity).to eq(1)
+    end
+  end
+
+  describe '#weave_thread' do
+    let(:t) { make_thread }
+
+    it 'adds thread id and returns true' do
+      expect(tapestry.weave_thread(t.id)).to be true
+    end
+
+    it 'rejects duplicate thread' do
+      tapestry.weave_thread(t.id)
+      expect(tapestry.weave_thread(t.id)).to be false
+    end
+
+    it 'rejects when full' do
+      10.times do
+        th = make_thread
+        tapestry.weave_thread(th.id)
+      end
+      extra = make_thread
+      expect(tapestry.weave_thread(extra.id)).to be false
+    end
+  end
+
+  describe '#unravel_thread' do
+    let(:t) { make_thread }
+
+    it 'removes thread and returns true' do
+      tapestry.weave_thread(t.id)
+      expect(tapestry.unravel_thread(t.id)).to be true
+    end
+
+    it 'returns false for unknown thread' do
+      expect(tapestry.unravel_thread('nope')).to be false
+    end
+  end
+
+  describe '#size' do
+    it 'starts at zero' do
+      expect(tapestry.size).to eq(0)
+    end
+
+    it 'increments after weave' do
+      tapestry.weave_thread('t-1')
+      expect(tapestry.size).to eq(1)
+    end
+  end
+
+  describe '#completeness' do
+    it 'returns 0.0 when empty' do
+      expect(tapestry.completeness).to eq(0.0)
+    end
+
+    it 'returns fraction of capacity' do
+      5.times { tapestry.weave_thread(SecureRandom.uuid) }
+      expect(tapestry.completeness).to eq(0.5)
+    end
+
+    it 'returns 1.0 when full' do
+      10.times { tapestry.weave_thread(SecureRandom.uuid) }
+      expect(tapestry.completeness).to eq(1.0)
+    end
+  end
+
+  describe '#gap_count' do
+    it 'equals capacity minus size' do
+      tapestry.weave_thread(SecureRandom.uuid)
+      expect(tapestry.gap_count).to eq(9)
+    end
+  end
+
+  describe '#fraying?' do
+    it 'returns false with no threads' do
+      expect(tapestry.fraying?([])).to be false
+    end
+
+    it 'returns true when avg strength < 0.3' do
+      t = make_thread(strength: 0.1)
+      tapestry.weave_thread(t.id)
+      expect(tapestry.fraying?([t])).to be true
+    end
+
+    it 'returns false when avg strength >= 0.3' do
+      t = make_thread(strength: 0.8)
+      tapestry.weave_thread(t.id)
+      expect(tapestry.fraying?([t])).to be false
+    end
+  end
+
+  describe '#masterwork?' do
+    it 'returns false when empty' do
+      expect(tapestry.masterwork?([])).to be false
+    end
+
+    it 'returns true when threads taut and completeness high' do
+      cap = 3
+      tap = described_class.new(name: 'x', pattern: :brocade, capacity: cap)
+      threads = cap.times.map do
+        make_thread(strength: 0.95).tap { |t| tap.weave_thread(t.id) }
+      end
+      expect(tap.masterwork?(threads)).to be true
+    end
+
+    it 'returns false when completeness low' do
+      t = make_thread(strength: 0.95)
+      tapestry.weave_thread(t.id)
+      expect(tapestry.masterwork?([t])).to be false
+    end
+  end
+
+  describe '#coherence_score' do
+    it 'returns 0.0 for empty tapestry' do
+      expect(tapestry.coherence_score([])).to eq(0.0)
+    end
+
+    it 'returns a float between 0 and 1' do
+      t = make_thread(strength: 0.7)
+      tapestry.weave_thread(t.id)
+      score = tapestry.coherence_score([t])
+      expect(score).to be_between(0.0, 1.0)
+    end
+
+    it 'benefits from higher pattern coherence factor (brocade > plain)' do
+      plain_tap = described_class.new(name: 'p', pattern: :plain, capacity: 5)
+      brocade_tap = described_class.new(name: 'b', pattern: :brocade, capacity: 5)
+      t = make_thread(strength: 0.7)
+      plain_tap.weave_thread(t.id)
+      brocade_tap.weave_thread(t.id)
+      expect(brocade_tap.coherence_score([t])).to be > plain_tap.coherence_score([t])
+    end
+  end
+
+  describe '#completeness_label' do
+    it 'returns a symbol' do
+      expect(tapestry.completeness_label).to be_a(Symbol)
+    end
+  end
+
+  describe '#complexity_label' do
+    it 'returns a symbol' do
+      t = make_thread(strength: 0.7)
+      tapestry.weave_thread(t.id)
+      expect(tapestry.complexity_label([t])).to be_a(Symbol)
+    end
+  end
+
+  describe '#to_h' do
+    it 'includes all expected keys' do
+      h = tapestry.to_h([])
+      %i[id name pattern capacity size completeness completeness_label
+         coherence_score gap_count full empty fraying masterwork
+         thread_ids created_at].each do |k|
+        expect(h).to have_key(k)
+      end
+    end
+
+    it 'thread_ids is a dup (not the same array)' do
+      tap_h = tapestry.to_h([])
+      tap_h[:thread_ids] << 'injected'
+      expect(tapestry.thread_ids).not_to include('injected')
+    end
+  end
+
+  describe '#age!' do
+    it 'returns the fray_rate (no state mutation on tapestry itself)' do
+      result = tapestry.age!
+      expect(result).to be_a(Numeric)
+    end
+  end
+
+  describe '#repair!' do
+    it 'returns the boost value' do
+      result = tapestry.repair!
+      expect(result).to eq(0.1)
+    end
+  end
+end

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

@@ -0,0 +1,211 @@
+# frozen_string_literal: true
+
+RSpec.describe Legion::Extensions::Agentic::Integration::Tapestry::Helpers::Thread do
+  subject(:thread) do
+    described_class.new(thread_type: :experience, domain: :reasoning, content: 'a past event')
+  end
+
+  describe '#initialize' do
+    it 'sets thread_type' do
+      expect(thread.thread_type).to eq(:experience)
+    end
+
+    it 'sets domain as symbol' do
+      expect(thread.domain).to eq(:reasoning)
+    end
+
+    it 'sets content as string' do
+      expect(thread.content).to eq('a past event')
+    end
+
+    it 'generates a uuid id' do
+      expect(thread.id).to match(/\A[0-9a-f-]{36}\z/)
+    end
+
+    it 'defaults strength to 0.5' do
+      expect(thread.strength).to eq(0.5)
+    end
+
+    it 'assigns a default color based on type' do
+      expect(thread.color).to eq(:gold)
+    end
+
+    it 'starts as loose (not woven)' do
+      expect(thread.loose?).to be true
+    end
+
+    it 'starts with nil tapestry_id' do
+      expect(thread.tapestry_id).to be_nil
+    end
+
+    it 'records created_at' do
+      expect(thread.created_at).to be_a(Time)
+    end
+
+    it 'clamps strength above 1.0' do
+      t = described_class.new(thread_type: :belief, domain: :x, content: 'y', strength: 2.0)
+      expect(t.strength).to eq(1.0)
+    end
+
+    it 'clamps strength below 0.0' do
+      t = described_class.new(thread_type: :memory, domain: :x, content: 'y', strength: -0.5)
+      expect(t.strength).to eq(0.0)
+    end
+
+    it 'accepts custom color' do
+      t = described_class.new(thread_type: :emotion, domain: :x, content: 'y', color: :amber)
+      expect(t.color).to eq(:amber)
+    end
+
+    it 'rejects unknown thread_type' do
+      expect do
+        described_class.new(thread_type: :unknown, domain: :x, content: 'y')
+      end.to raise_error(ArgumentError, /unknown thread_type/)
+    end
+  end
+
+  describe '#woven_into!' do
+    it 'sets tapestry_id' do
+      thread.woven_into!('tap-1')
+      expect(thread.tapestry_id).to eq('tap-1')
+    end
+
+    it 'marks thread as woven' do
+      thread.woven_into!('tap-1')
+      expect(thread.woven?).to be true
+    end
+
+    it 'returns self' do
+      expect(thread.woven_into!('tap-1')).to eq(thread)
+    end
+  end
+
+  describe '#unwoven!' do
+    before { thread.woven_into!('tap-1') }
+
+    it 'clears tapestry_id' do
+      thread.unwoven!
+      expect(thread.tapestry_id).to be_nil
+    end
+
+    it 'marks thread as loose' do
+      thread.unwoven!
+      expect(thread.loose?).to be true
+    end
+  end
+
+  describe '#reinforce!' do
+    it 'increases strength by TENSION_RATE by default' do
+      before = thread.strength
+      thread.reinforce!
+      expect(thread.strength).to eq((before + Legion::Extensions::Agentic::Integration::Tapestry::Helpers::Constants::TENSION_RATE).round(10))
+    end
+
+    it 'accepts custom rate' do
+      thread.reinforce!(rate: 0.1)
+      expect(thread.strength).to eq(0.6)
+    end
+
+    it 'clamps at 1.0' do
+      t = described_class.new(thread_type: :narrative, domain: :x, content: 'y', strength: 0.99)
+      t.reinforce!(rate: 0.5)
+      expect(t.strength).to eq(1.0)
+    end
+
+    it 'returns self' do
+      expect(thread.reinforce!).to eq(thread)
+    end
+  end
+
+  describe '#fray!' do
+    it 'decreases strength by FRAY_RATE by default' do
+      before = thread.strength
+      thread.fray!
+      expect(thread.strength).to eq((before - Legion::Extensions::Agentic::Integration::Tapestry::Helpers::Constants::FRAY_RATE).round(10))
+    end
+
+    it 'accepts custom rate' do
+      thread.fray!(rate: 0.2)
+      expect(thread.strength).to eq(0.3)
+    end
+
+    it 'clamps at 0.0' do
+      t = described_class.new(thread_type: :experience, domain: :x, content: 'y', strength: 0.01)
+      t.fray!(rate: 0.5)
+      expect(t.strength).to eq(0.0)
+    end
+
+    it 'returns self' do
+      expect(thread.fray!).to eq(thread)
+    end
+  end
+
+  describe '#snap?' do
+    it 'returns false when strength is positive' do
+      expect(thread.snap?).to be false
+    end
+
+    it 'returns true when strength is zero' do
+      t = described_class.new(thread_type: :belief, domain: :x, content: 'y', strength: 0.0)
+      expect(t.snap?).to be true
+    end
+  end
+
+  describe '#taut?' do
+    it 'returns false at default strength' do
+      expect(thread.taut?).to be false
+    end
+
+    it 'returns true at 0.9 or above' do
+      t = described_class.new(thread_type: :memory, domain: :x, content: 'y', strength: 0.95)
+      expect(t.taut?).to be true
+    end
+  end
+
+  describe '#thread_integrity' do
+    it 'returns a symbol label' do
+      expect(thread.thread_integrity).to be_a(Symbol)
+    end
+
+    it 'returns masterwork for high strength' do
+      t = described_class.new(thread_type: :emotion, domain: :x, content: 'y', strength: 0.95)
+      expect(t.thread_integrity).to eq(:masterwork)
+    end
+
+    it 'returns rags for near-zero strength' do
+      t = described_class.new(thread_type: :narrative, domain: :x, content: 'y', strength: 0.05)
+      expect(t.thread_integrity).to eq(:rags)
+    end
+  end
+
+  describe '#to_h' do
+    it 'includes all expected keys' do
+      h = thread.to_h
+      %i[id thread_type domain content strength color thread_integrity
+         woven loose snap taut tapestry_id created_at].each do |k|
+        expect(h).to have_key(k)
+      end
+    end
+
+    it 'reflects current woven state' do
+      thread.woven_into!('t-1')
+      expect(thread.to_h[:woven]).to be true
+      expect(thread.to_h[:loose]).to be false
+    end
+  end
+
+  describe 'color defaults per thread_type' do
+    {
+      experience: :gold,
+      belief:     :silver,
+      memory:     :blue,
+      emotion:    :crimson,
+      narrative:  :violet
+    }.each do |type, expected_color|
+      it "assigns #{expected_color} for #{type}" do
+        t = described_class.new(thread_type: type, domain: :x, content: 'y')
+        expect(t.color).to eq(expected_color)
+      end
+    end
+  end
+end

data/spec/legion/extensions/agentic/integration/tapestry/runners/cognitive_tapestry_spec.rb

@@ -0,0 +1,171 @@
+# frozen_string_literal: true
+
+RSpec.describe Legion::Extensions::Agentic::Integration::Tapestry::Runners::CognitiveTapestry do
+  let(:engine) { Legion::Extensions::Agentic::Integration::Tapestry::Helpers::LoomEngine.new }
+
+  describe '.spin_thread' do
+    it 'returns success with thread hash' do
+      result = described_class.spin_thread(
+        thread_type: :experience, domain: :test, content: 'something happened',
+        engine: engine
+      )
+      expect(result[:success]).to be true
+      expect(result[:thread][:thread_type]).to eq(:experience)
+    end
+
+    it 'returns failure for invalid thread_type' do
+      result = described_class.spin_thread(
+        thread_type: :bogus, domain: :x, content: 'y', engine: engine
+      )
+      expect(result[:success]).to be false
+      expect(result[:error]).to include('unknown thread_type')
+    end
+
+    it 'accepts optional strength and color' do
+      result = described_class.spin_thread(
+        thread_type: :belief, domain: :x, content: 'core belief',
+        strength: 0.8, color: :amber, engine: engine
+      )
+      expect(result[:success]).to be true
+      expect(result[:thread][:strength]).to eq(0.8)
+      expect(result[:thread][:color]).to eq(:amber)
+    end
+
+    it 'absorbs extra keyword args via **' do
+      expect do
+        described_class.spin_thread(
+          thread_type: :memory, domain: :x, content: 'y',
+          engine: engine, unknown_key: 'ignored'
+        )
+      end.not_to raise_error
+    end
+  end
+
+  describe '.create_tapestry' do
+    it 'returns success with tapestry hash' do
+      result = described_class.create_tapestry(
+        name: 'my story', pattern: :brocade, engine: engine
+      )
+      expect(result[:success]).to be true
+      expect(result[:tapestry][:name]).to eq('my story')
+      expect(result[:tapestry][:pattern]).to eq(:brocade)
+    end
+
+    it 'returns failure for invalid pattern' do
+      result = described_class.create_tapestry(
+        name: 'x', pattern: :hexagonal, engine: engine
+      )
+      expect(result[:success]).to be false
+    end
+
+    it 'accepts custom capacity' do
+      result = described_class.create_tapestry(
+        name: 'limited', pattern: :plain, capacity: 5, engine: engine
+      )
+      expect(result[:success]).to be true
+      expect(result[:tapestry][:capacity]).to eq(5)
+    end
+  end
+
+  describe '.weave' do
+    let(:thread_result) do
+      described_class.spin_thread(thread_type: :narrative, domain: :x, content: 'a', engine: engine)
+    end
+    let(:tapestry_result) do
+      described_class.create_tapestry(name: 'canvas', pattern: :satin, engine: engine)
+    end
+
+    it 'successfully weaves thread into tapestry' do
+      result = described_class.weave(
+        thread_id:   thread_result[:thread][:id],
+        tapestry_id: tapestry_result[:tapestry][:id],
+        engine:      engine
+      )
+      expect(result[:success]).to be true
+      expect(result[:thread][:woven]).to be true
+    end
+
+    it 'returns failure when thread is already woven' do
+      first_tap = described_class.create_tapestry(name: 'first', pattern: :plain, engine: engine)
+      described_class.weave(
+        thread_id:   thread_result[:thread][:id],
+        tapestry_id: first_tap[:tapestry][:id],
+        engine:      engine
+      )
+      result = described_class.weave(
+        thread_id:   thread_result[:thread][:id],
+        tapestry_id: tapestry_result[:tapestry][:id],
+        engine:      engine
+      )
+      expect(result[:success]).to be false
+      expect(result[:error]).to include('already woven')
+    end
+
+    it 'returns failure for unknown thread_id' do
+      result = described_class.weave(
+        thread_id: 'nonexistent', tapestry_id: tapestry_result[:tapestry][:id], engine: engine
+      )
+      expect(result[:success]).to be false
+    end
+
+    it 'returns failure for unknown tapestry_id' do
+      result = described_class.weave(
+        thread_id: thread_result[:thread][:id], tapestry_id: 'nonexistent', engine: engine
+      )
+      expect(result[:success]).to be false
+    end
+  end
+
+  describe '.list_tapestries' do
+    before do
+      described_class.create_tapestry(name: 'plain one', pattern: :plain, engine: engine)
+      described_class.create_tapestry(name: 'twill one', pattern: :twill, engine: engine)
+    end
+
+    it 'returns all tapestries when no filter' do
+      result = described_class.list_tapestries(engine: engine)
+      expect(result[:success]).to be true
+      expect(result[:count]).to eq(2)
+    end
+
+    it 'filters by pattern' do
+      result = described_class.list_tapestries(engine: engine, pattern: :plain)
+      expect(result[:count]).to eq(1)
+      expect(result[:tapestries].first[:pattern]).to eq(:plain)
+    end
+
+    it 'filters fraying_only' do
+      weak_t = engine.spin_thread(thread_type: :emotion, domain: :x, content: 'y', strength: 0.05)
+      tap3   = engine.create_tapestry(name: 'fragile', pattern: :satin, capacity: 5)
+      engine.weave(thread_id: weak_t.id, tapestry_id: tap3.id)
+      result = described_class.list_tapestries(engine: engine, fraying_only: true)
+      expect(result[:count]).to be >= 1
+    end
+
+    it 'returns empty array when no match' do
+      result = described_class.list_tapestries(engine: engine, pattern: :brocade)
+      expect(result[:count]).to eq(0)
+      expect(result[:tapestries]).to be_empty
+    end
+  end
+
+  describe '.loom_status' do
+    it 'returns success with report' do
+      result = described_class.loom_status(engine: engine)
+      expect(result[:success]).to be true
+      expect(result[:report]).to have_key(:total_threads)
+      expect(result[:report]).to have_key(:total_tapestries)
+    end
+
+    it 'report includes loose_count' do
+      described_class.spin_thread(thread_type: :belief, domain: :x, content: 'y', engine: engine)
+      result = described_class.loom_status(engine: engine)
+      expect(result[:report][:loose_count]).to eq(1)
+    end
+
+    it 'report includes fraying_count' do
+      result = described_class.loom_status(engine: engine)
+      expect(result[:report]).to have_key(:fraying_count)
+    end
+  end
+end

data/spec/legion/extensions/agentic/integration/tessellation/client_spec.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+RSpec.describe Legion::Extensions::Agentic::Integration::Tessellation::Client do
+  subject(:client) { described_class.new }
+
+  it 'responds to runner methods' do
+    expect(client).to respond_to(:create_tile, :expand_tile, :tessellation_status)
+  end
+
+  it 'runs a full tessellation lifecycle' do
+    result = client.create_tile(tile_type: :knowledge, shape: :hexagonal, domain: :cognitive, coverage: 0.3)
+    tile_id = result[:tile][:id]
+
+    client.expand_tile(tile_id: tile_id)
+    client.create_tile(tile_type: :skill, shape: :square, domain: :cognitive, coverage: 0.5)
+
+    status = client.tessellation_status
+    expect(status[:total_tiles]).to eq(2)
+    expect(status[:success]).to be true
+  end
+
+  it 'lists gaps' do
+    client.create_tile(tile_type: :knowledge, shape: :hexagonal, domain: :cognitive, fit_score: 0.1)
+    gaps = client.list_gaps
+    expect(gaps[:count]).to eq(1)
+  end
+
+  it 'connects tiles across domains' do
+    r1 = client.create_tile(tile_type: :knowledge, shape: :hexagonal, domain: :cognitive)
+    r2 = client.create_tile(tile_type: :skill, shape: :square, domain: :emotional)
+    result = client.connect_tiles(tile_a_id: r1[:tile][:id], tile_b_id: r2[:tile][:id])
+    expect(result[:success]).to be true
+  end
+
+  it 'shrinks all tiles' do
+    client.create_tile(tile_type: :knowledge, shape: :hexagonal, domain: :cognitive, coverage: 0.5)
+    result = client.shrink_all
+    expect(result[:success]).to be true
+  end
+end