lex-agentic-integration 0.1.0

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

@@ -0,0 +1,106 @@
+# frozen_string_literal: true
+
+require 'securerandom'
+
+module Legion
+  module Extensions
+    module Agentic
+      module Integration
+        module Integration
+          module Helpers
+            class IntegratedRepresentation
+              include Constants
+
+              attr_reader :id, :signal_ids, :modalities, :binding_strength,
+                          :coherence, :created_at
+
+              def initialize(signals:)
+                @id               = SecureRandom.uuid
+                @signal_ids       = signals.map(&:id)
+                @modalities       = signals.map(&:modality).uniq
+                @binding_strength = compute_binding(signals)
+                @coherence        = compute_coherence(signals)
+                @reinforcement_count = 0
+                @created_at       = Time.now.utc
+              end
+
+              def reinforce!
+                @binding_strength = (@binding_strength + REINFORCEMENT_RATE).clamp(0.0, 1.0).round(10)
+                @reinforcement_count += 1
+                self
+              end
+
+              def decay!
+                @binding_strength = (@binding_strength - BINDING_DECAY_RATE).clamp(0.0, 1.0).round(10)
+                self
+              end
+
+              def disrupt!(amount: CONFLICT_PENALTY)
+                @binding_strength = (@binding_strength - amount).clamp(0.0, 1.0).round(10)
+                @coherence = (@coherence - (amount * 0.5)).clamp(0.0, 1.0).round(10)
+                self
+              end
+
+              def modal_count = @modalities.size
+              def multi_modal? = @modalities.size > 1
+              def coherent? = @coherence >= COHERENT_THRESHOLD
+              def fragmented? = @coherence < FRAGMENTED_THRESHOLD
+
+              def binding_label
+                match = BINDING_LABELS.find { |range, _| range.cover?(@binding_strength) }
+                match ? match.last : :unbound
+              end
+
+              def quality_label
+                score = ((@binding_strength * 0.6) + (@coherence * 0.4)).round(10)
+                match = QUALITY_LABELS.find { |range, _| range.cover?(score) }
+                match ? match.last : :failed
+              end
+
+              def quality_score
+                ((@binding_strength * 0.6) + (@coherence * 0.4)).round(10)
+              end
+
+              def to_h
+                {
+                  id:                  @id,
+                  signal_ids:          @signal_ids,
+                  modalities:          @modalities,
+                  modal_count:         modal_count,
+                  multi_modal:         multi_modal?,
+                  binding_strength:    @binding_strength,
+                  binding_label:       binding_label,
+                  coherence:           @coherence,
+                  coherent:            coherent?,
+                  fragmented:          fragmented?,
+                  quality_score:       quality_score,
+                  quality_label:       quality_label,
+                  reinforcement_count: @reinforcement_count,
+                  created_at:          @created_at
+                }
+              end
+
+              private
+
+              def compute_binding(signals)
+                return DEFAULT_BINDING_STRENGTH if signals.empty?
+
+                weights = signals.map(&:effective_weight)
+                (weights.sum / weights.size).round(10)
+              end
+
+              def compute_coherence(signals)
+                return 0.0 if signals.size < 2
+
+                confidences = signals.map(&:confidence)
+                mean = confidences.sum / confidences.size
+                variance = confidences.sum { |c| (c - mean)**2 } / confidences.size
+                (1.0 - Math.sqrt(variance)).clamp(0.0, 1.0).round(10)
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,163 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module Agentic
+      module Integration
+        module Integration
+          module Helpers
+            class IntegrationEngine
+              include Constants
+
+              def initialize
+                @signals         = {}
+                @representations = {}
+              end
+
+              def add_signal(modality:, content:, confidence: 0.5, salience: 0.5)
+                prune_signals_if_needed
+                signal = ModalSignal.new(modality: modality, content: content,
+                                         confidence: confidence, salience: salience)
+                @signals[signal.id] = signal
+                signal
+              end
+
+              def remove_signal(signal_id:)
+                @signals.delete(signal_id)
+              end
+
+              def integrate(signal_ids:)
+                signals = signal_ids.filter_map { |sid| @signals[sid] }
+                return nil if signals.size < MIN_SIGNALS_FOR_BINDING
+
+                prune_representations_if_needed
+                rep = IntegratedRepresentation.new(signals: signals)
+                @representations[rep.id] = rep
+                rep
+              end
+
+              def integrate_by_modalities(modalities:)
+                mods = modalities.map(&:to_sym)
+                matching = @signals.values.select { |s| mods.include?(s.modality) }
+                return nil if matching.size < MIN_SIGNALS_FOR_BINDING
+
+                integrate(signal_ids: matching.map(&:id))
+              end
+
+              def integrate_all_salient
+                salient = @signals.values.select(&:salient?)
+                return nil if salient.size < MIN_SIGNALS_FOR_BINDING
+
+                integrate(signal_ids: salient.map(&:id))
+              end
+
+              def reinforce(representation_id:)
+                rep = @representations[representation_id]
+                return nil unless rep
+
+                rep.reinforce!
+              end
+
+              def disrupt(representation_id:, amount: CONFLICT_PENALTY)
+                rep = @representations[representation_id]
+                return nil unless rep
+
+                rep.disrupt!(amount: amount)
+              end
+
+              def decay_all!
+                @representations.each_value(&:decay!)
+                prune_weak_representations
+                { representations_remaining: @representations.size }
+              end
+
+              def signals_by_modality(modality:)
+                m = modality.to_sym
+                @signals.values.select { |s| s.modality == m }
+              end
+
+              def multi_modal_representations
+                @representations.values.select(&:multi_modal?)
+              end
+
+              def coherent_representations
+                @representations.values.select(&:coherent?)
+              end
+
+              def fragmented_representations
+                @representations.values.select(&:fragmented?)
+              end
+
+              def strongest_representations(limit: 5)
+                @representations.values.sort_by { |r| -r.binding_strength }.first(limit)
+              end
+
+              def average_binding_strength
+                return DEFAULT_BINDING_STRENGTH if @representations.empty?
+
+                vals = @representations.values.map(&:binding_strength)
+                (vals.sum / vals.size).round(10)
+              end
+
+              def average_coherence
+                return 0.5 if @representations.empty?
+
+                vals = @representations.values.map(&:coherence)
+                (vals.sum / vals.size).round(10)
+              end
+
+              def modality_coverage
+                @signals.values.map(&:modality).uniq
+              end
+
+              def integration_report
+                {
+                  total_signals:            @signals.size,
+                  total_representations:    @representations.size,
+                  multi_modal_count:        multi_modal_representations.size,
+                  coherent_count:           coherent_representations.size,
+                  fragmented_count:         fragmented_representations.size,
+                  average_binding_strength: average_binding_strength,
+                  average_coherence:        average_coherence,
+                  modality_coverage:        modality_coverage,
+                  strongest:                strongest_representations(limit: 3).map(&:to_h)
+                }
+              end
+
+              def to_h
+                {
+                  total_signals:            @signals.size,
+                  total_representations:    @representations.size,
+                  multi_modal_count:        multi_modal_representations.size,
+                  coherent_count:           coherent_representations.size,
+                  average_binding_strength: average_binding_strength,
+                  average_coherence:        average_coherence
+                }
+              end
+
+              private
+
+              def prune_signals_if_needed
+                return if @signals.size < MAX_SIGNALS
+
+                oldest = @signals.values.min_by(&:created_at)
+                @signals.delete(oldest.id) if oldest
+              end
+
+              def prune_representations_if_needed
+                return if @representations.size < MAX_REPRESENTATIONS
+
+                weakest = @representations.values.min_by(&:binding_strength)
+                @representations.delete(weakest.id) if weakest
+              end
+
+              def prune_weak_representations
+                @representations.reject! { |_, r| r.binding_strength <= 0.0 }
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,62 @@
+# frozen_string_literal: true
+
+require 'securerandom'
+
+module Legion
+  module Extensions
+    module Agentic
+      module Integration
+        module Integration
+          module Helpers
+            class ModalSignal
+              include Constants
+
+              attr_reader :id, :modality, :content, :confidence, :salience,
+                          :created_at
+
+              def initialize(modality:, content:, confidence: 0.5, salience: 0.5)
+                @id         = SecureRandom.uuid
+                @modality   = modality.to_sym
+                @content    = content
+                @confidence = confidence.to_f.clamp(0.0, 1.0).round(10)
+                @salience   = salience.to_f.clamp(0.0, 1.0).round(10)
+                @created_at = Time.now.utc
+              end
+
+              def effective_weight
+                (@confidence * @salience).round(10)
+              end
+
+              def salient?
+                @salience >= 0.6
+              end
+
+              def confident?
+                @confidence >= 0.6
+              end
+
+              def confidence_label
+                match = CONFIDENCE_LABELS.find { |range, _| range.cover?(@confidence) }
+                match ? match.last : :uncertain
+              end
+
+              def to_h
+                {
+                  id:               @id,
+                  modality:         @modality,
+                  content:          @content,
+                  confidence:       @confidence,
+                  confidence_label: confidence_label,
+                  salience:         @salience,
+                  effective_weight: effective_weight,
+                  salient:          salient?,
+                  created_at:       @created_at
+                }
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/legion/extensions/agentic/integration/integration/runners/cognitive_integration.rb

@@ -0,0 +1,105 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module Agentic
+      module Integration
+        module Integration
+          module Runners
+            module CognitiveIntegration
+              include Legion::Extensions::Helpers::Lex if defined?(Legion::Extensions::Helpers::Lex)
+
+              def add_signal(modality:, content:, confidence: 0.5, salience: 0.5, engine: nil, **)
+                eng = engine || default_engine
+                signal = eng.add_signal(modality: modality, content: content,
+                                        confidence: confidence, salience: salience)
+                { success: true, signal: signal.to_h }
+              end
+
+              def remove_signal(signal_id:, engine: nil, **)
+                eng = engine || default_engine
+                signal = eng.remove_signal(signal_id: signal_id)
+                return { success: false, error: 'signal not found' } unless signal
+
+                { success: true, removed: signal.to_h }
+              end
+
+              def integrate(signal_ids:, engine: nil, **)
+                eng = engine || default_engine
+                rep = eng.integrate(signal_ids: signal_ids)
+                return { success: false, error: 'insufficient signals for binding' } unless rep
+
+                { success: true, representation: rep.to_h }
+              end
+
+              def integrate_by_modalities(modalities:, engine: nil, **)
+                eng = engine || default_engine
+                rep = eng.integrate_by_modalities(modalities: modalities)
+                return { success: false, error: 'insufficient matching signals' } unless rep
+
+                { success: true, representation: rep.to_h }
+              end
+
+              def integrate_all_salient(engine: nil, **)
+                eng = engine || default_engine
+                rep = eng.integrate_all_salient
+                return { success: false, error: 'insufficient salient signals' } unless rep
+
+                { success: true, representation: rep.to_h }
+              end
+
+              def reinforce(representation_id:, engine: nil, **)
+                eng = engine || default_engine
+                rep = eng.reinforce(representation_id: representation_id)
+                return { success: false, error: 'representation not found' } unless rep
+
+                { success: true, representation: rep.to_h }
+              end
+
+              def disrupt(representation_id:, amount: nil, engine: nil, **)
+                eng = engine || default_engine
+                amt = amount || Helpers::Constants::CONFLICT_PENALTY
+                rep = eng.disrupt(representation_id: representation_id, amount: amt)
+                return { success: false, error: 'representation not found' } unless rep
+
+                { success: true, representation: rep.to_h }
+              end
+
+              def decay(engine: nil, **)
+                eng = engine || default_engine
+                result = eng.decay_all!
+                { success: true, **result }
+              end
+
+              def signals_by_modality(modality:, engine: nil, **)
+                eng = engine || default_engine
+                { success: true, signals: eng.signals_by_modality(modality: modality).map(&:to_h) }
+              end
+
+              def coherent_representations(engine: nil, **)
+                eng = engine || default_engine
+                { success: true, representations: eng.coherent_representations.map(&:to_h) }
+              end
+
+              def integration_report(engine: nil, **)
+                eng = engine || default_engine
+                { success: true, report: eng.integration_report }
+              end
+
+              def status(engine: nil, **)
+                eng = engine || default_engine
+                { success: true, **eng.to_h }
+              end
+
+              private
+
+              def default_engine
+                @default_engine ||= Helpers::IntegrationEngine.new
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

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

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

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+require_relative 'integration/version'
+require_relative 'integration/helpers/constants'
+require_relative 'integration/helpers/modal_signal'
+require_relative 'integration/helpers/integrated_representation'
+require_relative 'integration/helpers/integration_engine'
+require_relative 'integration/runners/cognitive_integration'
+require_relative 'integration/client'
+
+module Legion
+  module Extensions
+    module Agentic
+      module Integration
+        module Integration
+        end
+      end
+    end
+  end
+end

data/lib/legion/extensions/agentic/integration/labyrinth/actors/thread_walker.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+require 'legion/extensions/actors/every'
+
+module Legion
+  module Extensions
+    module Agentic
+      module Integration
+        module Labyrinth
+          module Actor
+            class ThreadWalker < Legion::Extensions::Actors::Every
+              def runner_class
+                Legion::Extensions::Agentic::Integration::Labyrinth::Runners::CognitiveLabyrinth
+              end
+
+              def runner_function
+                'list_labyrinths'
+              end
+
+              def time
+                600
+              end
+
+              def run_now?
+                false
+              end
+
+              def use_runner?
+                false
+              end
+
+              def check_subtask?
+                false
+              end
+
+              def generate_task?
+                false
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module Agentic
+      module Integration
+        module Labyrinth
+          class Client
+            include Runners::CognitiveLabyrinth
+
+            def initialize(**)
+              @labyrinth_engine = Helpers::LabyrinthEngine.new
+            end
+
+            private
+
+            attr_reader :labyrinth_engine
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module Agentic
+      module Integration
+        module Labyrinth
+          module Helpers
+            module Constants
+              NODE_TYPES = %i[corridor junction dead_end entrance exit minotaur_lair].freeze
+
+              MAX_LABYRINTHS = 20
+              MAX_NODES      = 200
+
+              COMPLEXITY_LABELS = {
+                (0.0...0.2) => :trivial,
+                (0.2...0.4) => :simple,
+                (0.4...0.6) => :moderate,
+                (0.6...0.8) => :complex,
+                (0.8..1.0)  => :labyrinthine
+              }.freeze
+
+              DANGER_LABELS = {
+                (0.0...0.25) => :safe,
+                (0.25...0.5) => :uncertain,
+                (0.5...0.75) => :hazardous,
+                (0.75..1.0)  => :lethal
+              }.freeze
+
+              DEFAULT_DANGER_LEVEL    = 0.0
+              MINOTAUR_DANGER_LEVEL   = 0.9
+              DEAD_END_COMPLEXITY_HIT = 0.1
+            end
+          end
+        end
+      end
+    end
+  end
+end