lex-agentic-integration 0.1.0

data/spec/legion/extensions/agentic/integration/mosaic/helpers/tessera_spec.rb

@@ -0,0 +1,92 @@
+# frozen_string_literal: true
+
+RSpec.describe Legion::Extensions::Agentic::Integration::Mosaic::Helpers::Tessera do
+  subject(:tessera) do
+    described_class.new(material: :glass, domain: :reasoning, content: 'fragment')
+  end
+
+  describe '#initialize' do
+    it 'sets material' do
+      expect(tessera.material).to eq(:glass)
+    end
+
+    it 'sets domain' do
+      expect(tessera.domain).to eq(:reasoning)
+    end
+
+    it 'generates uuid' do
+      expect(tessera.id).to match(/\A[0-9a-f-]{36}\z/)
+    end
+
+    it 'assigns a color' do
+      expect(tessera.color).to be_a(Symbol)
+    end
+
+    it 'defaults fit_quality to 0.5' do
+      expect(tessera.fit_quality).to eq(0.5)
+    end
+
+    it 'starts unplaced' do
+      expect(tessera.loose?).to be true
+    end
+
+    it 'rejects unknown materials' do
+      expect { described_class.new(material: :plasma, domain: :x, content: 'y') }
+        .to raise_error(ArgumentError, /unknown material/)
+    end
+
+    it 'accepts custom fit_quality' do
+      t = described_class.new(material: :stone, domain: :x, content: 'y', fit_quality: 0.95)
+      expect(t.fit_quality).to eq(0.95)
+    end
+  end
+
+  describe '#place!' do
+    it 'marks tessera as placed' do
+      tessera.place!('mosaic-1')
+      expect(tessera.placed?).to be true
+    end
+
+    it 'records mosaic id' do
+      tessera.place!('mosaic-1')
+      expect(tessera.mosaic_id).to eq('mosaic-1')
+    end
+
+    it 'records placement time' do
+      tessera.place!('mosaic-1')
+      expect(tessera.placed_at).to be_a(Time)
+    end
+  end
+
+  describe '#perfect_fit?' do
+    it 'returns false at default quality' do
+      expect(tessera.perfect_fit?).to be false
+    end
+
+    it 'returns true at high quality' do
+      t = described_class.new(material: :crystal, domain: :x, content: 'y', fit_quality: 0.95)
+      expect(t.perfect_fit?).to be true
+    end
+  end
+
+  describe '#poor_fit?' do
+    it 'returns false at default quality' do
+      expect(tessera.poor_fit?).to be false
+    end
+
+    it 'returns true at low quality' do
+      t = described_class.new(material: :clay, domain: :x, content: 'y', fit_quality: 0.1)
+      expect(t.poor_fit?).to be true
+    end
+  end
+
+  describe '#to_h' do
+    it 'returns all keys' do
+      h = tessera.to_h
+      %i[id material domain content color fit_quality
+         placed loose perfect_fit poor_fit mosaic_id placed_at].each do |k|
+        expect(h).to have_key(k)
+      end
+    end
+  end
+end

data/spec/legion/extensions/agentic/integration/mosaic/runners/cognitive_mosaic_spec.rb

@@ -0,0 +1,88 @@
+# frozen_string_literal: true
+
+RSpec.describe Legion::Extensions::Agentic::Integration::Mosaic::Runners::CognitiveMosaic do
+  let(:engine) { Legion::Extensions::Agentic::Integration::Mosaic::Helpers::MosaicEngine.new }
+
+  describe '.create_tessera' do
+    it 'returns success' do
+      result = described_class.create_tessera(
+        material: :glass, domain: :reasoning, content: 'test', engine: engine
+      )
+      expect(result[:success]).to be true
+      expect(result[:tessera][:material]).to eq(:glass)
+    end
+
+    it 'returns failure for invalid material' do
+      result = described_class.create_tessera(
+        material: :plasma, domain: :x, content: 'y', engine: engine
+      )
+      expect(result[:success]).to be false
+    end
+  end
+
+  describe '.create_mosaic' do
+    it 'returns success' do
+      result = described_class.create_mosaic(
+        name: 'test', pattern_category: :geometric, engine: engine
+      )
+      expect(result[:success]).to be true
+      expect(result[:mosaic][:name]).to eq('test')
+    end
+
+    it 'returns failure for invalid pattern' do
+      result = described_class.create_mosaic(
+        name: 'x', pattern_category: :random, engine: engine
+      )
+      expect(result[:success]).to be false
+    end
+  end
+
+  describe '.place_tessera' do
+    it 'places tessera successfully' do
+      t = engine.create_tessera(material: :stone, domain: :x, content: 'a')
+      m = engine.create_mosaic(name: 'wall', pattern_category: :organic)
+      result = described_class.place_tessera(
+        tessera_id: t.id, mosaic_id: m.id, engine: engine
+      )
+      expect(result[:success]).to be true
+    end
+
+    it 'returns failure for missing tessera' do
+      result = described_class.place_tessera(
+        tessera_id: 'nope', mosaic_id: 'nope', engine: engine
+      )
+      expect(result[:success]).to be false
+    end
+  end
+
+  describe '.list_tesserae' do
+    it 'returns all tesserae' do
+      engine.create_tessera(material: :glass, domain: :x, content: 'a')
+      result = described_class.list_tesserae(engine: engine)
+      expect(result[:count]).to eq(1)
+    end
+
+    it 'filters by material' do
+      engine.create_tessera(material: :glass, domain: :x, content: 'a')
+      engine.create_tessera(material: :stone, domain: :x, content: 'b')
+      result = described_class.list_tesserae(engine: engine, material: :glass)
+      expect(result[:count]).to eq(1)
+    end
+  end
+
+  describe '.list_mosaics' do
+    it 'returns all mosaics' do
+      engine.create_mosaic(name: 'a', pattern_category: :geometric)
+      result = described_class.list_mosaics(engine: engine)
+      expect(result[:count]).to eq(1)
+    end
+  end
+
+  describe '.mosaic_status' do
+    it 'returns report' do
+      result = described_class.mosaic_status(engine: engine)
+      expect(result[:success]).to be true
+      expect(result[:report]).to have_key(:total_tesserae)
+    end
+  end
+end

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

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+RSpec.describe Legion::Extensions::Agentic::Integration::Mycelium::Client do
+  let(:client) { described_class.new }
+
+  it 'responds to runner methods' do
+    expect(client).to respond_to(:create_node, :connect, :fruit,
+                                 :network_status)
+  end
+
+  describe '#create_node' do
+    it 'delegates' do
+      result = client.create_node(node_type: :knowledge_cluster,
+                                  domain: :semantic, content: 'x')
+      expect(result[:success]).to be true
+    end
+  end
+
+  describe '#network_status' do
+    it 'returns report' do
+      result = client.network_status
+      expect(result[:report]).to be_a Hash
+    end
+  end
+end

data/spec/legion/extensions/agentic/integration/mycelium/cognitive_mycelium_spec.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+RSpec.describe Legion::Extensions::Agentic::Integration::Mycelium do
+  it 'has a version number' do
+    expect(described_class::VERSION).to eq '0.1.0'
+  end
+end

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

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+RSpec.describe Legion::Extensions::Agentic::Integration::Mycelium::Helpers::Constants do
+  let(:c) { described_class }
+
+  it 'defines MAX_NODES' do
+    expect(c::MAX_NODES).to eq 200
+  end
+
+  it 'has 6 node types' do
+    expect(c::NODE_TYPES.size).to eq 6
+  end
+
+  it 'has 6 nutrient types' do
+    expect(c::NUTRIENT_TYPES.size).to eq 6
+  end
+
+  it 'has 6 fruiting types' do
+    expect(c::FRUITING_TYPES.size).to eq 6
+  end
+
+  describe '.label_for' do
+    it 'returns health labels' do
+      expect(c.label_for(c::NETWORK_HEALTH_LABELS, 0.9)).to eq :thriving
+      expect(c.label_for(c::NETWORK_HEALTH_LABELS, 0.1)).to eq :depleted
+    end
+  end
+end

data/spec/legion/extensions/agentic/integration/mycelium/helpers/fruiting_body_spec.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+RSpec.describe Legion::Extensions::Agentic::Integration::Mycelium::Helpers::FruitingBody do
+  let(:body) do
+    described_class.new(fruiting_type: :insight, source_node_id: 'node-1',
+                        content: 'breakthrough discovery')
+  end
+
+  describe '#initialize' do
+    it 'assigns UUID' do
+      expect(body.id).to match(/\A[0-9a-f-]{36}\z/)
+    end
+
+    it 'sets fruiting_type' do
+      expect(body.fruiting_type).to eq :insight
+    end
+
+    it 'raises on invalid type' do
+      expect do
+        described_class.new(fruiting_type: :bogus, source_node_id: 'x',
+                            content: 'x')
+      end.to raise_error(ArgumentError, /unknown fruiting type/)
+    end
+  end
+
+  describe '#to_h' do
+    it 'includes expected keys' do
+      %i[id fruiting_type source_node_id content potency emerged_at].each do |key|
+        expect(body.to_h).to have_key(key)
+      end
+    end
+  end
+end

data/spec/legion/extensions/agentic/integration/mycelium/helpers/hypha_spec.rb

@@ -0,0 +1,69 @@
+# frozen_string_literal: true
+
+RSpec.describe Legion::Extensions::Agentic::Integration::Mycelium::Helpers::Hypha do
+  let(:hypha) do
+    described_class.new(source_id: 'src', target_id: 'tgt',
+                        nutrient_type: :information)
+  end
+
+  describe '#initialize' do
+    it 'assigns UUID' do
+      expect(hypha.id).to match(/\A[0-9a-f-]{36}\z/)
+    end
+
+    it 'starts in growing state' do
+      expect(hypha.state).to eq :growing
+    end
+
+    it 'raises on invalid nutrient_type' do
+      expect do
+        described_class.new(source_id: 'a', target_id: 'b',
+                            nutrient_type: :bogus)
+      end.to raise_error(ArgumentError, /unknown nutrient type/)
+    end
+  end
+
+  describe '#reinforce!' do
+    it 'increases strength' do
+      hypha.reinforce!(amount: 0.2)
+      expect(hypha.strength).to eq 0.7
+    end
+
+    it 'transitions to mature at 0.6' do
+      hypha.reinforce!(amount: 0.2)
+      expect(hypha.state).to eq :mature
+    end
+  end
+
+  describe '#decay!' do
+    it 'decreases strength' do
+      original = hypha.strength
+      hypha.decay!
+      expect(hypha.strength).to be < original
+    end
+
+    it 'transitions to decaying when below 0.2' do
+      hypha.instance_variable_set(:@strength, 0.2)
+      hypha.decay!(rate: 0.05)
+      expect(hypha.state).to eq :decaying
+    end
+  end
+
+  describe '#transfer_capacity' do
+    it 'returns strength * efficiency' do
+      expected = (0.5 * 0.8).round(10)
+      expect(hypha.transfer_capacity).to eq expected
+    end
+  end
+
+  describe '#active?' do
+    it 'true when growing' do
+      expect(hypha.active?).to be true
+    end
+
+    it 'false when decaying' do
+      hypha.instance_variable_set(:@state, :decaying)
+      expect(hypha.active?).to be false
+    end
+  end
+end

data/spec/legion/extensions/agentic/integration/mycelium/helpers/mycelial_node_spec.rb

@@ -0,0 +1,79 @@
+# frozen_string_literal: true
+
+RSpec.describe Legion::Extensions::Agentic::Integration::Mycelium::Helpers::MycelialNode do
+  let(:node) do
+    described_class.new(node_type: :knowledge_cluster, domain: :semantic,
+                        content: 'test node')
+  end
+
+  describe '#initialize' do
+    it 'assigns UUID' do
+      expect(node.id).to match(/\A[0-9a-f-]{36}\z/)
+    end
+
+    it 'sets node_type' do
+      expect(node.node_type).to eq :knowledge_cluster
+    end
+
+    it 'defaults nutrient_level to 0.5' do
+      expect(node.nutrient_level).to eq 0.5
+    end
+
+    it 'raises on invalid type' do
+      expect do
+        described_class.new(node_type: :bogus, domain: :x, content: 'x')
+      end.to raise_error(ArgumentError, /unknown node type/)
+    end
+  end
+
+  describe '#absorb!' do
+    it 'increases nutrient_level' do
+      node.absorb!(0.2)
+      expect(node.nutrient_level).to eq 0.7
+    end
+
+    it 'clamps at 1.0' do
+      node.absorb!(5.0)
+      expect(node.nutrient_level).to eq 1.0
+    end
+  end
+
+  describe '#deplete!' do
+    it 'decreases nutrient_level' do
+      node.deplete!(0.2)
+      expect(node.nutrient_level).to eq 0.3
+    end
+
+    it 'clamps at 0.0' do
+      node.deplete!(5.0)
+      expect(node.nutrient_level).to eq 0.0
+    end
+  end
+
+  describe '#fruiting_ready?' do
+    it 'true when nutrient >= threshold' do
+      node.absorb!(0.3)
+      expect(node.fruiting_ready?).to be true
+    end
+
+    it 'false when below threshold' do
+      expect(node.fruiting_ready?).to be false
+    end
+  end
+
+  describe '#starving?' do
+    it 'true when nutrient < 0.1' do
+      node.deplete!(0.45)
+      expect(node.starving?).to be true
+    end
+  end
+
+  describe '#to_h' do
+    it 'includes expected keys' do
+      %i[id node_type domain content nutrient_level connections_count
+         fruiting_ready starving created_at].each do |key|
+        expect(node.to_h).to have_key(key)
+      end
+    end
+  end
+end

data/spec/legion/extensions/agentic/integration/mycelium/helpers/mycelium_engine_spec.rb

@@ -0,0 +1,136 @@
+# frozen_string_literal: true
+
+RSpec.describe Legion::Extensions::Agentic::Integration::Mycelium::Helpers::MyceliumEngine do
+  let(:engine) { described_class.new }
+
+  describe '#create_node' do
+    it 'creates a node' do
+      node = engine.create_node(node_type: :knowledge_cluster,
+                                domain: :semantic, content: 'test')
+      expect(node.node_type).to eq :knowledge_cluster
+    end
+
+    it 'tracks in all_nodes' do
+      engine.create_node(node_type: :insight_node, domain: :creative,
+                         content: 'x')
+      expect(engine.all_nodes.size).to eq 1
+    end
+  end
+
+  describe '#connect' do
+    let(:n1) do
+      engine.create_node(node_type: :knowledge_cluster, domain: :semantic,
+                         content: 'a')
+    end
+    let(:n2) do
+      engine.create_node(node_type: :skill_node, domain: :procedural,
+                         content: 'b')
+    end
+
+    it 'creates a hypha' do
+      h = engine.connect(source_id: n1.id, target_id: n2.id,
+                         nutrient_type: :information)
+      expect(h.source_id).to eq n1.id
+    end
+
+    it 'increments connection counts' do
+      engine.connect(source_id: n1.id, target_id: n2.id,
+                     nutrient_type: :information)
+      expect(n1.connections_count).to eq 1
+      expect(n2.connections_count).to eq 1
+    end
+
+    it 'raises for unknown node' do
+      expect do
+        engine.connect(source_id: 'bad', target_id: n2.id,
+                       nutrient_type: :information)
+      end.to raise_error(ArgumentError, /node not found/)
+    end
+  end
+
+  describe '#transfer_nutrients' do
+    it 'moves nutrients from source to target' do
+      n1 = engine.create_node(node_type: :knowledge_cluster,
+                              domain: :semantic, content: 'src',
+                              nutrient_level: 0.8)
+      n2 = engine.create_node(node_type: :skill_node, domain: :procedural,
+                              content: 'tgt', nutrient_level: 0.2)
+      h = engine.connect(source_id: n1.id, target_id: n2.id,
+                         nutrient_type: :information)
+      result = engine.transfer_nutrients(hypha_id: h.id)
+      expect(result[:transferred]).to be > 0
+      expect(n1.nutrient_level).to be < 0.8
+      expect(n2.nutrient_level).to be > 0.2
+    end
+  end
+
+  describe '#fruit!' do
+    it 'creates fruiting body when node is ready' do
+      n = engine.create_node(node_type: :creative_node, domain: :creative,
+                             content: 'ripe', nutrient_level: 0.9)
+      body = engine.fruit!(node_id: n.id, fruiting_type: :insight,
+                           content: 'eureka')
+      expect(body.fruiting_type).to eq :insight
+    end
+
+    it 'raises when node is not ready' do
+      n = engine.create_node(node_type: :creative_node, domain: :creative,
+                             content: 'unripe', nutrient_level: 0.3)
+      expect do
+        engine.fruit!(node_id: n.id, fruiting_type: :insight,
+                      content: 'too early')
+      end.to raise_error(ArgumentError, /not ready/)
+    end
+
+    it 'depletes the source node' do
+      n = engine.create_node(node_type: :creative_node, domain: :creative,
+                             content: 'ripe', nutrient_level: 0.9)
+      engine.fruit!(node_id: n.id, fruiting_type: :breakthrough,
+                    content: 'big')
+      expect(n.nutrient_level).to be < 0.9
+    end
+  end
+
+  describe '#decay_network!' do
+    it 'reduces strengths' do
+      n1 = engine.create_node(node_type: :knowledge_cluster,
+                              domain: :semantic, content: 'a')
+      n2 = engine.create_node(node_type: :skill_node, domain: :procedural,
+                              content: 'b')
+      h = engine.connect(source_id: n1.id, target_id: n2.id,
+                         nutrient_type: :information)
+      original = h.strength
+      engine.decay_network!
+      expect(h.strength).to be < original
+    end
+  end
+
+  describe '#connections_for' do
+    it 'returns hyphae connected to a node' do
+      n1 = engine.create_node(node_type: :knowledge_cluster,
+                              domain: :semantic, content: 'a')
+      n2 = engine.create_node(node_type: :skill_node, domain: :procedural,
+                              content: 'b')
+      engine.connect(source_id: n1.id, target_id: n2.id,
+                     nutrient_type: :experience)
+      expect(engine.connections_for(n1.id).size).to eq 1
+    end
+  end
+
+  describe '#network_report' do
+    it 'returns comprehensive report' do
+      engine.create_node(node_type: :knowledge_cluster, domain: :semantic,
+                         content: 'x')
+      report = engine.network_report
+      %i[total_nodes total_hyphae total_fruiting active_hyphae
+         avg_nutrient avg_strength fruiting_ready starving_nodes
+         network_health].each do |key|
+        expect(report).to have_key(key)
+      end
+    end
+
+    it 'works empty' do
+      expect(engine.network_report[:total_nodes]).to eq 0
+    end
+  end
+end

data/spec/legion/extensions/agentic/integration/mycelium/runners/cognitive_mycelium_spec.rb

@@ -0,0 +1,61 @@
+# frozen_string_literal: true
+
+RSpec.describe Legion::Extensions::Agentic::Integration::Mycelium::Runners::CognitiveMycelium do
+  let(:engine) { Legion::Extensions::Agentic::Integration::Mycelium::Helpers::MyceliumEngine.new }
+  let(:runner) { described_class }
+
+  describe '.create_node' do
+    it 'succeeds' do
+      result = runner.create_node(node_type: :knowledge_cluster,
+                                  domain: :semantic, content: 'test',
+                                  engine: engine)
+      expect(result[:success]).to be true
+      expect(result[:node][:node_type]).to eq :knowledge_cluster
+    end
+
+    it 'returns failure for invalid type' do
+      result = runner.create_node(node_type: :bogus, domain: :x,
+                                  content: 'x', engine: engine)
+      expect(result[:success]).to be false
+    end
+  end
+
+  describe '.connect' do
+    it 'creates connection' do
+      n1 = engine.create_node(node_type: :knowledge_cluster,
+                              domain: :semantic, content: 'a')
+      n2 = engine.create_node(node_type: :skill_node, domain: :procedural,
+                              content: 'b')
+      result = runner.connect(source_id: n1.id, target_id: n2.id,
+                              nutrient_type: :information, engine: engine)
+      expect(result[:success]).to be true
+    end
+  end
+
+  describe '.fruit' do
+    it 'creates fruiting body' do
+      n = engine.create_node(node_type: :creative_node, domain: :creative,
+                             content: 'ripe', nutrient_level: 0.9)
+      result = runner.fruit(node_id: n.id, fruiting_type: :insight,
+                            content: 'eureka', engine: engine)
+      expect(result[:success]).to be true
+      expect(result[:fruiting_body][:fruiting_type]).to eq :insight
+    end
+
+    it 'returns failure when not ready' do
+      n = engine.create_node(node_type: :creative_node, domain: :creative,
+                             content: 'x', nutrient_level: 0.2)
+      result = runner.fruit(node_id: n.id, fruiting_type: :insight,
+                            content: 'x', engine: engine)
+      expect(result[:success]).to be false
+    end
+  end
+
+  describe '.network_status' do
+    it 'returns report' do
+      result = runner.network_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/phenomenal_binding/client_spec.rb

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+require 'legion/extensions/agentic/integration/phenomenal_binding/client'
+
+RSpec.describe Legion::Extensions::Agentic::Integration::PhenomenalBinding::Client do
+  let(:client) { described_class.new }
+
+  it 'responds to runner methods' do
+    expect(client).to respond_to(:register_stream)
+    expect(client).to respond_to(:create_binding)
+    expect(client).to respond_to(:reinforce_binding)
+    expect(client).to respond_to(:dissolve_binding)
+    expect(client).to respond_to(:unified_experience)
+    expect(client).to respond_to(:fragmentation_index)
+    expect(client).to respond_to(:binding_by_type)
+    expect(client).to respond_to(:streams_for_binding)
+    expect(client).to respond_to(:unbound_streams)
+    expect(client).to respond_to(:decay_all)
+    expect(client).to respond_to(:prune_incoherent)
+    expect(client).to respond_to(:consciousness_report)
+    expect(client).to respond_to(:engine_stats)
+  end
+
+  it 'maintains independent engine state per instance' do
+    c1 = described_class.new
+    c2 = described_class.new
+    c1.register_stream(stream_type: :perception, content: 'only in c1')
+    expect(c1.engine_stats[:stream_count]).to eq(1)
+    expect(c2.engine_stats[:stream_count]).to eq(0)
+  end
+
+  it 'runs a full bind/reinforce/dissolve cycle' do
+    s = client.register_stream(stream_type: :thought, content: 'philosophy', salience: 0.75)
+    b = client.create_binding(stream_ids: [s[:stream][:id]], binding_type: :conceptual)
+    client.reinforce_binding(binding_id: b[:binding][:id])
+    expect(client.unified_experience[:unified_experience]).to be_a(Hash)
+    client.dissolve_binding(binding_id: b[:binding][:id])
+    expect(client.unified_experience[:unified_experience]).to be_nil
+  end
+
+  it 'builds a consciousness report across multiple streams and bindings' do
+    s1 = client.register_stream(stream_type: :perception, content: 'light', salience: 0.8)
+    s2 = client.register_stream(stream_type: :emotion, content: 'warmth', salience: 0.7)
+    s3 = client.register_stream(stream_type: :memory, content: 'familiar', salience: 0.9)
+    client.create_binding(stream_ids: [s1[:stream][:id], s2[:stream][:id]], binding_type: :emotional)
+    report = client.consciousness_report
+    expect(report[:stream_count]).to eq(3)
+    expect(report[:binding_count]).to eq(1)
+    expect(report[:unbound_count]).to eq(1) # s3 is unbound
+    _ = s3
+  end
+end