lex-agentic-attention 0.1.0

data/lib/legion/extensions/agentic/attention/lighthouse/helpers/lighthouse_engine.rb

@@ -0,0 +1,127 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module Agentic
+      module Attention
+        module Lighthouse
+          module Helpers
+            class LighthouseEngine
+              def initialize
+                @beacons   = {}
+                @fog_banks = {}
+              end
+
+              def light_beacon(beacon_type:, domain:, content:, luminosity: nil, sweep_angle: nil)
+                raise ArgumentError, 'too many beacons' if @beacons.size >= Constants::MAX_BEACONS
+
+                beacon = Beacon.new(
+                  beacon_type: beacon_type,
+                  domain:      domain,
+                  content:     content,
+                  luminosity:  luminosity,
+                  sweep_angle: sweep_angle
+                )
+                @beacons[beacon.id] = beacon
+                beacon
+              end
+
+              def create_fog(fog_type:, domain:, density: nil, extent: nil)
+                raise ArgumentError, 'too many fog banks' if @fog_banks.size >= Constants::MAX_FOG_BANKS
+
+                fog = Fog.new(fog_type: fog_type, domain: domain, density: density, extent: extent)
+                @fog_banks[fog.id] = fog
+                fog
+              end
+
+              def sweep(beacon_id:, fog_id:)
+                beacon = fetch_beacon(beacon_id)
+                fog    = fetch_fog(fog_id)
+
+                reduction = (beacon.luminosity * 0.5).round(10)
+                fog.disperse!(rate: reduction)
+
+                { beacon: beacon.to_h, fog: fog.to_h, reduction: reduction }
+              end
+
+              def dim_all!(rate: Constants::LUMINOSITY_RATE)
+                @beacons.each_value { |b| b.dim!(rate: rate) }
+                pruned = @beacons.select { |_, b| b.extinguished? }.keys
+                pruned.each { |id| @beacons.delete(id) }
+                { remaining: @beacons.size, pruned: pruned.size }
+              end
+
+              def thicken_all!(rate: Constants::FOG_DENSITY_RATE)
+                @fog_banks.each_value { |f| f.thicken!(rate: rate) }
+                { fog_banks: @fog_banks.size }
+              end
+
+              def brightest_beacons(limit: 5)
+                @beacons.values
+                        .reject(&:extinguished?)
+                        .sort_by { |b| -b.luminosity }
+                        .first(limit)
+              end
+
+              def densest_fogs(limit: 5)
+                @fog_banks.values
+                          .sort_by { |f| -f.density }
+                          .first(limit)
+              end
+
+              def visibility_report
+                avg_luminosity = compute_average_luminosity
+                avg_density    = compute_average_density
+                net_visibility = (avg_luminosity - avg_density).clamp(0.0, 1.0).round(10)
+
+                {
+                  total_beacons:    @beacons.size,
+                  total_fog_banks:  @fog_banks.size,
+                  avg_luminosity:   avg_luminosity,
+                  avg_density:      avg_density,
+                  net_visibility:   net_visibility,
+                  blazing_beacons:  @beacons.count { |_, b| b.blazing? },
+                  extinguished:     @beacons.count { |_, b| b.extinguished? },
+                  impenetrable_fog: @fog_banks.count { |_, f| f.impenetrable? },
+                  clearing_fog:     @fog_banks.count { |_, f| f.clearing? }
+                }
+              end
+
+              def all_beacons
+                @beacons.values
+              end
+
+              def all_fog_banks
+                @fog_banks.values
+              end
+
+              private
+
+              def fetch_beacon(id)
+                @beacons.fetch(id) { raise ArgumentError, "beacon not found: #{id}" }
+              end
+
+              def fetch_fog(id)
+                @fog_banks.fetch(id) { raise ArgumentError, "fog bank not found: #{id}" }
+              end
+
+              def compute_average_luminosity
+                return 0.0 if @beacons.empty?
+
+                total = @beacons.values.sum(&:luminosity)
+                (total / @beacons.size).round(10)
+              end
+
+              def compute_average_density
+                return 0.0 if @fog_banks.empty?
+
+                total = @fog_banks.values.sum(&:density)
+                (total / @fog_banks.size).round(10)
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/legion/extensions/agentic/attention/lighthouse/runners/cognitive_lighthouse.rb

@@ -0,0 +1,80 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module Agentic
+      module Attention
+        module Lighthouse
+          module Runners
+            module CognitiveLighthouse
+              extend self
+
+              include Legion::Extensions::Helpers::Lex if defined?(Legion::Extensions::Helpers::Lex)
+
+              def light_beacon(beacon_type:, domain:, content:, luminosity: nil,
+                               sweep_angle: nil, engine: nil, **)
+                eng    = resolve_engine(engine)
+                beacon = eng.light_beacon(
+                  beacon_type: beacon_type,
+                  domain:      domain,
+                  content:     content,
+                  luminosity:  luminosity,
+                  sweep_angle: sweep_angle
+                )
+                Legion::Logging.debug "[lighthouse] lit beacon: type=#{beacon_type} domain=#{domain} " \
+                                      "luminosity=#{beacon.luminosity}"
+                { success: true, beacon: beacon.to_h }
+              rescue ArgumentError => e
+                { success: false, error: e.message }
+              end
+
+              def create_fog(fog_type:, domain:, density: nil, extent: nil, engine: nil, **)
+                eng = resolve_engine(engine)
+                fog = eng.create_fog(fog_type: fog_type, domain: domain,
+                                     density: density, extent: extent)
+                Legion::Logging.debug "[lighthouse] created fog: type=#{fog_type} domain=#{domain} " \
+                                      "density=#{fog.density}"
+                { success: true, fog: fog.to_h }
+              rescue ArgumentError => e
+                { success: false, error: e.message }
+              end
+
+              def sweep(beacon_id:, fog_id:, engine: nil, **)
+                eng    = resolve_engine(engine)
+                result = eng.sweep(beacon_id: beacon_id, fog_id: fog_id)
+                Legion::Logging.debug "[lighthouse] sweep: beacon=#{beacon_id} fog=#{fog_id} " \
+                                      "reduction=#{result[:reduction]}"
+                { success: true, **result }
+              rescue ArgumentError => e
+                { success: false, error: e.message }
+              end
+
+              def list_beacons(engine: nil, domain: nil, beacon_type: nil, **)
+                eng     = resolve_engine(engine)
+                results = eng.all_beacons
+                results = results.select { |b| b.domain == domain.to_s } if domain
+                results = results.select { |b| b.beacon_type == beacon_type.to_sym } if beacon_type
+                { success: true, beacons: results.map(&:to_h), count: results.size }
+              end
+
+              def navigation_status(engine: nil, **)
+                eng = resolve_engine(engine)
+                { success: true, report: eng.visibility_report }
+              end
+
+              private
+
+              def resolve_engine(engine)
+                engine || default_engine
+              end
+
+              def default_engine
+                @default_engine ||= Helpers::LighthouseEngine.new
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

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

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

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+require 'securerandom'
+
+require_relative 'lighthouse/version'
+require_relative 'lighthouse/helpers/constants'
+require_relative 'lighthouse/helpers/beacon'
+require_relative 'lighthouse/helpers/fog'
+require_relative 'lighthouse/helpers/lighthouse_engine'
+require_relative 'lighthouse/runners/cognitive_lighthouse'
+require_relative 'lighthouse/client'
+
+module Legion
+  module Extensions
+    module Agentic
+      module Attention
+        module Lighthouse
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module Agentic
+      module Attention
+        module Priming
+          class Client
+            include Runners::Priming
+
+            attr_reader :network
+
+            def initialize(network: nil, **)
+              @network = network || Helpers::ActivationNetwork.new
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/legion/extensions/agentic/attention/priming/helpers/activation_network.rb

@@ -0,0 +1,130 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module Agentic
+      module Attention
+        module Priming
+          module Helpers
+            class ActivationNetwork
+              attr_reader :concepts
+
+              def initialize
+                @concepts = {}
+              end
+
+              def add_concept(name:, domain: :general)
+                @concepts[name] ||= ConceptNode.new(name: name, domain: domain)
+                trim_concepts
+                @concepts[name]
+              end
+
+              def link(name_a, name_b, strength: Constants::DEFAULT_ASSOCIATION_STRENGTH)
+                add_concept(name: name_a) unless @concepts.key?(name_a)
+                add_concept(name: name_b) unless @concepts.key?(name_b)
+                @concepts[name_a].associate(name_b, strength: strength)
+                @concepts[name_b].associate(name_a, strength: strength)
+              end
+
+              def prime(name, boost: Constants::PRIME_BOOST, source: nil, spread: true)
+                concept = @concepts[name]
+                return nil unless concept
+
+                concept.prime(boost: boost, source: source)
+                spread_activation(name, boost) if spread
+                concept
+              end
+
+              def activation_for(name)
+                concept = @concepts[name]
+                concept ? concept.activation : 0.0
+              end
+
+              def primed_concepts
+                @concepts.values.select(&:primed?)
+              end
+
+              def primed_in_domain(domain)
+                @concepts.values.select { |c| c.domain == domain && c.primed? }
+              end
+
+              def decay_all
+                @concepts.each_value do |concept|
+                  concept.decay_activation
+                  concept.decay_associations
+                end
+              end
+
+              def neighbors(name)
+                concept = @concepts[name]
+                return [] unless concept
+
+                concept.associated_names.filter_map { |n| @concepts[n] }
+              end
+
+              def concept_count
+                @concepts.size
+              end
+
+              def active_prime_count
+                primed_concepts.size
+              end
+
+              def strongest_primes(count = 5)
+                primed_concepts.sort_by { |c| -c.activation }.first(count)
+              end
+
+              def to_h
+                {
+                  concept_count:   @concepts.size,
+                  active_primes:   active_prime_count,
+                  primed_concepts: primed_concepts.map { |c| { name: c.name, activation: c.activation.round(4) } },
+                  domains:         @concepts.values.map(&:domain).uniq
+                }
+              end
+
+              private
+
+              def spread_activation(source_name, initial_boost)
+                visited = Set.new([source_name])
+                queue = [[source_name, initial_boost, 0]]
+
+                while queue.any?
+                  current_name, current_boost, depth = queue.shift
+                  next if depth >= Constants::MAX_SPREAD_HOPS
+
+                  concept = @concepts[current_name]
+                  next unless concept
+
+                  concept.associated_names.each do |neighbor_name|
+                    next if visited.include?(neighbor_name)
+
+                    visited.add(neighbor_name)
+                    neighbor = @concepts[neighbor_name]
+                    next unless neighbor
+
+                    strength = concept.association_strength(neighbor_name)
+                    spread_boost = current_boost * Constants::SPREAD_FACTOR * strength
+                    next if spread_boost < Constants::PRIME_THRESHOLD
+
+                    neighbor.prime(boost: spread_boost, source: source_name)
+                    concept.strengthen_association(neighbor_name)
+                    queue << [neighbor_name, spread_boost, depth + 1]
+                  end
+                end
+              end
+
+              def trim_concepts
+                return unless @concepts.size > Constants::MAX_CONCEPTS
+
+                sorted = @concepts.sort_by { |_, c| c.activation }
+                excess = @concepts.size - Constants::MAX_CONCEPTS
+                sorted.first(excess).each { |name, _| @concepts.delete(name) } # rubocop:disable Style/HashEachMethods
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/legion/extensions/agentic/attention/priming/helpers/concept_node.rb

@@ -0,0 +1,92 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module Agentic
+      module Attention
+        module Priming
+          module Helpers
+            class ConceptNode
+              attr_reader :name, :domain, :associations
+              attr_accessor :activation, :prime_source
+
+              def initialize(name:, domain: :general)
+                @name         = name
+                @domain       = domain
+                @activation   = 0.0
+                @prime_source = nil
+                @associations = {}
+              end
+
+              def primed?
+                @activation >= Constants::PRIME_THRESHOLD
+              end
+
+              def associate(other_name, strength: Constants::DEFAULT_ASSOCIATION_STRENGTH)
+                @associations[other_name] = strength.clamp(Constants::ASSOCIATION_FLOOR, Constants::ASSOCIATION_CEILING)
+                trim_associations
+              end
+
+              def strengthen_association(other_name)
+                return unless @associations.key?(other_name)
+
+                @associations[other_name] = [
+                  @associations[other_name] + Constants::ASSOCIATION_STRENGTHEN,
+                  Constants::ASSOCIATION_CEILING
+                ].min
+              end
+
+              def decay_associations
+                @associations.each_key do |key|
+                  @associations[key] = [
+                    @associations[key] - Constants::ASSOCIATION_DECAY,
+                    Constants::ASSOCIATION_FLOOR
+                  ].max
+                end
+              end
+
+              def decay_activation
+                @activation = [@activation - Constants::PRIME_DECAY, 0.0].max
+                @prime_source = nil unless primed?
+              end
+
+              def prime(boost: Constants::PRIME_BOOST, source: nil)
+                @activation = [@activation + boost, 1.0].min
+                @prime_source = source
+              end
+
+              def association_strength(other_name)
+                @associations[other_name] || 0.0
+              end
+
+              def associated_names
+                @associations.keys
+              end
+
+              def to_h
+                {
+                  name:         @name,
+                  domain:       @domain,
+                  activation:   @activation.round(4),
+                  primed:       primed?,
+                  prime_source: @prime_source,
+                  associations: @associations.transform_values { |v| v.round(4) }
+                }
+              end
+
+              private
+
+              def trim_associations
+                return unless @associations.size > Constants::MAX_ASSOCIATIONS
+
+                sorted = @associations.sort_by { |_, v| v }
+                excess = @associations.size - Constants::MAX_ASSOCIATIONS
+                sorted.first(excess).each { |name, _| @associations.delete(name) } # rubocop:disable Style/HashEachMethods
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module Agentic
+      module Attention
+        module Priming
+          module Helpers
+            module Constants
+              # Base activation boost from a prime
+              PRIME_BOOST = 0.3
+
+              # How fast priming decays per tick
+              PRIME_DECAY = 0.08
+
+              # Spreading activation factor (each hop reduces by this ratio)
+              SPREAD_FACTOR = 0.5
+
+              # Maximum hops for spreading activation
+              MAX_SPREAD_HOPS = 3
+
+              # Minimum activation to be considered primed
+              PRIME_THRESHOLD = 0.1
+
+              # Maximum concepts in the network
+              MAX_CONCEPTS = 500
+
+              # Maximum associations per concept
+              MAX_ASSOCIATIONS = 20
+
+              # Maximum active primes at once
+              MAX_ACTIVE_PRIMES = 100
+
+              # Default association strength between new connections
+              DEFAULT_ASSOCIATION_STRENGTH = 0.5
+
+              # Strengthening factor when association is activated
+              ASSOCIATION_STRENGTHEN = 0.05
+
+              # Weakening factor for unused associations
+              ASSOCIATION_DECAY = 0.01
+
+              # Association strength floor (never fully disconnect)
+              ASSOCIATION_FLOOR = 0.05
+
+              # Association strength ceiling
+              ASSOCIATION_CEILING = 1.0
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/legion/extensions/agentic/attention/priming/runners/priming.rb

@@ -0,0 +1,94 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module Agentic
+      module Attention
+        module Priming
+          module Runners
+            module Priming
+              include Legion::Extensions::Helpers::Lex
+
+              def network
+                @network ||= Helpers::ActivationNetwork.new
+              end
+
+              def prime_concept(name:, boost: nil, source: nil, spread: true, **)
+                boost ||= Helpers::Constants::PRIME_BOOST
+                network.add_concept(name: name) unless network.concepts.key?(name)
+                concept = network.prime(name, boost: boost, source: source, spread: spread)
+                return { success: false, reason: :not_found } unless concept
+
+                Legion::Logging.debug "[priming] primed #{name} activation=#{concept.activation.round(4)} spread=#{spread}"
+                { success: true, concept: concept.to_h, active_primes: network.active_prime_count }
+              end
+
+              def add_concept(name:, domain: :general, **)
+                concept = network.add_concept(name: name, domain: domain)
+                { success: true, concept: concept.to_h }
+              end
+
+              def link_concepts(name_a:, name_b:, strength: nil, **)
+                strength ||= Helpers::Constants::DEFAULT_ASSOCIATION_STRENGTH
+                network.link(name_a, name_b, strength: strength)
+                Legion::Logging.debug "[priming] linked #{name_a} <-> #{name_b} strength=#{strength}"
+                { success: true, name_a: name_a, name_b: name_b, strength: strength }
+              end
+
+              def update_priming(**)
+                network.decay_all
+                primed = network.primed_concepts
+                Legion::Logging.debug "[priming] tick: concepts=#{network.concept_count} active=#{primed.size}"
+                { success: true, active_primes: primed.size, concept_count: network.concept_count }
+              end
+
+              def check_primed(name:, **)
+                activation = network.activation_for(name)
+                concept = network.concepts[name]
+                {
+                  success:    true,
+                  name:       name,
+                  activation: activation.round(4),
+                  primed:     activation >= Helpers::Constants::PRIME_THRESHOLD,
+                  source:     concept&.prime_source
+                }
+              end
+
+              def primed_concepts(domain: nil, **)
+                concepts = domain ? network.primed_in_domain(domain) : network.primed_concepts
+                {
+                  success:  true,
+                  concepts: concepts.map { |c| { name: c.name, activation: c.activation.round(4), domain: c.domain } },
+                  count:    concepts.size
+                }
+              end
+
+              def strongest_primes(count: 5, **)
+                top = network.strongest_primes(count)
+                {
+                  success: true,
+                  primes:  top.map { |c| { name: c.name, activation: c.activation.round(4), domain: c.domain } },
+                  count:   top.size
+                }
+              end
+
+              def neighbors_for(name:, **)
+                nbrs = network.neighbors(name)
+                {
+                  success:   true,
+                  name:      name,
+                  neighbors: nbrs.map { |c| { name: c.name, activation: c.activation.round(4), primed: c.primed? } },
+                  count:     nbrs.size
+                }
+              end
+
+              def priming_stats(**)
+                { success: true, stats: network.to_h }
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

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

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

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+require_relative 'priming/version'
+require_relative 'priming/helpers/constants'
+require_relative 'priming/helpers/concept_node'
+require_relative 'priming/helpers/activation_network'
+require_relative 'priming/runners/priming'
+require_relative 'priming/client'
+
+module Legion
+  module Extensions
+    module Agentic
+      module Attention
+        module Priming
+        end
+      end
+    end
+  end
+end