lex-agentic-integration 0.1.0

data/spec/legion/extensions/agentic/integration/tessellation/helpers/mosaic_spec.rb

@@ -0,0 +1,99 @@
+# frozen_string_literal: true
+
+RSpec.describe Legion::Extensions::Agentic::Integration::Tessellation::Helpers::Mosaic do
+  subject(:mosaic) { described_class.new(domain: :cognitive) }
+
+  let(:tile_class) { Legion::Extensions::Agentic::Integration::Tessellation::Helpers::Tile }
+
+  describe '#initialize' do
+    it 'assigns a uuid id' do
+      expect(mosaic.id).to match(/\A[0-9a-f-]{36}\z/)
+    end
+
+    it 'stores domain as symbol' do
+      expect(mosaic.domain).to eq(:cognitive)
+    end
+
+    it 'starts with empty tiles' do
+      expect(mosaic.tiles).to be_empty
+    end
+  end
+
+  describe '#add_tile' do
+    it 'adds a tile to the mosaic' do
+      tile = tile_class.new(tile_type: :knowledge, shape: :hexagonal, domain: :cognitive)
+      mosaic.add_tile(tile)
+      expect(mosaic.tiles.size).to eq(1)
+    end
+
+    it 'auto-connects tiles of the same domain' do
+      t1 = tile_class.new(tile_type: :knowledge, shape: :hexagonal, domain: :cognitive, coverage: 0.5)
+      t2 = tile_class.new(tile_type: :skill, shape: :hexagonal, domain: :cognitive, coverage: 0.5)
+      mosaic.add_tile(t1)
+      mosaic.add_tile(t2)
+      expect(t2.adjacent_ids).to include(t1.id)
+    end
+  end
+
+  describe '#total_coverage' do
+    it 'returns 0.0 for empty mosaic' do
+      expect(mosaic.total_coverage).to eq(0.0)
+    end
+
+    it 'returns average effective coverage' do
+      t1 = tile_class.new(tile_type: :knowledge, shape: :hexagonal, domain: :cognitive, coverage: 0.6)
+      t2 = tile_class.new(tile_type: :skill, shape: :square, domain: :cognitive, coverage: 0.4)
+      mosaic.add_tile(t1)
+      mosaic.add_tile(t2)
+      expect(mosaic.total_coverage).to be_between(0.0, 1.0)
+    end
+  end
+
+  describe '#average_fit' do
+    it 'returns 0.0 for empty mosaic' do
+      expect(mosaic.average_fit).to eq(0.0)
+    end
+
+    it 'computes average fit score' do
+      t1 = tile_class.new(tile_type: :knowledge, shape: :hexagonal, domain: :cognitive, fit_score: 0.8)
+      mosaic.add_tile(t1)
+      expect(mosaic.average_fit).to be > 0.0
+    end
+  end
+
+  describe '#coherence' do
+    it 'returns 0.0 for empty mosaic' do
+      expect(mosaic.coherence).to eq(0.0)
+    end
+  end
+
+  describe '#uniformity' do
+    it 'returns 1.0 for single tile' do
+      t = tile_class.new(tile_type: :knowledge, shape: :hexagonal, domain: :cognitive, coverage: 0.5)
+      mosaic.add_tile(t)
+      expect(mosaic.uniformity).to eq(1.0)
+    end
+
+    it 'returns high uniformity for similar coverages' do
+      t1 = tile_class.new(tile_type: :knowledge, shape: :hexagonal, domain: :cognitive, coverage: 0.5)
+      t2 = tile_class.new(tile_type: :skill, shape: :hexagonal, domain: :cognitive, coverage: 0.5)
+      mosaic.add_tile(t1)
+      mosaic.add_tile(t2)
+      expect(mosaic.uniformity).to be > 0.9
+    end
+  end
+
+  describe '#complete?' do
+    it 'returns false for low coverage' do
+      expect(mosaic).not_to be_complete
+    end
+  end
+
+  describe '#to_h' do
+    it 'returns hash with mosaic stats' do
+      h = mosaic.to_h
+      expect(h).to include(:id, :domain, :tile_count, :total_coverage, :average_fit,
+                           :coherence, :uniformity, :gaps, :seamless, :complete)
+    end
+  end
+end

data/spec/legion/extensions/agentic/integration/tessellation/helpers/tessellation_engine_spec.rb

@@ -0,0 +1,145 @@
+# frozen_string_literal: true
+
+RSpec.describe Legion::Extensions::Agentic::Integration::Tessellation::Helpers::TessellationEngine do
+  subject(:engine) { described_class.new }
+
+  describe '#create_tile' do
+    it 'creates a tile and returns it' do
+      tile = engine.create_tile(tile_type: :knowledge, shape: :hexagonal, domain: :cognitive)
+      expect(tile).to be_a(Legion::Extensions::Agentic::Integration::Tessellation::Helpers::Tile)
+    end
+
+    it 'adds tile to a mosaic for its domain' do
+      engine.create_tile(tile_type: :knowledge, shape: :hexagonal, domain: :cognitive)
+      report = engine.tessellation_report
+      expect(report[:total_mosaics]).to eq(1)
+    end
+
+    it 'reuses existing mosaic for same domain' do
+      engine.create_tile(tile_type: :knowledge, shape: :hexagonal, domain: :cognitive)
+      engine.create_tile(tile_type: :skill, shape: :square, domain: :cognitive)
+      report = engine.tessellation_report
+      expect(report[:total_mosaics]).to eq(1)
+    end
+
+    it 'creates separate mosaics for different domains' do
+      engine.create_tile(tile_type: :knowledge, shape: :hexagonal, domain: :cognitive)
+      engine.create_tile(tile_type: :skill, shape: :square, domain: :emotional)
+      report = engine.tessellation_report
+      expect(report[:total_mosaics]).to eq(2)
+    end
+  end
+
+  describe '#expand_tile' do
+    it 'expands an existing tile' do
+      tile = engine.create_tile(tile_type: :knowledge, shape: :hexagonal, domain: :cognitive)
+      result = engine.expand_tile(tile_id: tile.id)
+      expect(result.coverage).to be > 0.0
+    end
+
+    it 'returns nil for unknown tile' do
+      expect(engine.expand_tile(tile_id: 'nonexistent')).to be_nil
+    end
+  end
+
+  describe '#shrink_all!' do
+    it 'reduces coverage of all tiles' do
+      tile = engine.create_tile(tile_type: :knowledge, shape: :hexagonal, domain: :cognitive, coverage: 0.5)
+      engine.shrink_all!
+      expect(tile.coverage).to be < 0.5
+    end
+  end
+
+  describe '#connect_tiles' do
+    it 'connects two tiles' do
+      t1 = engine.create_tile(tile_type: :knowledge, shape: :hexagonal, domain: :cognitive)
+      t2 = engine.create_tile(tile_type: :skill, shape: :square, domain: :emotional)
+      result = engine.connect_tiles(tile_a_id: t1.id, tile_b_id: t2.id)
+      expect(result[:connected]).to be true
+    end
+
+    it 'returns nil for missing tiles' do
+      t1 = engine.create_tile(tile_type: :knowledge, shape: :hexagonal, domain: :cognitive)
+      expect(engine.connect_tiles(tile_a_id: t1.id, tile_b_id: 'missing')).to be_nil
+    end
+  end
+
+  describe 'query methods' do
+    before do
+      engine.create_tile(tile_type: :knowledge, shape: :hexagonal, domain: :cognitive, coverage: 0.5)
+      engine.create_tile(tile_type: :skill, shape: :square, domain: :emotional, coverage: 0.3)
+      engine.create_tile(tile_type: :pattern, shape: :hexagonal, domain: :cognitive, coverage: 0.8)
+    end
+
+    it 'filters tiles_by_domain' do
+      expect(engine.tiles_by_domain(domain: :cognitive).size).to eq(2)
+    end
+
+    it 'filters tiles_by_type' do
+      expect(engine.tiles_by_type(tile_type: :knowledge).size).to eq(1)
+    end
+
+    it 'filters tiles_by_shape' do
+      expect(engine.tiles_by_shape(shape: :hexagonal).size).to eq(2)
+    end
+
+    it 'returns most_covered tiles' do
+      results = engine.most_covered(limit: 2)
+      expect(results.size).to eq(2)
+      expect(results.first.coverage).to be >= results.last.coverage
+    end
+
+    it 'returns least_covered tiles' do
+      results = engine.least_covered(limit: 1)
+      expect(results.size).to eq(1)
+    end
+  end
+
+  describe 'aggregate metrics' do
+    it 'returns 0.0 overall_coverage for empty engine' do
+      expect(engine.overall_coverage).to eq(0.0)
+    end
+
+    it 'returns 0.0 overall_fit for empty engine' do
+      expect(engine.overall_fit).to eq(0.0)
+    end
+
+    it 'computes overall_coverage from mosaics' do
+      engine.create_tile(tile_type: :knowledge, shape: :hexagonal, domain: :cognitive, coverage: 0.6)
+      expect(engine.overall_coverage).to be > 0.0
+    end
+
+    it 'computes overall_fit from tiles' do
+      engine.create_tile(tile_type: :knowledge, shape: :hexagonal, domain: :cognitive)
+      expect(engine.overall_fit).to be > 0.0
+    end
+
+    it 'computes gap_density' do
+      engine.create_tile(tile_type: :knowledge, shape: :hexagonal, domain: :cognitive, fit_score: 0.1)
+      expect(engine.gap_density).to be > 0.0
+    end
+  end
+
+  describe '#tessellation_report' do
+    it 'returns comprehensive report' do
+      engine.create_tile(tile_type: :knowledge, shape: :hexagonal, domain: :cognitive, coverage: 0.5)
+      report = engine.tessellation_report
+      expect(report).to include(:total_tiles, :total_mosaics, :overall_coverage,
+                                :coverage_label, :overall_fit, :fit_label,
+                                :overall_coherence, :gap_density, :domain_coverage, :mosaics)
+    end
+
+    it 'includes coverage_label' do
+      engine.create_tile(tile_type: :knowledge, shape: :hexagonal, domain: :cognitive, coverage: 0.5)
+      report = engine.tessellation_report
+      expect(report[:coverage_label]).to be_a(Symbol)
+    end
+  end
+
+  describe '#to_h' do
+    it 'returns summary hash' do
+      h = engine.to_h
+      expect(h).to include(:total_tiles, :total_mosaics, :coverage, :fit, :coherence)
+    end
+  end
+end

data/spec/legion/extensions/agentic/integration/tessellation/helpers/tile_spec.rb

@@ -0,0 +1,138 @@
+# frozen_string_literal: true
+
+RSpec.describe Legion::Extensions::Agentic::Integration::Tessellation::Helpers::Tile do
+  subject(:tile) { described_class.new(tile_type: :knowledge, shape: :hexagonal, domain: :cognitive) }
+
+  describe '#initialize' do
+    it 'assigns a uuid id' do
+      expect(tile.id).to match(/\A[0-9a-f-]{36}\z/)
+    end
+
+    it 'stores tile_type as symbol' do
+      expect(tile.tile_type).to eq(:knowledge)
+    end
+
+    it 'stores shape as symbol' do
+      expect(tile.shape).to eq(:hexagonal)
+    end
+
+    it 'stores domain as symbol' do
+      expect(tile.domain).to eq(:cognitive)
+    end
+
+    it 'defaults coverage to 0.0' do
+      expect(tile.coverage).to eq(0.0)
+    end
+
+    it 'defaults fit_score to 0.5' do
+      expect(tile.fit_score).to eq(0.5)
+    end
+
+    it 'starts with empty adjacent_ids' do
+      expect(tile.adjacent_ids).to be_empty
+    end
+
+    it 'accepts explicit coverage' do
+      t = described_class.new(tile_type: :skill, shape: :square, domain: :emotional, coverage: 0.8)
+      expect(t.coverage).to eq(0.8)
+    end
+
+    it 'clamps coverage to 0..1' do
+      t = described_class.new(tile_type: :skill, shape: :square, domain: :emotional, coverage: 1.5)
+      expect(t.coverage).to eq(1.0)
+    end
+  end
+
+  describe '#expand!' do
+    it 'increases coverage' do
+      tile.expand!
+      expect(tile.coverage).to be > 0.0
+    end
+
+    it 'clamps coverage at 1.0' do
+      t = described_class.new(tile_type: :skill, shape: :square, domain: :cognitive, coverage: 0.98)
+      t.expand!(0.1)
+      expect(t.coverage).to eq(1.0)
+    end
+  end
+
+  describe '#shrink!' do
+    it 'decreases coverage' do
+      t = described_class.new(tile_type: :skill, shape: :square, domain: :cognitive, coverage: 0.5)
+      t.shrink!
+      expect(t.coverage).to be < 0.5
+    end
+
+    it 'clamps coverage at 0.0' do
+      t = described_class.new(tile_type: :skill, shape: :square, domain: :cognitive, coverage: 0.01)
+      t.shrink!(0.1)
+      expect(t.coverage).to eq(0.0)
+    end
+  end
+
+  describe '#adjust_fit!' do
+    it 'updates fit_score' do
+      tile.adjust_fit!(0.9)
+      expect(tile.fit_score).to eq(0.9)
+    end
+
+    it 'clamps fit_score' do
+      tile.adjust_fit!(1.5)
+      expect(tile.fit_score).to eq(1.0)
+    end
+  end
+
+  describe '#connect!' do
+    it 'adds adjacent id' do
+      tile.connect!('other-id')
+      expect(tile.adjacent_ids).to include('other-id')
+    end
+
+    it 'does not duplicate adjacent ids' do
+      tile.connect!('other-id')
+      tile.connect!('other-id')
+      expect(tile.adjacent_ids.size).to eq(1)
+    end
+  end
+
+  describe 'predicate methods' do
+    it 'reports full_coverage when coverage >= 0.95' do
+      t = described_class.new(tile_type: :skill, shape: :square, domain: :cognitive, coverage: 0.96)
+      expect(t).to be_full_coverage
+    end
+
+    it 'reports gapped when fit_score < 0.3' do
+      t = described_class.new(tile_type: :skill, shape: :square, domain: :cognitive, fit_score: 0.2)
+      expect(t).to be_gapped
+    end
+
+    it 'reports isolated when no adjacent tiles' do
+      expect(tile).to be_isolated
+    end
+
+    it 'reports well_connected with 3+ adjacent' do
+      3.times { |i| tile.connect!("id-#{i}") }
+      expect(tile).to be_well_connected
+    end
+
+    it 'reports seamless when fit >= 0.8' do
+      tile.adjust_fit!(0.85)
+      expect(tile).to be_seamless
+    end
+  end
+
+  describe '#effective_coverage' do
+    it 'equals coverage for non-overlapping tiles' do
+      t = described_class.new(tile_type: :skill, shape: :square, domain: :cognitive, coverage: 0.5)
+      expect(t.effective_coverage).to eq(0.5)
+    end
+  end
+
+  describe '#to_h' do
+    it 'returns a hash with all fields' do
+      h = tile.to_h
+      expect(h).to include(:id, :tile_type, :shape, :domain, :coverage, :fit_score,
+                           :effective_coverage, :adjacent_count, :created_at)
+    end
+  end
+end

data/spec/legion/extensions/agentic/integration/zeitgeist/helpers/cognitive_signal_spec.rb

@@ -0,0 +1,62 @@
+# frozen_string_literal: true
+
+RSpec.describe Legion::Extensions::Agentic::Integration::Zeitgeist::Helpers::CognitiveSignal do
+  subject(:signal) do
+    described_class.new(source_subsystem: :emotion, domain: :threat, intensity: 0.8, valence: -0.5)
+  end
+
+  describe '#initialize' do
+    it 'assigns a uuid id' do
+      expect(signal.id).to match(/\A[0-9a-f-]{36}\z/)
+    end
+
+    it 'stores source_subsystem as symbol' do
+      expect(signal.source_subsystem).to eq(:emotion)
+    end
+
+    it 'stores domain as symbol' do
+      expect(signal.domain).to eq(:threat)
+    end
+
+    it 'clamps intensity to 0..1' do
+      s = described_class.new(source_subsystem: :x, domain: :y, intensity: 5.0)
+      expect(s.intensity).to eq(1.0)
+    end
+
+    it 'clamps valence to -1..1' do
+      s = described_class.new(source_subsystem: :x, domain: :y, valence: -9.0)
+      expect(s.valence).to eq(-1.0)
+    end
+
+    it 'uses default intensity when not provided' do
+      s = described_class.new(source_subsystem: :x, domain: :y)
+      expect(s.intensity).to eq(Legion::Extensions::Agentic::Integration::Zeitgeist::Helpers::Constants::DEFAULT_INTENSITY)
+    end
+
+    it 'defaults timestamp to now' do
+      expect(signal.timestamp).to be_a(Time)
+    end
+
+    it 'accepts explicit timestamp' do
+      t = Time.now.utc - 3600
+      s = described_class.new(source_subsystem: :x, domain: :y, timestamp: t)
+      expect(s.timestamp).to eq(t)
+    end
+  end
+
+  describe '#to_h' do
+    it 'returns a hash with all fields' do
+      h = signal.to_h
+      expect(h.keys).to contain_exactly(:id, :source_subsystem, :domain, :intensity, :valence, :timestamp)
+    end
+
+    it 'rounds intensity to 10 decimal places' do
+      h = signal.to_h
+      expect(h[:intensity]).to be_a(Float)
+    end
+
+    it 'includes timestamp as iso8601 string' do
+      expect(signal.to_h[:timestamp]).to match(/\d{4}-\d{2}-\d{2}/)
+    end
+  end
+end

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

@@ -0,0 +1,73 @@
+# frozen_string_literal: true
+
+RSpec.describe Legion::Extensions::Agentic::Integration::Zeitgeist::Helpers::Constants do
+  describe '.label_for' do
+    it 'returns correct mood label for high value' do
+      label = described_class.label_for(described_class::MOOD_LABELS, 0.9)
+      expect(label).to eq(:euphoric)
+    end
+
+    it 'returns correct mood label for mid value' do
+      label = described_class.label_for(described_class::MOOD_LABELS, 0.5)
+      expect(label).to eq(:neutral)
+    end
+
+    it 'returns correct mood label for low value' do
+      label = described_class.label_for(described_class::MOOD_LABELS, 0.1)
+      expect(label).to eq(:suppressed)
+    end
+
+    it 'returns correct convergence label for unified' do
+      label = described_class.label_for(described_class::CONVERGENCE_LABELS, 0.95)
+      expect(label).to eq(:unified)
+    end
+
+    it 'returns correct convergence label for divergent' do
+      label = described_class.label_for(described_class::CONVERGENCE_LABELS, 0.1)
+      expect(label).to eq(:divergent)
+    end
+
+    it 'returns correct momentum label for surging' do
+      label = described_class.label_for(described_class::MOMENTUM_LABELS, 0.8)
+      expect(label).to eq(:surging)
+    end
+
+    it 'returns correct momentum label for collapsing' do
+      label = described_class.label_for(described_class::MOMENTUM_LABELS, -0.5)
+      expect(label).to eq(:collapsing)
+    end
+
+    it 'returns nil for unmatched value when no range covers it' do
+      custom = { (0.5..1.0) => :high }.freeze
+      expect(described_class.label_for(custom, 0.2)).to be_nil
+    end
+  end
+
+  describe 'SIGNAL_DOMAINS' do
+    it 'contains 8 domains' do
+      expect(described_class::SIGNAL_DOMAINS.size).to eq(8)
+    end
+
+    it 'includes expected domains' do
+      expect(described_class::SIGNAL_DOMAINS).to include(:threat, :curiosity, :creativity, :social)
+    end
+  end
+
+  describe 'constants' do
+    it 'MAX_SIGNALS is 1000' do
+      expect(described_class::MAX_SIGNALS).to eq(1000)
+    end
+
+    it 'WINDOW_SIZE is 100' do
+      expect(described_class::WINDOW_SIZE).to eq(100)
+    end
+
+    it 'CONVERGENCE_THRESHOLD is 0.7' do
+      expect(described_class::CONVERGENCE_THRESHOLD).to eq(0.7)
+    end
+
+    it 'DIVERGENCE_THRESHOLD is 0.3' do
+      expect(described_class::DIVERGENCE_THRESHOLD).to eq(0.3)
+    end
+  end
+end

data/spec/legion/extensions/agentic/integration/zeitgeist/helpers/trend_window_spec.rb

@@ -0,0 +1,100 @@
+# frozen_string_literal: true
+
+RSpec.describe Legion::Extensions::Agentic::Integration::Zeitgeist::Helpers::TrendWindow do
+  subject(:window) { described_class.new }
+
+  let(:signal_class) { Legion::Extensions::Agentic::Integration::Zeitgeist::Helpers::CognitiveSignal }
+
+  def make_signal(domain: :curiosity, intensity: 0.5, valence: 0.0)
+    signal_class.new(source_subsystem: :emotion, domain: domain, intensity: intensity, valence: valence)
+  end
+
+  describe '#add' do
+    it 'adds a signal and returns self' do
+      result = window.add(make_signal)
+      expect(result).to be(window)
+      expect(window.signals.size).to eq(1)
+    end
+
+    it 'evicts oldest signal when at capacity' do
+      small_window = described_class.new(window_size: 3)
+      4.times { small_window.add(make_signal) }
+      expect(small_window.signals.size).to eq(3)
+    end
+  end
+
+  describe '#dominant_domain' do
+    it 'returns nil for empty window' do
+      expect(window.dominant_domain).to be_nil
+    end
+
+    it 'returns the domain with highest weighted intensity' do
+      window.add(make_signal(domain: :threat, intensity: 0.9))
+      window.add(make_signal(domain: :threat, intensity: 0.8))
+      window.add(make_signal(domain: :curiosity, intensity: 0.3))
+      expect(window.dominant_domain).to eq(:threat)
+    end
+  end
+
+  describe '#dominant_valence' do
+    it 'returns 0.0 for empty window' do
+      expect(window.dominant_valence).to eq(0.0)
+    end
+
+    it 'computes intensity-weighted valence' do
+      window.add(make_signal(domain: :threat, intensity: 1.0, valence: -1.0))
+      window.add(make_signal(domain: :opportunity, intensity: 1.0, valence: 1.0))
+      expect(window.dominant_valence).to be_within(0.001).of(0.0)
+    end
+
+    it 'is positive when positive signals dominate' do
+      window.add(make_signal(intensity: 0.8, valence: 0.9))
+      window.add(make_signal(intensity: 0.1, valence: -0.5))
+      expect(window.dominant_valence).to be > 0.0
+    end
+  end
+
+  describe '#momentum' do
+    it 'returns 0.0 with fewer than 2 signals' do
+      window.add(make_signal)
+      expect(window.momentum).to eq(0.0)
+    end
+
+    it 'returns positive momentum when second half more intense' do
+      4.times { window.add(make_signal(intensity: 0.2)) }
+      4.times { window.add(make_signal(intensity: 0.9)) }
+      expect(window.momentum).to be > 0.0
+    end
+
+    it 'returns negative momentum when second half less intense' do
+      4.times { window.add(make_signal(intensity: 0.9)) }
+      4.times { window.add(make_signal(intensity: 0.2)) }
+      expect(window.momentum).to be < 0.0
+    end
+  end
+
+  describe '#accelerating? and #decelerating?' do
+    it 'is accelerating when momentum exceeds threshold' do
+      4.times { window.add(make_signal(intensity: 0.1)) }
+      4.times { window.add(make_signal(intensity: 1.0)) }
+      expect(window.accelerating?).to be true
+      expect(window.decelerating?).to be false
+    end
+
+    it 'is decelerating when momentum is strongly negative' do
+      4.times { window.add(make_signal(intensity: 1.0)) }
+      4.times { window.add(make_signal(intensity: 0.0)) }
+      expect(window.decelerating?).to be true
+      expect(window.accelerating?).to be false
+    end
+  end
+
+  describe '#to_h' do
+    it 'returns a complete hash' do
+      window.add(make_signal)
+      h = window.to_h
+      expect(h.keys).to include(:size, :window_size, :dominant_domain, :dominant_valence, :momentum,
+                                :accelerating, :decelerating)
+    end
+  end
+end