lex-agentic-integration 0.1.0

data/lib/legion/extensions/agentic/integration/mosaic/helpers/mosaic.rb

@@ -0,0 +1,111 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module Agentic
+      module Integration
+        module Mosaic
+          module Helpers
+            class Mosaic
+              attr_reader :id, :name, :pattern_category, :tessera_ids,
+                          :capacity, :created_at
+              attr_accessor :grout_strength
+
+              def initialize(name:, pattern_category:, capacity: 50, grout_strength: nil)
+                validate_pattern!(pattern_category)
+                @id               = SecureRandom.uuid
+                @name             = name.to_s
+                @pattern_category = pattern_category.to_sym
+                @tessera_ids      = []
+                @capacity         = capacity.to_i.clamp(1, 500)
+                @grout_strength   = (grout_strength || 0.8).to_f.clamp(0.0, 1.0).round(10)
+                @created_at       = Time.now.utc
+              end
+
+              def add_tessera(tessera_id)
+                return false if @tessera_ids.include?(tessera_id)
+                return false if full?
+
+                @tessera_ids << tessera_id
+                true
+              end
+
+              def remove_tessera(tessera_id)
+                @tessera_ids.delete(tessera_id) ? true : false
+              end
+
+              def size
+                @tessera_ids.size
+              end
+
+              def full?
+                @tessera_ids.size >= @capacity
+              end
+
+              def empty?
+                @tessera_ids.empty?
+              end
+
+              def completeness
+                return 0.0 if @capacity.zero?
+
+                (@tessera_ids.size.to_f / @capacity).clamp(0.0, 1.0).round(10)
+              end
+
+              def erode_grout!(rate: Constants::GROUT_DECAY)
+                @grout_strength = (@grout_strength - rate.abs).clamp(0.0, 1.0).round(10)
+                self
+              end
+
+              def reinforce_grout!(boost: 0.1)
+                @grout_strength = (@grout_strength + boost.abs).clamp(0.0, 1.0).round(10)
+                self
+              end
+
+              def crumbling?
+                @grout_strength < 0.2
+              end
+
+              def completeness_label
+                Constants.label_for(Constants::COMPLETENESS_LABELS, completeness)
+              end
+
+              def gap_count
+                @capacity - @tessera_ids.size
+              end
+
+              def to_h
+                {
+                  id:                 @id,
+                  name:               @name,
+                  pattern_category:   @pattern_category,
+                  tessera_ids:        @tessera_ids.dup,
+                  size:               size,
+                  capacity:           @capacity,
+                  completeness:       completeness,
+                  completeness_label: completeness_label,
+                  grout_strength:     @grout_strength,
+                  gap_count:          gap_count,
+                  full:               full?,
+                  empty:              empty?,
+                  crumbling:          crumbling?,
+                  created_at:         @created_at
+                }
+              end
+
+              private
+
+              def validate_pattern!(val)
+                return if Constants::PATTERN_CATEGORIES.include?(val.to_sym)
+
+                raise ArgumentError,
+                      "unknown pattern category: #{val.inspect}; " \
+                      "must be one of #{Constants::PATTERN_CATEGORIES.inspect}"
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/legion/extensions/agentic/integration/mosaic/helpers/mosaic_engine.rb

@@ -0,0 +1,124 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module Agentic
+      module Integration
+        module Mosaic
+          module Helpers
+            class MosaicEngine
+              def initialize
+                @tesserae = {}
+                @mosaics  = {}
+              end
+
+              def create_tessera(material:, domain:, content:, color: nil, fit_quality: nil)
+                raise ArgumentError, 'tessera limit reached' if @tesserae.size >= Constants::MAX_TESSERAE
+
+                t = Tessera.new(material: material, domain: domain, content: content,
+                                color: color, fit_quality: fit_quality)
+                @tesserae[t.id] = t
+                t
+              end
+
+              def create_mosaic(name:, pattern_category:, capacity: 50, grout_strength: nil)
+                raise ArgumentError, 'mosaic limit reached' if @mosaics.size >= Constants::MAX_MOSAICS
+
+                m = Mosaic.new(name: name, pattern_category: pattern_category,
+                               capacity: capacity, grout_strength: grout_strength)
+                @mosaics[m.id] = m
+                m
+              end
+
+              def place_tessera(tessera_id:, mosaic_id:)
+                tessera = fetch_tessera(tessera_id)
+                mosaic  = fetch_mosaic(mosaic_id)
+
+                raise ArgumentError, 'tessera already placed' if tessera.placed?
+                raise ArgumentError, 'mosaic is full' if mosaic.full?
+
+                mosaic.add_tessera(tessera_id)
+                tessera.place!(mosaic_id)
+              end
+
+              def erode_all_grout!(rate: Constants::GROUT_DECAY)
+                @mosaics.each_value { |m| m.erode_grout!(rate: rate) }
+                crumbling = @mosaics.count { |_, m| m.crumbling? }
+                { total: @mosaics.size, crumbling: crumbling }
+              end
+
+              def most_complete(limit: 5)
+                @mosaics.values.sort_by { |m| -m.completeness }.first(limit)
+              end
+
+              def most_gaps(limit: 5)
+                @mosaics.values.sort_by { |m| -m.gap_count }.first(limit)
+              end
+
+              def loose_tesserae
+                @tesserae.values.select(&:loose?)
+              end
+
+              def tesserae_by_material
+                counts = Constants::MATERIAL_TYPES.to_h { |m| [m, 0] }
+                @tesserae.each_value { |t| counts[t.material] += 1 }
+                counts
+              end
+
+              def coherence(mosaic_id:)
+                mosaic = fetch_mosaic(mosaic_id)
+                return 0.0 if mosaic.empty?
+
+                placed = mosaic.tessera_ids.filter_map { |id| @tesserae[id] }
+                return 0.0 if placed.empty?
+
+                avg_fit = placed.sum(&:fit_quality) / placed.size
+                grout_factor = mosaic.grout_strength
+                ((avg_fit + grout_factor) / 2.0).clamp(0.0, 1.0).round(10)
+              end
+
+              def coherence_label(mosaic_id:)
+                Constants.label_for(Constants::COHERENCE_LABELS, coherence(mosaic_id: mosaic_id))
+              end
+
+              def mosaic_report
+                {
+                  total_tesserae:   @tesserae.size,
+                  total_mosaics:    @mosaics.size,
+                  loose_count:      loose_tesserae.size,
+                  by_material:      tesserae_by_material,
+                  crumbling_count:  @mosaics.count { |_, m| m.crumbling? },
+                  avg_completeness: avg_completeness
+                }
+              end
+
+              def all_tesserae
+                @tesserae.values
+              end
+
+              def all_mosaics
+                @mosaics.values
+              end
+
+              private
+
+              def fetch_tessera(id)
+                @tesserae.fetch(id) { raise ArgumentError, "tessera not found: #{id}" }
+              end
+
+              def fetch_mosaic(id)
+                @mosaics.fetch(id) { raise ArgumentError, "mosaic not found: #{id}" }
+              end
+
+              def avg_completeness
+                return 0.0 if @mosaics.empty?
+
+                (@mosaics.values.sum(&:completeness) / @mosaics.size).round(10)
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/legion/extensions/agentic/integration/mosaic/helpers/tessera.rb

@@ -0,0 +1,86 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module Agentic
+      module Integration
+        module Mosaic
+          module Helpers
+            class Tessera
+              attr_reader :id, :material, :domain, :content,
+                          :color, :placed_at, :mosaic_id
+              attr_accessor :fit_quality
+
+              def initialize(material:, domain:, content:,
+                             color: nil, fit_quality: nil)
+                validate_material!(material)
+                @id          = SecureRandom.uuid
+                @material    = material.to_sym
+                @domain      = domain.to_sym
+                @content     = content.to_s
+                @color       = (color || random_color).to_sym
+                @fit_quality = (fit_quality || 0.5).to_f.clamp(0.0, 1.0).round(10)
+                @placed_at   = nil
+                @mosaic_id   = nil
+              end
+
+              def place!(mosaic_id)
+                @mosaic_id = mosaic_id
+                @placed_at = Time.now.utc
+                self
+              end
+
+              def placed?
+                !@mosaic_id.nil?
+              end
+
+              def loose?
+                @mosaic_id.nil?
+              end
+
+              def perfect_fit?
+                @fit_quality >= 0.9
+              end
+
+              def poor_fit?
+                @fit_quality < 0.3
+              end
+
+              def to_h
+                {
+                  id:          @id,
+                  material:    @material,
+                  domain:      @domain,
+                  content:     @content,
+                  color:       @color,
+                  fit_quality: @fit_quality,
+                  placed:      placed?,
+                  loose:       loose?,
+                  perfect_fit: perfect_fit?,
+                  poor_fit:    poor_fit?,
+                  mosaic_id:   @mosaic_id,
+                  placed_at:   @placed_at
+                }
+              end
+
+              private
+
+              def random_color
+                %i[red blue green gold white black silver amber
+                   turquoise crimson ivory jade].sample
+              end
+
+              def validate_material!(val)
+                return if Constants::MATERIAL_TYPES.include?(val.to_sym)
+
+                raise ArgumentError,
+                      "unknown material: #{val.inspect}; " \
+                      "must be one of #{Constants::MATERIAL_TYPES.inspect}"
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/legion/extensions/agentic/integration/mosaic/runners/cognitive_mosaic.rb

@@ -0,0 +1,76 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module Agentic
+      module Integration
+        module Mosaic
+          module Runners
+            module CognitiveMosaic
+              extend self
+
+              def create_tessera(material:, domain:, content:,
+                                 color: nil, fit_quality: nil, engine: nil, **)
+                eng = resolve_engine(engine)
+                t   = eng.create_tessera(material: material, domain: domain,
+                                         content: content, color: color,
+                                         fit_quality: fit_quality)
+                { success: true, tessera: t.to_h }
+              rescue ArgumentError => e
+                { success: false, error: e.message }
+              end
+
+              def create_mosaic(name:, pattern_category:, capacity: 50,
+                                grout_strength: nil, engine: nil, **)
+                eng = resolve_engine(engine)
+                m   = eng.create_mosaic(name: name, pattern_category: pattern_category,
+                                        capacity: capacity, grout_strength: grout_strength)
+                { success: true, mosaic: m.to_h }
+              rescue ArgumentError => e
+                { success: false, error: e.message }
+              end
+
+              def place_tessera(tessera_id:, mosaic_id:, engine: nil, **)
+                eng = resolve_engine(engine)
+                t   = eng.place_tessera(tessera_id: tessera_id, mosaic_id: mosaic_id)
+                { success: true, tessera: t.to_h }
+              rescue ArgumentError => e
+                { success: false, error: e.message }
+              end
+
+              def list_tesserae(engine: nil, material: nil, **)
+                eng     = resolve_engine(engine)
+                results = eng.all_tesserae
+                results = results.select { |t| t.material == material.to_sym } if material
+                { success: true, tesserae: results.map(&:to_h), count: results.size }
+              end
+
+              def list_mosaics(engine: nil, **)
+                eng = resolve_engine(engine)
+                { success: true, mosaics: eng.all_mosaics.map(&:to_h),
+                  count: eng.all_mosaics.size }
+              end
+
+              def mosaic_status(engine: nil, **)
+                eng = resolve_engine(engine)
+                { success: true, report: eng.mosaic_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::MosaicEngine.new
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

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

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

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+require 'securerandom'
+
+require_relative 'mosaic/version'
+require_relative 'mosaic/helpers/constants'
+require_relative 'mosaic/helpers/tessera'
+require_relative 'mosaic/helpers/mosaic'
+require_relative 'mosaic/helpers/mosaic_engine'
+require_relative 'mosaic/runners/cognitive_mosaic'
+require_relative 'mosaic/client'
+
+module Legion
+  module Extensions
+    module Agentic
+      module Integration
+        module Mosaic
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module Agentic
+      module Integration
+        module Mycelium
+          class Client
+            include Runners::CognitiveMycelium
+
+            def initialize(engine: nil)
+              @default_engine = engine || Helpers::MyceliumEngine.new
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module Agentic
+      module Integration
+        module Mycelium
+          module Helpers
+            module Constants
+              MAX_NODES           = 200
+              MAX_HYPHAE          = 500
+              MAX_FRUITING_BODIES = 100
+              NUTRIENT_DECAY      = 0.03
+              TRANSFER_EFFICIENCY = 0.8
+              FRUITING_THRESHOLD  = 0.7
+
+              NODE_TYPES = %i[
+                knowledge_cluster insight_node memory_node
+                skill_node pattern_node creative_node
+              ].freeze
+
+              NUTRIENT_TYPES = %i[
+                information experience emotional_energy
+                novelty pattern_recognition creative_potential
+              ].freeze
+
+              HYPHA_STATES = %i[growing mature dormant decaying].freeze
+
+              FRUITING_TYPES = %i[
+                insight breakthrough connection analogy
+                synthesis innovation
+              ].freeze
+
+              NETWORK_HEALTH_LABELS = [
+                [0.8..1.0, :thriving],
+                [0.6..0.8, :healthy],
+                [0.4..0.6, :stable],
+                [0.2..0.4, :stressed],
+                [0.0..0.2, :depleted]
+              ].freeze
+
+              def self.label_for(table, value)
+                table.each { |range, label| return label if range.cover?(value) }
+                table.last.last
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module Agentic
+      module Integration
+        module Mycelium
+          module Helpers
+            class FruitingBody
+              attr_reader :id, :fruiting_type, :source_node_id,
+                          :content, :potency, :emerged_at
+
+              def initialize(fruiting_type:, source_node_id:,
+                             content:, potency: 0.5)
+                validate_type!(fruiting_type)
+                @id             = SecureRandom.uuid
+                @fruiting_type  = fruiting_type.to_sym
+                @source_node_id = source_node_id
+                @content        = content.to_s
+                @potency        = potency.to_f.clamp(0.0, 1.0).round(10)
+                @emerged_at     = Time.now.utc
+              end
+
+              def to_h
+                {
+                  id:             @id,
+                  fruiting_type:  @fruiting_type,
+                  source_node_id: @source_node_id,
+                  content:        @content,
+                  potency:        @potency,
+                  emerged_at:     @emerged_at
+                }
+              end
+
+              private
+
+              def validate_type!(val)
+                return if Constants::FRUITING_TYPES.include?(val.to_sym)
+
+                raise ArgumentError,
+                      "unknown fruiting type: #{val.inspect}; " \
+                      "must be one of #{Constants::FRUITING_TYPES.inspect}"
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,76 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module Agentic
+      module Integration
+        module Mycelium
+          module Helpers
+            class Hypha
+              attr_reader :id, :source_id, :target_id, :nutrient_type,
+                          :created_at
+              attr_accessor :strength, :state
+
+              def initialize(source_id:, target_id:, nutrient_type:,
+                             strength: 0.5)
+                validate_nutrient!(nutrient_type)
+                @id            = SecureRandom.uuid
+                @source_id     = source_id
+                @target_id     = target_id
+                @nutrient_type = nutrient_type.to_sym
+                @strength      = strength.to_f.clamp(0.0, 1.0).round(10)
+                @state         = :growing
+                @created_at    = Time.now.utc
+              end
+
+              def reinforce!(amount: 0.1)
+                @strength = (@strength + amount.abs).clamp(0.0, 1.0).round(10)
+                @state = :mature if @strength >= 0.6
+                self
+              end
+
+              def decay!(rate: Constants::NUTRIENT_DECAY)
+                @strength = (@strength - rate.abs).clamp(0.0, 1.0).round(10)
+                @state = :decaying if @strength < 0.2
+                @state = :dormant if @strength < 0.4 && @state == :mature
+                self
+              end
+
+              def transfer_capacity
+                (@strength * Constants::TRANSFER_EFFICIENCY).round(10)
+              end
+
+              def active?
+                %i[growing mature].include?(@state)
+              end
+
+              def to_h
+                {
+                  id:                @id,
+                  source_id:         @source_id,
+                  target_id:         @target_id,
+                  nutrient_type:     @nutrient_type,
+                  strength:          @strength,
+                  state:             @state,
+                  transfer_capacity: transfer_capacity,
+                  active:            active?,
+                  created_at:        @created_at
+                }
+              end
+
+              private
+
+              def validate_nutrient!(val)
+                return if Constants::NUTRIENT_TYPES.include?(val.to_sym)
+
+                raise ArgumentError,
+                      "unknown nutrient type: #{val.inspect}; " \
+                      "must be one of #{Constants::NUTRIENT_TYPES.inspect}"
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end