lex-agentic-integration 0.1.0

data/lib/legion/extensions/agentic/integration/mycelium/helpers/mycelial_node.rb

@@ -0,0 +1,72 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module Agentic
+      module Integration
+        module Mycelium
+          module Helpers
+            class MycelialNode
+              attr_reader :id, :node_type, :domain, :content, :created_at
+              attr_accessor :nutrient_level, :connections_count
+
+              def initialize(node_type:, domain:, content:,
+                             nutrient_level: 0.5)
+                validate_type!(node_type)
+                @id                = SecureRandom.uuid
+                @node_type         = node_type.to_sym
+                @domain            = domain.to_sym
+                @content           = content.to_s
+                @nutrient_level    = nutrient_level.to_f.clamp(0.0, 1.0).round(10)
+                @connections_count = 0
+                @created_at        = Time.now.utc
+              end
+
+              def absorb!(amount)
+                @nutrient_level = (@nutrient_level + amount.abs).clamp(0.0, 1.0).round(10)
+                self
+              end
+
+              def deplete!(amount)
+                @nutrient_level = (@nutrient_level - amount.abs).clamp(0.0, 1.0).round(10)
+                self
+              end
+
+              def fruiting_ready?
+                @nutrient_level >= Constants::FRUITING_THRESHOLD
+              end
+
+              def starving?
+                @nutrient_level < 0.1
+              end
+
+              def to_h
+                {
+                  id:                @id,
+                  node_type:         @node_type,
+                  domain:            @domain,
+                  content:           @content,
+                  nutrient_level:    @nutrient_level,
+                  connections_count: @connections_count,
+                  fruiting_ready:    fruiting_ready?,
+                  starving:          starving?,
+                  created_at:        @created_at
+                }
+              end
+
+              private
+
+              def validate_type!(val)
+                return if Constants::NODE_TYPES.include?(val.to_sym)
+
+                raise ArgumentError,
+                      "unknown node type: #{val.inspect}; " \
+                      "must be one of #{Constants::NODE_TYPES.inspect}"
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/legion/extensions/agentic/integration/mycelium/helpers/mycelium_engine.rb

@@ -0,0 +1,151 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module Agentic
+      module Integration
+        module Mycelium
+          module Helpers
+            class MyceliumEngine
+              def initialize
+                @nodes          = {}
+                @hyphae         = {}
+                @fruiting_bodies = {}
+              end
+
+              def create_node(node_type:, domain:, content:,
+                              nutrient_level: 0.5)
+                validate_capacity!(@nodes, Constants::MAX_NODES, 'nodes')
+                node = MycelialNode.new(
+                  node_type: node_type, domain: domain,
+                  content: content, nutrient_level: nutrient_level
+                )
+                @nodes[node.id] = node
+                node
+              end
+
+              def connect(source_id:, target_id:, nutrient_type:,
+                          strength: 0.5)
+                validate_capacity!(@hyphae, Constants::MAX_HYPHAE, 'hyphae')
+                fetch_node!(source_id)
+                fetch_node!(target_id)
+                hypha = Hypha.new(
+                  source_id: source_id, target_id: target_id,
+                  nutrient_type: nutrient_type, strength: strength
+                )
+                @hyphae[hypha.id] = hypha
+                increment_connections(source_id, target_id)
+                hypha
+              end
+
+              def transfer_nutrients(hypha_id:)
+                hypha  = fetch_hypha!(hypha_id)
+                source = fetch_node!(hypha.source_id)
+                target = fetch_node!(hypha.target_id)
+                amount = [hypha.transfer_capacity, source.nutrient_level].min
+                source.deplete!(amount)
+                target.absorb!(amount)
+                { transferred: amount, source: source.to_h, target: target.to_h }
+              end
+
+              def fruit!(node_id:, fruiting_type:, content:)
+                validate_capacity!(@fruiting_bodies,
+                                   Constants::MAX_FRUITING_BODIES, 'fruiting bodies')
+                node = fetch_node!(node_id)
+                raise ArgumentError, 'node not ready for fruiting' unless node.fruiting_ready?
+
+                body = FruitingBody.new(
+                  fruiting_type: fruiting_type, source_node_id: node_id,
+                  content: content, potency: node.nutrient_level
+                )
+                node.deplete!(0.3)
+                @fruiting_bodies[body.id] = body
+                body
+              end
+
+              def decay_network!(rate: Constants::NUTRIENT_DECAY)
+                @hyphae.each_value { |h| h.decay!(rate: rate) }
+                @nodes.each_value { |n| n.deplete!(rate * 0.5) }
+                prune_dead!
+                { nodes: @nodes.size, hyphae: @hyphae.size }
+              end
+
+              def all_nodes
+                @nodes.values
+              end
+
+              def all_hyphae
+                @hyphae.values
+              end
+
+              def all_fruiting_bodies
+                @fruiting_bodies.values
+              end
+
+              def connections_for(node_id)
+                @hyphae.values.select do |h|
+                  h.source_id == node_id || h.target_id == node_id
+                end
+              end
+
+              def network_report
+                {
+                  total_nodes:    @nodes.size,
+                  total_hyphae:   @hyphae.size,
+                  total_fruiting: @fruiting_bodies.size,
+                  active_hyphae:  @hyphae.values.count(&:active?),
+                  avg_nutrient:   avg_field(@nodes, :nutrient_level),
+                  avg_strength:   avg_field(@hyphae, :strength),
+                  fruiting_ready: @nodes.values.count(&:fruiting_ready?),
+                  starving_nodes: @nodes.values.count(&:starving?),
+                  network_health: network_health_label
+                }
+              end
+
+              private
+
+              def fetch_node!(id)
+                @nodes.fetch(id) do
+                  raise ArgumentError, "node not found: #{id.inspect}"
+                end
+              end
+
+              def fetch_hypha!(id)
+                @hyphae.fetch(id) do
+                  raise ArgumentError, "hypha not found: #{id.inspect}"
+                end
+              end
+
+              def validate_capacity!(coll, max, name)
+                return if coll.size < max
+
+                raise ArgumentError,
+                      "#{name} capacity reached (max #{max})"
+              end
+
+              def increment_connections(source_id, target_id)
+                @nodes[source_id].connections_count += 1
+                @nodes[target_id].connections_count += 1
+              end
+
+              def prune_dead!
+                @hyphae.delete_if { |_, h| h.strength <= 0.0 }
+              end
+
+              def avg_field(coll, field)
+                return 0.0 if coll.empty?
+
+                (coll.values.sum(&field) / coll.size).round(10)
+              end
+
+              def network_health_label
+                avg = avg_field(@nodes, :nutrient_level)
+                Constants.label_for(Constants::NETWORK_HEALTH_LABELS, avg)
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/legion/extensions/agentic/integration/mycelium/runners/cognitive_mycelium.rb

@@ -0,0 +1,73 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module Agentic
+      module Integration
+        module Mycelium
+          module Runners
+            module CognitiveMycelium
+              extend self
+
+              def create_node(node_type:, domain:, content:,
+                              nutrient_level: 0.5, engine: nil, **)
+                eng  = resolve_engine(engine)
+                node = eng.create_node(node_type: node_type, domain: domain,
+                                       content: content,
+                                       nutrient_level: nutrient_level)
+                { success: true, node: node.to_h }
+              rescue ArgumentError => e
+                { success: false, error: e.message }
+              end
+
+              def connect(source_id:, target_id:, nutrient_type:,
+                          strength: 0.5, engine: nil, **)
+                eng   = resolve_engine(engine)
+                hypha = eng.connect(source_id: source_id, target_id: target_id,
+                                    nutrient_type: nutrient_type,
+                                    strength: strength)
+                { success: true, hypha: hypha.to_h }
+              rescue ArgumentError => e
+                { success: false, error: e.message }
+              end
+
+              def transfer_nutrients(hypha_id:, engine: nil, **)
+                eng    = resolve_engine(engine)
+                result = eng.transfer_nutrients(hypha_id: hypha_id)
+                { success: true }.merge(result)
+              rescue ArgumentError => e
+                { success: false, error: e.message }
+              end
+
+              def fruit(node_id:, fruiting_type:, content:, engine: nil, **)
+                eng  = resolve_engine(engine)
+                body = eng.fruit!(node_id: node_id, fruiting_type: fruiting_type,
+                                  content: content)
+                { success: true, fruiting_body: body.to_h }
+              rescue ArgumentError => e
+                { success: false, error: e.message }
+              end
+
+              def network_status(engine: nil, **)
+                eng = resolve_engine(engine)
+                { success: true, report: eng.network_report }
+              end
+
+              include Legion::Extensions::Helpers::Lex if defined?(Legion::Extensions::Helpers::Lex)
+
+              private
+
+              def resolve_engine(engine)
+                engine || default_engine
+              end
+
+              def default_engine
+                @default_engine ||= Helpers::MyceliumEngine.new
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/legion/extensions/agentic/integration/mycelium/version.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module Agentic
+      module Integration
+        module Mycelium
+          VERSION = '0.1.0'
+        end
+      end
+    end
+  end
+end

data/lib/legion/extensions/agentic/integration/mycelium.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+require 'securerandom'
+
+require_relative 'mycelium/version'
+require_relative 'mycelium/helpers/constants'
+require_relative 'mycelium/helpers/mycelial_node'
+require_relative 'mycelium/helpers/hypha'
+require_relative 'mycelium/helpers/fruiting_body'
+require_relative 'mycelium/helpers/mycelium_engine'
+require_relative 'mycelium/runners/cognitive_mycelium'
+require_relative 'mycelium/client'
+
+module Legion
+  module Extensions
+    module Agentic
+      module Integration
+        module Mycelium
+        end
+      end
+    end
+  end
+end

data/lib/legion/extensions/agentic/integration/phenomenal_binding/client.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+require 'legion/extensions/agentic/integration/phenomenal_binding/runners/phenomenal_binding'
+
+module Legion
+  module Extensions
+    module Agentic
+      module Integration
+        module PhenomenalBinding
+          class Client
+            include Runners::PhenomenalBinding
+
+            def initialize(**)
+              @engine = Helpers::BindingEngine.new
+            end
+
+            private
+
+            attr_reader :engine
+          end
+        end
+      end
+    end
+  end
+end

data/lib/legion/extensions/agentic/integration/phenomenal_binding/helpers/binding_engine.rb

@@ -0,0 +1,156 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module Agentic
+      module Integration
+        module PhenomenalBinding
+          module Helpers
+            class BindingEngine
+              include Constants
+
+              def initialize
+                @streams  = {}
+                @bindings = {}
+              end
+
+              def register_stream(stream_type:, content:, salience: DEFAULT_SALIENCE, domain: nil)
+                prune_streams_if_full
+                stream = Stream.new(
+                  stream_type: stream_type,
+                  content:     content,
+                  salience:    salience,
+                  domain:      domain
+                )
+                @streams[stream.id] = stream
+                stream
+              end
+
+              def create_binding(stream_ids:, binding_type:, attention_weight: 0.5)
+                prune_bindings_if_full
+                valid_ids   = stream_ids.select { |id| @streams.key?(id) }
+                coherence   = compute_initial_coherence(valid_ids)
+                binding     = BindingUnit.new(
+                  stream_ids:       valid_ids,
+                  binding_type:     binding_type,
+                  coherence:        coherence,
+                  attention_weight: attention_weight
+                )
+                @bindings[binding.id] = binding
+                binding
+              end
+
+              def reinforce_binding(binding_id:)
+                binding = @bindings[binding_id]
+                return { status: :not_found, binding_id: binding_id } unless binding
+
+                binding.reinforce!
+                { status: :reinforced, binding_id: binding_id, coherence: binding.coherence }
+              end
+
+              def dissolve_binding(binding_id:)
+                return { status: :not_found, binding_id: binding_id } unless @bindings.key?(binding_id)
+
+                @bindings.delete(binding_id)
+                { status: :dissolved, binding_id: binding_id }
+              end
+
+              def unified_experience
+                coherent = @bindings.values.select(&:coherent?)
+                return nil if coherent.empty?
+
+                coherent.max_by { |b| b.coherence * b.attention_weight }
+              end
+
+              def fragmentation_index
+                total = @streams.size
+                return 0.0 if total.zero?
+
+                (unbound_streams.size.to_f / total).round(10)
+              end
+
+              def binding_by_type(binding_type:)
+                @bindings.values.select { |b| b.binding_type == binding_type }
+              end
+
+              def streams_for_binding(binding_id:)
+                binding = @bindings[binding_id]
+                return [] unless binding
+
+                binding.stream_ids.filter_map { |id| @streams[id] }
+              end
+
+              def unbound_streams
+                bound_ids = @bindings.values.flat_map(&:stream_ids).to_set
+                @streams.values.reject { |s| bound_ids.include?(s.id) }
+              end
+
+              def decay_all
+                @bindings.each_value(&:decay!)
+              end
+
+              def prune_incoherent
+                @bindings.delete_if { |_, b| !b.coherent? }
+              end
+
+              def consciousness_report
+                experience = unified_experience
+                distribution = coherence_distribution
+
+                {
+                  unified_experience:     experience&.to_h,
+                  fragmentation_index:    fragmentation_index,
+                  coherence_distribution: distribution,
+                  stream_count:           @streams.size,
+                  binding_count:          @bindings.size,
+                  unbound_count:          unbound_streams.size
+                }
+              end
+
+              def to_h
+                {
+                  stream_count:  @streams.size,
+                  binding_count: @bindings.size,
+                  unbound_count: unbound_streams.size,
+                  fragmentation: fragmentation_index
+                }
+              end
+
+              private
+
+              def compute_initial_coherence(stream_ids)
+                return 0.0 if stream_ids.empty?
+
+                saliences = stream_ids.filter_map { |id| @streams[id]&.salience }
+                return 0.0 if saliences.empty?
+
+                (saliences.sum / saliences.size).round(10)
+              end
+
+              def coherence_distribution
+                Constants::COHERENCE_LABELS.to_h do |_range, label|
+                  count = @bindings.values.count { |b| b.coherence_label == label }
+                  [label, count]
+                end
+              end
+
+              def prune_streams_if_full
+                return if @streams.size < MAX_STREAMS
+
+                oldest = @streams.values.min_by(&:created_at)
+                @streams.delete(oldest.id) if oldest
+              end
+
+              def prune_bindings_if_full
+                return if @bindings.size < MAX_BINDINGS
+
+                oldest = @bindings.values.min_by(&:created_at)
+                @bindings.delete(oldest.id) if oldest
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/legion/extensions/agentic/integration/phenomenal_binding/helpers/binding_unit.rb

@@ -0,0 +1,72 @@
+# frozen_string_literal: true
+
+require 'securerandom'
+
+module Legion
+  module Extensions
+    module Agentic
+      module Integration
+        module PhenomenalBinding
+          module Helpers
+            class BindingUnit
+              include Constants
+
+              attr_reader :id, :stream_ids, :binding_type, :coherence, :attention_weight, :created_at
+
+              def initialize(stream_ids:, binding_type:, coherence:, attention_weight: 0.5)
+                @id              = ::SecureRandom.uuid
+                @stream_ids      = stream_ids.dup
+                @binding_type    = binding_type
+                @coherence       = coherence.clamp(0.0, 1.0)
+                @attention_weight = attention_weight.clamp(0.0, 1.0)
+                @created_at = Time.now.utc
+              end
+
+              def add_stream(stream_id:)
+                @stream_ids << stream_id unless @stream_ids.include?(stream_id)
+              end
+
+              def remove_stream(stream_id:)
+                @stream_ids.delete(stream_id)
+              end
+
+              def reinforce!
+                @coherence = (@coherence + BINDING_BOOST).clamp(0.0, 1.0)
+              end
+
+              def decay!
+                @coherence = (@coherence - BINDING_DECAY).clamp(0.0, 1.0)
+              end
+
+              def coherent?
+                @coherence >= COHERENCE_THRESHOLD
+              end
+
+              def coherence_label
+                COHERENCE_LABELS.find { |range, _| range.cover?(@coherence) }&.last || :unbound
+              end
+
+              def stream_count
+                @stream_ids.size
+              end
+
+              def to_h
+                {
+                  id:               @id,
+                  stream_ids:       @stream_ids.dup,
+                  binding_type:     @binding_type,
+                  coherence:        @coherence.round(10),
+                  attention_weight: @attention_weight.round(10),
+                  coherent:         coherent?,
+                  coherence_label:  coherence_label,
+                  stream_count:     stream_count,
+                  created_at:       @created_at
+                }
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/legion/extensions/agentic/integration/phenomenal_binding/helpers/constants.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module Agentic
+      module Integration
+        module PhenomenalBinding
+          module Helpers
+            module Constants
+              MAX_STREAMS   = 100
+              MAX_BINDINGS  = 200
+
+              COHERENCE_THRESHOLD = 0.6
+              BINDING_DECAY       = 0.03
+              BINDING_BOOST       = 0.08
+              DEFAULT_SALIENCE    = 0.5
+
+              BINDING_TYPES = %i[perceptual conceptual temporal narrative emotional].freeze
+
+              COHERENCE_LABELS = {
+                (0.8..)     => :unified,
+                (0.6...0.8) => :coherent,
+                (0.4...0.6) => :fragmented,
+                (0.2...0.4) => :dissociated,
+                (..0.2)     => :unbound
+              }.freeze
+
+              STREAM_TYPES = %i[perception thought emotion memory intention prediction].freeze
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/legion/extensions/agentic/integration/phenomenal_binding/helpers/stream.rb

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+require 'securerandom'
+
+module Legion
+  module Extensions
+    module Agentic
+      module Integration
+        module PhenomenalBinding
+          module Helpers
+            class Stream
+              include Constants
+
+              attr_reader :id, :stream_type, :content, :salience, :timestamp, :domain, :created_at
+
+              def initialize(stream_type:, content:, salience: DEFAULT_SALIENCE, domain: nil, timestamp: nil)
+                @id          = ::SecureRandom.uuid
+                @stream_type = stream_type
+                @content     = content
+                @salience    = salience.clamp(0.0, 1.0)
+                @domain      = domain
+                @timestamp   = timestamp || Time.now.utc
+                @created_at  = Time.now.utc
+              end
+
+              def salient?
+                @salience >= DEFAULT_SALIENCE
+              end
+
+              def fresh?(window: 30)
+                (Time.now.utc - created_at) <= window
+              end
+
+              def to_h
+                {
+                  id:          @id,
+                  stream_type: @stream_type,
+                  content:     @content,
+                  salience:    @salience.round(10),
+                  domain:      @domain,
+                  timestamp:   @timestamp,
+                  created_at:  @created_at
+                }
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end