lex-agentic-attention 0.1.0

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

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module Agentic
+      module Attention
+        module Prism
+          class Client
+            include Runners::CognitivePrism
+
+            attr_reader :engine
+
+            def initialize(engine: nil, **)
+              @engine         = engine || Helpers::PrismEngine.new
+              @default_engine = @engine
+            end
+
+            private
+
+            attr_writer :default_engine
+          end
+        end
+      end
+    end
+  end
+end

data/lib/legion/extensions/agentic/attention/prism/helpers/beam.rb

@@ -0,0 +1,169 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module Agentic
+      module Attention
+        module Prism
+          module Helpers
+            class Beam
+              BAND_MIDPOINTS = Constants::WAVELENGTH_RANGES.transform_values do |range|
+                ((range.min + range.max) / 2.0).round
+              end.freeze
+
+              attr_reader :beam_id, :domain, :content, :components
+
+              def initialize(beam_id:, domain:, content:)
+                @beam_id    = beam_id
+                @domain     = domain
+                @content    = content
+                @components = []
+                @purity     = 0.0
+              end
+
+              def purity
+                @purity.round(10)
+              end
+
+              def decompose!
+                @components = []
+                bands = assign_bands(content)
+
+                bands.each do |band, band_content|
+                  wavelength = BAND_MIDPOINTS.fetch(band)
+                  intensity  = compute_intensity(band, band_content)
+                  @components << SpectralComponent.new(
+                    band:       band,
+                    wavelength: wavelength,
+                    intensity:  intensity,
+                    content:    band_content
+                  )
+                end
+
+                @purity = compute_purity
+                self
+              end
+
+              def recompose
+                return '' if @components.empty?
+
+                active = @components.reject(&:faded?)
+                sorted = active.sort_by { |c| -c.intensity }
+                parts  = sorted.map { |c| "#{c.band}(#{c.intensity.round(3)}): #{summarize(c.content)}" }
+                parts.join(' | ')
+              end
+
+              def dominant_band
+                return nil if @components.empty?
+
+                dominant = @components.select(&:dominant?)
+                candidates = dominant.any? ? dominant : @components
+                candidates.max_by(&:intensity)&.band
+              end
+
+              def spectral_balance
+                return {} if @components.empty?
+
+                total = @components.sum(&:intensity)
+                return {} if total.zero?
+
+                @components.to_h do |c|
+                  [c.band, (c.intensity / total).round(10)]
+                end
+              end
+
+              def to_h
+                {
+                  beam_id:          @beam_id,
+                  domain:           @domain,
+                  content:          @content,
+                  purity:           purity,
+                  purity_label:     purity_label,
+                  dominant_band:    dominant_band,
+                  spectral_balance: spectral_balance,
+                  component_count:  @components.size,
+                  components:       @components.map(&:to_h)
+                }
+              end
+
+              private
+
+              def assign_bands(raw_content)
+                content_str = raw_content.is_a?(String) ? raw_content : raw_content.to_s
+                total_length = content_str.length
+                chunk_size   = total_length.positive? ? (total_length.to_f / Constants::SPECTRAL_BANDS.size).ceil : 1
+
+                Constants::SPECTRAL_BANDS.each_with_index.with_object({}) do |(band, idx), acc|
+                  start_pos  = idx * chunk_size
+                  chunk      = total_length.positive? ? content_str[start_pos, chunk_size] || '' : ''
+                  acc[band]  = { raw: chunk, abstraction_level: abstraction_level_for(band) }
+                end
+              end
+
+              def abstraction_level_for(band)
+                abstraction_map = {
+                  infrared:    :meta_contextual,
+                  red:         :concrete,
+                  orange:      :applied,
+                  yellow:      :structural,
+                  green:       :relational,
+                  blue:        :conceptual,
+                  violet:      :abstract,
+                  ultraviolet: :transcendent
+                }
+                abstraction_map.fetch(band, :unknown)
+              end
+
+              def compute_intensity(_band, band_content)
+                raw     = band_content[:raw].to_s
+                level   = band_content[:abstraction_level]
+                base    = raw.empty? ? 0.1 : (raw.length.to_f / 20).clamp(0.1, 1.0)
+                weight  = abstraction_weight(level)
+                (base * weight).clamp(0.0, 1.0).round(10)
+              end
+
+              def abstraction_weight(level)
+                weights = {
+                  meta_contextual: 0.6,
+                  concrete:        1.0,
+                  applied:         0.9,
+                  structural:      0.85,
+                  relational:      0.8,
+                  conceptual:      0.75,
+                  abstract:        0.7,
+                  transcendent:    0.5
+                }
+                weights.fetch(level, 0.7)
+              end
+
+              def compute_purity
+                return 0.0 if @components.empty?
+
+                intensities = @components.map(&:intensity)
+                total       = intensities.sum
+                return 0.0 if total.zero?
+
+                max = intensities.max
+                dominance_ratio = max / total
+                n = Constants::SPECTRAL_BANDS.size.to_f
+                uniformity = 1.0 - ((dominance_ratio - (1.0 / n)) * n / (n - 1)).abs
+                uniformity.clamp(0.0, 1.0).round(10)
+              end
+
+              def purity_label
+                Constants::PURITY_LABELS.find { |entry| entry[:range].cover?(@purity) }&.fetch(:label, :unknown)
+              end
+
+              def summarize(band_content)
+                return '' unless band_content.is_a?(Hash)
+
+                raw = band_content[:raw].to_s
+                raw.length > 30 ? "#{raw[0, 30]}..." : raw
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module Agentic
+      module Attention
+        module Prism
+          module Helpers
+            module Constants
+              SPECTRAL_BANDS = %i[infrared red orange yellow green blue violet ultraviolet].freeze
+
+              WAVELENGTH_RANGES = {
+                infrared:    700..1000,
+                red:         620..699,
+                orange:      590..619,
+                yellow:      560..589,
+                green:       490..559,
+                blue:        450..489,
+                violet:      380..449,
+                ultraviolet: 10..379
+              }.freeze
+
+              MAX_BEAMS = 200
+
+              INTENSITY_LABELS = [
+                { range: 0.0..0.19,  label: :trace },
+                { range: 0.2..0.39,  label: :faint },
+                { range: 0.4..0.59,  label: :moderate },
+                { range: 0.6..0.79,  label: :strong },
+                { range: 0.8..1.0,   label: :brilliant }
+              ].freeze
+
+              PURITY_LABELS = [
+                { range: 0.0..0.24,  label: :turbid },
+                { range: 0.25..0.49, label: :murky },
+                { range: 0.5..0.74,  label: :clear },
+                { range: 0.75..0.89, label: :pure },
+                { range: 0.9..1.0,   label: :prismatic }
+              ].freeze
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/legion/extensions/agentic/attention/prism/helpers/prism_engine.rb

@@ -0,0 +1,136 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module Agentic
+      module Attention
+        module Prism
+          module Helpers
+            class PrismEngine
+              def initialize
+                @beams      = {}
+                @components = {}
+              end
+
+              def create_beam(domain:, content:, beam_id: nil)
+                raise ArgumentError, "MAX_BEAMS (#{Constants::MAX_BEAMS}) reached" if @beams.size >= Constants::MAX_BEAMS
+
+                id   = beam_id || SecureRandom.uuid
+                beam = Beam.new(beam_id: id, domain: domain, content: content)
+                @beams[id] = beam
+                { success: true, beam_id: id, domain: domain }
+              end
+
+              def decompose(beam_id)
+                beam = @beams.fetch(beam_id) { return { success: false, error: "Beam #{beam_id} not found" } }
+
+                beam.decompose!
+                beam.components.each { |c| @components["#{beam_id}:#{c.band}"] = c }
+
+                Legion::Logging.debug "[cognitive_prism] decompose: beam=#{beam_id[0..7]} components=#{beam.components.size} purity=#{beam.purity.round(4)}"
+                {
+                  success:         true,
+                  beam_id:         beam_id,
+                  component_count: beam.components.size,
+                  dominant_band:   beam.dominant_band,
+                  purity:          beam.purity
+                }
+              end
+
+              def recompose(component_ids)
+                selected = component_ids.filter_map { |cid| resolve_component(cid) }
+                active   = selected.reject(&:faded?)
+                return { success: true, synthesis: '', active_count: 0, total_count: 0 } if active.empty?
+
+                synthesis = build_synthesis(active)
+                { success: true, synthesis: synthesis, active_count: active.size, total_count: selected.size }
+              end
+
+              def attenuate_all!(rate: SpectralComponent::ATTENUATION_RATE_DEFAULT)
+                count = 0
+                @beams.each_value do |beam|
+                  beam.components.each do |c|
+                    c.attenuate!(rate: rate)
+                    count += 1
+                  end
+                end
+                { success: true, attenuated: count, rate: rate }
+              end
+
+              def dominant_bands
+                result = Hash.new(0)
+                @beams.each_value do |beam|
+                  band = beam.dominant_band
+                  result[band] += 1 if band
+                end
+                result.sort_by { |_, v| -v }.to_h
+              end
+
+              def most_intense(limit: 5)
+                all_components = @beams.values.flat_map(&:components)
+                all_components
+                  .sort_by { |c| -c.intensity }
+                  .first(limit)
+                  .map(&:to_h)
+              end
+
+              def spectral_report
+                total_beams      = @beams.size
+                total_components = @beams.values.sum { |b| b.components.size }
+                decomposed_beams = @beams.count { |_, b| b.components.any? }
+
+                avg_purity = if decomposed_beams.positive?
+                               purity_sum = @beams.values.select { |b| b.components.any? }.sum(&:purity)
+                               (purity_sum / decomposed_beams).round(10)
+                             else
+                               0.0
+                             end
+
+                {
+                  total_beams:      total_beams,
+                  decomposed_beams: decomposed_beams,
+                  total_components: total_components,
+                  dominant_bands:   dominant_bands,
+                  avg_purity:       avg_purity,
+                  most_intense:     most_intense(limit: 3)
+                }
+              end
+
+              def get_beam(beam_id)
+                @beams[beam_id]
+              end
+
+              def beam_count
+                @beams.size
+              end
+
+              def clear!
+                @beams.clear
+                @components.clear
+                self
+              end
+
+              private
+
+              def resolve_component(cid)
+                return @components[cid] if @components.key?(cid)
+
+                @components.values.find { |c| component_key(c.band) == cid }
+              end
+
+              def build_synthesis(active)
+                active.sort_by { |c| -c.intensity }
+                      .map { |c| "[#{c.band}/#{c.wavelength}nm #{c.intensity.round(3)}]: #{c.content}" }
+                      .join(' | ')
+              end
+
+              def component_key(band)
+                band.to_s
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/legion/extensions/agentic/attention/prism/helpers/spectral_component.rb

@@ -0,0 +1,72 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module Agentic
+      module Attention
+        module Prism
+          module Helpers
+            class SpectralComponent
+              ATTENUATION_RATE_DEFAULT = 0.05
+              AMPLIFY_BOOST_DEFAULT    = 0.1
+              DOMINANT_THRESHOLD       = 0.7
+              FADED_THRESHOLD          = 0.1
+
+              attr_reader :band, :wavelength, :content
+
+              def initialize(band:, wavelength:, intensity:, content:)
+                raise ArgumentError, "Unknown band: #{band}" unless Constants::SPECTRAL_BANDS.include?(band)
+
+                range = Constants::WAVELENGTH_RANGES.fetch(band)
+                raise ArgumentError, "Wavelength #{wavelength} out of range for #{band}" unless range.cover?(wavelength)
+
+                @band       = band
+                @wavelength = wavelength
+                @intensity  = intensity.clamp(0.0, 1.0)
+                @content    = content
+              end
+
+              def intensity
+                @intensity.round(10)
+              end
+
+              def attenuate!(rate: ATTENUATION_RATE_DEFAULT)
+                @intensity = (@intensity - rate.to_f.abs).clamp(0.0, 1.0)
+                self
+              end
+
+              def amplify!(boost: AMPLIFY_BOOST_DEFAULT)
+                @intensity = (@intensity + boost.to_f.abs).clamp(0.0, 1.0)
+                self
+              end
+
+              def dominant?
+                @intensity >= DOMINANT_THRESHOLD
+              end
+
+              def faded?
+                @intensity <= FADED_THRESHOLD
+              end
+
+              def intensity_label
+                Constants::INTENSITY_LABELS.find { |entry| entry[:range].cover?(@intensity) }&.fetch(:label, :unknown)
+              end
+
+              def to_h
+                {
+                  band:            @band,
+                  wavelength:      @wavelength,
+                  intensity:       intensity,
+                  intensity_label: intensity_label,
+                  content:         @content,
+                  dominant:        dominant?,
+                  faded:           faded?
+                }
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/legion/extensions/agentic/attention/prism/runners/cognitive_prism.rb

@@ -0,0 +1,79 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module Agentic
+      module Attention
+        module Prism
+          module Runners
+            module CognitivePrism
+              extend self
+
+              include Legion::Extensions::Helpers::Lex if defined?(Legion::Extensions::Helpers::Lex)
+
+              def create_beam(domain:, content:, beam_id: nil, engine: nil, **)
+                prism = engine || default_engine
+                prism.create_beam(domain: domain, content: content, beam_id: beam_id)
+              rescue ArgumentError => e
+                Legion::Logging.warn "[cognitive_prism] create_beam failed: #{e.message}"
+                { success: false, error: e.message }
+              end
+
+              def decompose(beam_id:, engine: nil, **)
+                prism = engine || default_engine
+                prism.decompose(beam_id)
+              rescue ArgumentError => e
+                Legion::Logging.warn "[cognitive_prism] decompose failed: #{e.message}"
+                { success: false, error: e.message }
+              end
+
+              def recompose(component_ids:, engine: nil, **)
+                prism = engine || default_engine
+                prism.recompose(component_ids)
+              rescue ArgumentError => e
+                Legion::Logging.warn "[cognitive_prism] recompose failed: #{e.message}"
+                { success: false, error: e.message }
+              end
+
+              def attenuate_all(rate: Helpers::SpectralComponent::ATTENUATION_RATE_DEFAULT, engine: nil, **)
+                prism = engine || default_engine
+                prism.attenuate_all!(rate: rate)
+              rescue ArgumentError => e
+                Legion::Logging.warn "[cognitive_prism] attenuate_all failed: #{e.message}"
+                { success: false, error: e.message }
+              end
+
+              def dominant_bands(engine: nil, **)
+                prism = engine || default_engine
+                { success: true, bands: prism.dominant_bands }
+              rescue ArgumentError => e
+                { success: false, error: e.message }
+              end
+
+              def most_intense(limit: 5, engine: nil, **)
+                prism = engine || default_engine
+                { success: true, components: prism.most_intense(limit: limit) }
+              rescue ArgumentError => e
+                { success: false, error: e.message }
+              end
+
+              def spectral_report(engine: nil, **)
+                prism = engine || default_engine
+                report = prism.spectral_report
+                { success: true }.merge(report)
+              rescue ArgumentError => e
+                { success: false, error: e.message }
+              end
+
+              private
+
+              def default_engine
+                @default_engine ||= Helpers::PrismEngine.new
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

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

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

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+require 'securerandom'
+
+require_relative 'prism/version'
+require_relative 'prism/helpers/constants'
+require_relative 'prism/helpers/spectral_component'
+require_relative 'prism/helpers/beam'
+require_relative 'prism/helpers/prism_engine'
+require_relative 'prism/runners/cognitive_prism'
+require_relative 'prism/client'
+
+module Legion
+  module Extensions
+    module Agentic
+      module Attention
+        module Prism
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module Agentic
+      module Attention
+        module Regulation
+          class Client
+            include Runners::AttentionRegulation
+
+            def initialize(controller: nil)
+              @controller = controller || Helpers::AttentionController.new
+            end
+          end
+        end
+      end
+    end
+  end
+end