lex-agentic-attention 0.1.0

data/lib/legion/extensions/agentic/attention/switching/runners/attention_switching.rb

@@ -0,0 +1,92 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module Agentic
+      module Attention
+        module Switching
+          module Runners
+            module AttentionSwitching
+              include Legion::Extensions::Helpers::Lex if defined?(Legion::Extensions::Helpers::Lex)
+
+              def register_task(name:, task_type: :analytical, complexity: 0.5, engine: nil, **)
+                eng = engine || default_engine
+                task = eng.register_task(name: name, task_type: task_type, complexity: complexity)
+                { success: true, task: task.to_h }
+              end
+
+              def switch_to(task_id:, engine: nil, **)
+                eng = engine || default_engine
+                result = eng.switch_to(task_id: task_id)
+                return { success: false, error: 'task not found' } unless result
+
+                { success: true, **result }
+              end
+
+              def warmup(engine: nil, **)
+                eng = engine || default_engine
+                task = eng.warmup_active
+                return { success: false, error: 'no active task' } unless task
+
+                { success: true, task: task.to_h }
+              end
+
+              def decay_residuals(engine: nil, **)
+                eng = engine || default_engine
+                result = eng.decay_all_residuals!
+                { success: true, **result }
+              end
+
+              def active_task(engine: nil, **)
+                eng = engine || default_engine
+                task = eng.active_task
+                return { success: false, error: 'no active task' } unless task
+
+                { success: true, task: task.to_h }
+              end
+
+              def residual_tasks(engine: nil, **)
+                eng = engine || default_engine
+                { success: true, tasks: eng.tasks_with_residual.map(&:to_h) }
+              end
+
+              def recent_switches(limit: 10, engine: nil, **)
+                eng = engine || default_engine
+                { success: true, switches: eng.recent_switches(limit: limit).map(&:to_h) }
+              end
+
+              def average_switch_cost(engine: nil, **)
+                eng = engine || default_engine
+                { success: true, average_cost: eng.average_switch_cost }
+              end
+
+              def switch_cost_between(from_id:, to_id:, engine: nil, **)
+                eng = engine || default_engine
+                cost = eng.switch_cost_between(from_id: from_id, to_id: to_id)
+                return { success: false, error: 'no switches found for this pair' } unless cost
+
+                { success: true, cost: cost }
+              end
+
+              def switching_report(engine: nil, **)
+                eng = engine || default_engine
+                { success: true, report: eng.switching_report }
+              end
+
+              def status(engine: nil, **)
+                eng = engine || default_engine
+                { success: true, **eng.to_h }
+              end
+
+              private
+
+              def default_engine
+                @default_engine ||= Helpers::SwitchingEngine.new
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/legion/extensions/agentic/attention/switching/version.rb

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

data/lib/legion/extensions/agentic/attention/switching.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+require_relative 'switching/version'
+require_relative 'switching/helpers/constants'
+require_relative 'switching/helpers/task_set'
+require_relative 'switching/helpers/switch_event'
+require_relative 'switching/helpers/switching_engine'
+require_relative 'switching/runners/attention_switching'
+require_relative 'switching/client'
+
+module Legion
+  module Extensions
+    module Agentic
+      module Attention
+        module Switching
+        end
+      end
+    end
+  end
+end

data/lib/legion/extensions/agentic/attention/synesthesia/client.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+require 'legion/extensions/agentic/attention/synesthesia/helpers/constants'
+require 'legion/extensions/agentic/attention/synesthesia/helpers/sensory_mapping'
+require 'legion/extensions/agentic/attention/synesthesia/helpers/synesthetic_event'
+require 'legion/extensions/agentic/attention/synesthesia/helpers/synesthesia_engine'
+require 'legion/extensions/agentic/attention/synesthesia/runners/cognitive_synesthesia'
+
+module Legion
+  module Extensions
+    module Agentic
+      module Attention
+        module Synesthesia
+          class Client
+            include Runners::CognitiveSynesthesia
+
+            def initialize(engine: nil, **)
+              @synesthesia_engine = engine || Helpers::SynesthesiaEngine.new
+            end
+
+            private
+
+            attr_reader :synesthesia_engine
+          end
+        end
+      end
+    end
+  end
+end

data/lib/legion/extensions/agentic/attention/synesthesia/helpers/constants.rb

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module Agentic
+      module Attention
+        module Synesthesia
+          module Helpers
+            module Constants
+              MAX_MAPPINGS     = 200
+              MAX_EVENTS       = 500
+              DEFAULT_STRENGTH = 0.5
+              STRENGTH_BOOST   = 0.1
+              STRENGTH_DECAY   = 0.02
+              TRIGGER_THRESHOLD = 0.3
+
+              MODALITIES = %i[visual auditory tactile emotional semantic temporal spatial abstract].freeze
+
+              STRENGTH_LABELS = {
+                (0.8..)     => :dominant,
+                (0.6...0.8) => :strong,
+                (0.4...0.6) => :moderate,
+                (0.2...0.4) => :faint,
+                (..0.2)     => :trace
+              }.freeze
+
+              RICHNESS_LABELS = {
+                (0.8..)     => :synesthetic,
+                (0.6...0.8) => :vivid,
+                (0.4...0.6) => :partial,
+                (0.2...0.4) => :sparse,
+                (..0.2)     => :amodal
+              }.freeze
+
+              INTENSITY_LABELS = {
+                (0.8..)     => :overwhelming,
+                (0.6...0.8) => :intense,
+                (0.4...0.6) => :moderate,
+                (0.2...0.4) => :subtle,
+                (..0.2)     => :subliminal
+              }.freeze
+
+              def self.label_for(labels_hash, value)
+                labels_hash.find { |range, _| range.cover?(value) }&.last || :unknown
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/legion/extensions/agentic/attention/synesthesia/helpers/sensory_mapping.rb

@@ -0,0 +1,70 @@
+# frozen_string_literal: true
+
+require 'securerandom'
+
+module Legion
+  module Extensions
+    module Agentic
+      module Attention
+        module Synesthesia
+          module Helpers
+            class SensoryMapping
+              include Constants
+
+              attr_reader :id, :source_modality, :target_modality,
+                          :trigger_pattern, :response_pattern,
+                          :strength, :activation_count, :created_at, :last_activated_at
+
+              def initialize(source_modality:, target_modality:, trigger_pattern:, response_pattern:,
+                             strength: DEFAULT_STRENGTH)
+                @id               = SecureRandom.uuid
+                @source_modality  = source_modality
+                @target_modality  = target_modality
+                @trigger_pattern  = trigger_pattern
+                @response_pattern = response_pattern
+                @strength         = strength.clamp(0.0, 1.0)
+                @activation_count = 0
+                @created_at       = Time.now.utc
+                @last_activated_at = nil
+              end
+
+              def activate!
+                @activation_count += 1
+                @last_activated_at = Time.now.utc
+                @strength = (@strength + STRENGTH_BOOST).clamp(0.0, 1.0).round(10)
+              end
+
+              def decay!
+                @strength = (@strength - STRENGTH_DECAY).clamp(0.0, 1.0).round(10)
+              end
+
+              def active?
+                @strength >= TRIGGER_THRESHOLD
+              end
+
+              def strength_label
+                Constants.label_for(STRENGTH_LABELS, @strength)
+              end
+
+              def to_h
+                {
+                  id:                @id,
+                  source_modality:   @source_modality,
+                  target_modality:   @target_modality,
+                  trigger_pattern:   @trigger_pattern,
+                  response_pattern:  @response_pattern,
+                  strength:          @strength,
+                  activation_count:  @activation_count,
+                  strength_label:    strength_label,
+                  active:            active?,
+                  created_at:        @created_at,
+                  last_activated_at: @last_activated_at
+                }
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/legion/extensions/agentic/attention/synesthesia/helpers/synesthesia_engine.rb

@@ -0,0 +1,177 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module Agentic
+      module Attention
+        module Synesthesia
+          module Helpers
+            class SynesthesiaEngine
+              include Constants
+
+              attr_reader :mappings, :events
+
+              def initialize
+                @mappings = {}
+                @events   = []
+              end
+
+              def register_mapping(source_modality:, target_modality:, trigger_pattern:,
+                                   response_pattern:, strength: DEFAULT_STRENGTH, **)
+                return invalid_modality_error(:source_modality) unless MODALITIES.include?(source_modality)
+                return invalid_modality_error(:target_modality) unless MODALITIES.include?(target_modality)
+
+                mapping = SensoryMapping.new(
+                  source_modality:  source_modality,
+                  target_modality:  target_modality,
+                  trigger_pattern:  trigger_pattern,
+                  response_pattern: response_pattern,
+                  strength:         strength
+                )
+
+                @mappings[mapping.id] = mapping
+                prune_mappings! if @mappings.size > MAX_MAPPINGS
+
+                Legion::Logging.debug "[cognitive_synesthesia] mapping registered id=#{mapping.id[0..7]} " \
+                                      "#{source_modality}->#{target_modality} strength=#{strength.round(2)}"
+
+                { success: true, mapping_id: mapping.id, source_modality: source_modality,
+                  target_modality: target_modality }
+              end
+
+              def trigger(source_modality:, input:, **)
+                active = active_mappings_for(source_modality)
+                return { success: true, events: [], triggered_count: 0 } if active.empty?
+
+                triggered_events = active.map do |mapping|
+                  fire_event(mapping, input)
+                end
+
+                { success: true, events: triggered_events.map(&:to_h), triggered_count: triggered_events.size }
+              end
+
+              def decay_mappings!(**)
+                @mappings.each_value(&:decay!)
+                removed = prune_weak_mappings!
+
+                Legion::Logging.debug "[cognitive_synesthesia] decay_mappings! removed=#{removed} remaining=#{@mappings.size}"
+                { success: true, mappings_removed: removed, mappings_remaining: @mappings.size }
+              end
+
+              def cross_modal_richness(**)
+                return 0.0 if @mappings.empty?
+
+                pairs = active_mapping_pairs
+                total_possible = (MODALITIES.size * (MODALITIES.size - 1)).to_f
+                return 0.0 if total_possible.zero?
+
+                (pairs.size.to_f / total_possible).clamp(0.0, 1.0).round(10)
+              end
+
+              def dominant_modality_pairs(limit: 5, **)
+                pair_counts = Hash.new(0)
+                @mappings.each_value do |m|
+                  next unless m.active?
+
+                  pair_counts["#{m.source_modality}->#{m.target_modality}"] += m.activation_count
+                end
+
+                sorted = pair_counts.sort_by { |_, count| -count }.first(limit)
+                sorted.map { |pair, count| { pair: pair, activation_count: count } }
+              end
+
+              def event_history(limit: 20, **)
+                recent = @events.last(limit)
+                { success: true, events: recent.map(&:to_h), count: recent.size }
+              end
+
+              def modality_coverage(**)
+                covered = Set.new
+                @mappings.each_value do |m|
+                  next unless m.active?
+
+                  covered << m.source_modality
+                  covered << m.target_modality
+                end
+                {
+                  covered_modalities: covered.to_a.sort,
+                  coverage_count:     covered.size,
+                  total_modalities:   MODALITIES.size
+                }
+              end
+
+              def synesthesia_report(**)
+                richness = cross_modal_richness
+                {
+                  mapping_count:           @mappings.size,
+                  active_mapping_count:    @mappings.values.count(&:active?),
+                  event_count:             @events.size,
+                  cross_modal_richness:    richness,
+                  richness_label:          Constants.label_for(RICHNESS_LABELS, richness),
+                  dominant_modality_pairs: dominant_modality_pairs,
+                  modality_coverage:       modality_coverage
+                }
+              end
+
+              private
+
+              def invalid_modality_error(field)
+                { success: false, error: :invalid_modality, field: field, valid_modalities: MODALITIES }
+              end
+
+              def active_mappings_for(source_modality)
+                @mappings.values.select { |m| m.source_modality == source_modality && m.active? }
+              end
+
+              def fire_event(mapping, input)
+                mapping.activate!
+                intensity = mapping.strength.clamp(0.0, 1.0)
+                event = SynestheticEvent.new(
+                  mapping_id:    mapping.id,
+                  source_input:  input,
+                  target_output: build_target_output(mapping, input),
+                  intensity:     intensity
+                )
+                @events << event
+                @events.shift while @events.size > MAX_EVENTS
+
+                Legion::Logging.debug "[cognitive_synesthesia] event fired id=#{event.id[0..7]} " \
+                                      "mapping=#{mapping.id[0..7]} intensity=#{intensity.round(2)}"
+                event
+              end
+
+              def build_target_output(mapping, input)
+                {
+                  modality:         mapping.target_modality,
+                  response_pattern: mapping.response_pattern,
+                  source_input:     input,
+                  source_modality:  mapping.source_modality
+                }
+              end
+
+              def active_mapping_pairs
+                @mappings.values.select(&:active?).map do |m|
+                  [m.source_modality, m.target_modality]
+                end.uniq
+              end
+
+              def prune_mappings!
+                overflow = @mappings.size - MAX_MAPPINGS
+                return if overflow <= 0
+
+                ids_to_prune = @mappings.min_by(overflow) { |_, m| m.strength }.map(&:first)
+                ids_to_prune.each { |id| @mappings.delete(id) }
+              end
+
+              def prune_weak_mappings!
+                before = @mappings.size
+                @mappings.reject! { |_, m| m.strength <= 0.0 }
+                before - @mappings.size
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/legion/extensions/agentic/attention/synesthesia/helpers/synesthetic_event.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+require 'securerandom'
+
+module Legion
+  module Extensions
+    module Agentic
+      module Attention
+        module Synesthesia
+          module Helpers
+            class SynestheticEvent
+              include Constants
+
+              attr_reader :id, :mapping_id, :source_input, :target_output,
+                          :intensity, :involuntary, :triggered_at
+
+              def initialize(mapping_id:, source_input:, target_output:, intensity:, involuntary: true)
+                @id            = SecureRandom.uuid
+                @mapping_id    = mapping_id
+                @source_input  = source_input
+                @target_output = target_output
+                @intensity     = intensity.clamp(0.0, 1.0)
+                @involuntary   = involuntary
+                @triggered_at  = Time.now.utc
+              end
+
+              def intensity_label
+                Constants.label_for(INTENSITY_LABELS, @intensity)
+              end
+
+              def to_h
+                {
+                  id:              @id,
+                  mapping_id:      @mapping_id,
+                  source_input:    @source_input,
+                  target_output:   @target_output,
+                  intensity:       @intensity,
+                  intensity_label: intensity_label,
+                  involuntary:     @involuntary,
+                  triggered_at:    @triggered_at
+                }
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/legion/extensions/agentic/attention/synesthesia/runners/cognitive_synesthesia.rb

@@ -0,0 +1,83 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module Agentic
+      module Attention
+        module Synesthesia
+          module Runners
+            module CognitiveSynesthesia
+              include Legion::Extensions::Helpers::Lex if Legion::Extensions.const_defined?(:Helpers) &&
+                                                          Legion::Extensions::Helpers.const_defined?(:Lex)
+
+              def register_mapping(source_modality:, target_modality:, trigger_pattern:,
+                                   response_pattern:, strength: Helpers::Constants::DEFAULT_STRENGTH,
+                                   engine: nil, **)
+                target = engine || synesthesia_engine
+                Legion::Logging.debug "[cognitive_synesthesia] runner register_mapping #{source_modality}->#{target_modality}"
+                target.register_mapping(
+                  source_modality:  source_modality,
+                  target_modality:  target_modality,
+                  trigger_pattern:  trigger_pattern,
+                  response_pattern: response_pattern,
+                  strength:         strength
+                )
+              end
+
+              def trigger(source_modality:, input:, engine: nil, **)
+                target = engine || synesthesia_engine
+                Legion::Logging.debug "[cognitive_synesthesia] runner trigger modality=#{source_modality}"
+                target.trigger(source_modality: source_modality, input: input)
+              end
+
+              def decay_mappings(engine: nil, **)
+                target = engine || synesthesia_engine
+                Legion::Logging.debug '[cognitive_synesthesia] runner decay_mappings'
+                target.decay_mappings!
+              end
+
+              def cross_modal_richness(engine: nil, **)
+                target = engine || synesthesia_engine
+                richness = target.cross_modal_richness
+                label    = Helpers::Constants.label_for(Helpers::Constants::RICHNESS_LABELS, richness)
+                Legion::Logging.debug "[cognitive_synesthesia] runner cross_modal_richness=#{richness.round(4)} label=#{label}"
+                { success: true, richness: richness, richness_label: label }
+              end
+
+              def dominant_modality_pairs(limit: 5, engine: nil, **)
+                target = engine || synesthesia_engine
+                pairs  = target.dominant_modality_pairs(limit: limit)
+                Legion::Logging.debug "[cognitive_synesthesia] runner dominant_modality_pairs limit=#{limit}"
+                { success: true, pairs: pairs, count: pairs.size }
+              end
+
+              def event_history(limit: 20, engine: nil, **)
+                target = engine || synesthesia_engine
+                Legion::Logging.debug "[cognitive_synesthesia] runner event_history limit=#{limit}"
+                target.event_history(limit: limit)
+              end
+
+              def modality_coverage(engine: nil, **)
+                target = engine || synesthesia_engine
+                Legion::Logging.debug '[cognitive_synesthesia] runner modality_coverage'
+                { success: true }.merge(target.modality_coverage)
+              end
+
+              def synesthesia_report(engine: nil, **)
+                target = engine || synesthesia_engine
+                Legion::Logging.debug '[cognitive_synesthesia] runner synesthesia_report'
+                { success: true }.merge(target.synesthesia_report)
+              end
+
+              private
+
+              def synesthesia_engine
+                @synesthesia_engine ||= Helpers::SynesthesiaEngine.new
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/legion/extensions/agentic/attention/synesthesia/version.rb

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

data/lib/legion/extensions/agentic/attention/synesthesia.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+require 'legion/extensions/agentic/attention/synesthesia/version'
+require 'legion/extensions/agentic/attention/synesthesia/helpers/constants'
+require 'legion/extensions/agentic/attention/synesthesia/helpers/sensory_mapping'
+require 'legion/extensions/agentic/attention/synesthesia/helpers/synesthetic_event'
+require 'legion/extensions/agentic/attention/synesthesia/helpers/synesthesia_engine'
+require 'legion/extensions/agentic/attention/synesthesia/runners/cognitive_synesthesia'
+require 'legion/extensions/agentic/attention/synesthesia/client'
+
+module Legion
+  module Extensions
+    module Agentic
+      module Attention
+        module Synesthesia
+        end
+      end
+    end
+  end
+end

data/lib/legion/extensions/agentic/attention/telescope/client.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module Agentic
+      module Attention
+        module Telescope
+          class Client
+            include Runners::CognitiveTelescope
+          end
+        end
+      end
+    end
+  end
+end