lex-agentic-imagination 0.1.0

data/lib/legion/extensions/agentic/imagination/aurora/helpers/aurora_engine.rb

@@ -0,0 +1,123 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module Agentic
+      module Imagination
+        module Aurora
+          module Helpers
+            class AuroraEngine
+              include Constants
+
+              def initialize
+                @events = []
+                @spectral_bands = {}
+              end
+
+              def detect_aurora(type:, domain:, contributing_subsystems:, luminosity:, harmony_score:)
+                event = AuroraEvent.new(
+                  aurora_type:             type,
+                  domain:                  domain,
+                  contributing_subsystems: contributing_subsystems,
+                  luminosity:              luminosity,
+                  harmony_score:           harmony_score
+                )
+
+                prune_events if @events.size >= MAX_EVENTS
+
+                @events << event
+                register_in_band(event)
+                event
+              end
+
+              def fade_all!
+                @events.each(&:fade!)
+              end
+
+              def brilliant_events
+                @events.select(&:brilliant?)
+              end
+
+              def harmonious_events
+                @events.select(&:harmonious?)
+              end
+
+              def events_by_domain(domain)
+                @events.select { |e| e.domain == domain.to_sym }
+              end
+
+              def events_by_type(type)
+                @events.select { |e| e.aurora_type == type.to_sym }
+              end
+
+              def spectral_distribution
+                AURORA_TYPES.each_with_object({}) do |type, dist|
+                  band = @spectral_bands[type]
+                  dist[type] = band ? band.intensity : 0.0
+                end
+              end
+
+              def overall_luminosity
+                return 0.0 if @events.empty?
+
+                total = @events.sum(&:luminosity).round(10)
+                (total / @events.size).round(10)
+              end
+
+              def overall_harmony
+                return 0.0 if @events.empty?
+
+                total = @events.sum(&:harmony_score).round(10)
+                (total / @events.size).round(10)
+              end
+
+              def aurora_frequency
+                @events.size
+              end
+
+              def most_brilliant(limit: 5)
+                @events.sort_by { |e| -e.luminosity }.first(limit)
+              end
+
+              def active_bands
+                @spectral_bands.values.select(&:active?)
+              end
+
+              def aurora_report
+                {
+                  total_events:          @events.size,
+                  overall_luminosity:    overall_luminosity,
+                  overall_harmony:       overall_harmony,
+                  brilliant_count:       brilliant_events.size,
+                  harmonious_count:      harmonious_events.size,
+                  active_band_count:     active_bands.size,
+                  spectral_distribution: spectral_distribution,
+                  luminosity_label:      Constants.label_for(overall_luminosity, LUMINOSITY_LABELS),
+                  harmony_label:         Constants.label_for(overall_harmony, HARMONY_LABELS)
+                }
+              end
+
+              def events
+                @events.dup
+              end
+
+              private
+
+              def register_in_band(event)
+                type = event.aurora_type
+                @spectral_bands[type] ||= SpectralBand.new(aurora_type: type)
+                @spectral_bands[type].add_event(event)
+              end
+
+              def prune_events
+                faint = @events.select(&:faint?)
+                to_remove = faint.size.positive? ? faint : [@events.first]
+                to_remove.each { |e| @events.delete(e) }
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/legion/extensions/agentic/imagination/aurora/helpers/aurora_event.rb

@@ -0,0 +1,85 @@
+# frozen_string_literal: true
+
+require 'securerandom'
+require 'time'
+
+module Legion
+  module Extensions
+    module Agentic
+      module Imagination
+        module Aurora
+          module Helpers
+            class AuroraEvent
+              include Constants
+
+              attr_reader :id, :aurora_type, :domain, :contributing_subsystems, :harmony_score, :created_at
+              attr_accessor :luminosity
+
+              def initialize(aurora_type:, domain:, contributing_subsystems:, luminosity:, harmony_score:)
+                @id                     = SecureRandom.uuid
+                @aurora_type            = aurora_type
+                @domain                 = domain
+                @contributing_subsystems = Array(contributing_subsystems).map(&:to_sym)
+                @luminosity             = luminosity.clamp(0.0, 1.0)
+                @harmony_score          = harmony_score.clamp(0.0, 1.0)
+                @created_at             = Time.now.utc
+              end
+
+              def fade!
+                @luminosity = (@luminosity - LUMINOSITY_DECAY).round(10).clamp(0.0, 1.0)
+              end
+
+              def brilliant?
+                @luminosity > BRILLIANCE_THRESHOLD
+              end
+
+              def faint?
+                @luminosity < FAINT_THRESHOLD
+              end
+
+              def harmonious?
+                @harmony_score > HARMONY_THRESHOLD
+              end
+
+              def multi_source?
+                @contributing_subsystems.size > 2
+              end
+
+              def spectral_color
+                index = (@luminosity * (SPECTRAL_COLORS.size - 1)).round
+                SPECTRAL_COLORS[index.clamp(0, SPECTRAL_COLORS.size - 1)]
+              end
+
+              def luminosity_label
+                Constants.label_for(@luminosity, LUMINOSITY_LABELS)
+              end
+
+              def harmony_label
+                Constants.label_for(@harmony_score, HARMONY_LABELS)
+              end
+
+              def to_h
+                {
+                  id:                      @id,
+                  aurora_type:             @aurora_type,
+                  domain:                  @domain,
+                  contributing_subsystems: @contributing_subsystems,
+                  luminosity:              @luminosity,
+                  harmony_score:           @harmony_score,
+                  spectral_color:          spectral_color,
+                  luminosity_label:        luminosity_label,
+                  harmony_label:           harmony_label,
+                  brilliant:               brilliant?,
+                  faint:                   faint?,
+                  harmonious:              harmonious?,
+                  multi_source:            multi_source?,
+                  created_at:              @created_at.iso8601
+                }
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/legion/extensions/agentic/imagination/aurora/helpers/constants.rb

@@ -0,0 +1,91 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module Agentic
+      module Imagination
+        module Aurora
+          module Helpers
+            module Constants
+              MAX_EVENTS  = 300
+              MAX_BANDS   = 50
+
+              DEFAULT_LUMINOSITY = 0.5
+              LUMINOSITY_DECAY   = 0.03
+              LUMINOSITY_BOOST   = 0.1
+
+              HARMONY_THRESHOLD = 0.7
+              BRILLIANCE_THRESHOLD = 0.8
+              FAINT_THRESHOLD = 0.2
+
+              AURORA_TYPES = %i[
+                harmonic
+                resonant
+                cascading
+                convergent
+                emergent
+                serendipitous
+                synchronous
+                prismatic
+              ].freeze
+
+              SPECTRAL_COLORS = %i[
+                violet
+                indigo
+                blue
+                green
+                yellow
+                orange
+                red
+                ultraviolet
+              ].freeze
+
+              DOMAINS = %i[
+                memory
+                emotion
+                prediction
+                identity
+                trust
+                consent
+                governance
+                perception
+              ].freeze
+
+              LUMINOSITY_LABELS = {
+                (0.0...0.2) => :faint,
+                (0.2...0.4) => :dim,
+                (0.4...0.6) => :moderate,
+                (0.6...0.8) => :bright,
+                (0.8..1.0)  => :brilliant
+              }.freeze
+
+              HARMONY_LABELS = {
+                (0.0...0.3) => :discordant,
+                (0.3...0.5) => :unsettled,
+                (0.5...0.7) => :resonating,
+                (0.7...0.9) => :harmonious,
+                (0.9..1.0)  => :perfect
+              }.freeze
+
+              BRILLIANCE_LABELS = {
+                (0.0...0.25) => :nascent,
+                (0.25...0.5) => :emerging,
+                (0.5...0.75) => :radiant,
+                (0.75..1.0)  => :transcendent
+              }.freeze
+
+              module_function
+
+              def label_for(value, label_map)
+                label_map.each do |range, label|
+                  return label if range.cover?(value)
+                end
+                label_map.values.last
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/legion/extensions/agentic/imagination/aurora/helpers/spectral_band.rb

@@ -0,0 +1,79 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module Agentic
+      module Imagination
+        module Aurora
+          module Helpers
+            class SpectralBand
+              include Constants
+
+              attr_reader :id, :aurora_type, :events
+
+              def initialize(aurora_type:)
+                @id          = SecureRandom.uuid
+                @aurora_type = aurora_type
+                @events      = []
+              end
+
+              def add_event(event)
+                @events << event
+              end
+
+              def intensity
+                return 0.0 if @events.empty?
+
+                total = @events.sum(&:luminosity).round(10)
+                (total / @events.size).round(10)
+              end
+
+              def average_harmony
+                return 0.0 if @events.empty?
+
+                total = @events.sum(&:harmony_score).round(10)
+                (total / @events.size).round(10)
+              end
+
+              def dominant_color
+                return SPECTRAL_COLORS.first if @events.empty?
+
+                color_counts = Hash.new(0)
+                @events.each { |e| color_counts[e.spectral_color] += 1 }
+                color_counts.max_by { |_, count| count }&.first || SPECTRAL_COLORS.first
+              end
+
+              def active?
+                @events.any? { |e| !e.faint? }
+              end
+
+              def bandwidth
+                return (0.0..0.0) if @events.empty?
+
+                luminosities = @events.map(&:luminosity)
+                (luminosities.min..luminosities.max)
+              end
+
+              def event_count
+                @events.size
+              end
+
+              def to_h
+                {
+                  id:              @id,
+                  aurora_type:     @aurora_type,
+                  event_count:     event_count,
+                  intensity:       intensity,
+                  average_harmony: average_harmony,
+                  dominant_color:  dominant_color,
+                  active:          active?,
+                  bandwidth:       { min: bandwidth.min, max: bandwidth.max }
+                }
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/legion/extensions/agentic/imagination/aurora/runners/cognitive_aurora.rb

@@ -0,0 +1,84 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module Agentic
+      module Imagination
+        module Aurora
+          module Runners
+            module CognitiveAurora
+              include Legion::Extensions::Helpers::Lex if Legion::Extensions.const_defined?(:Helpers) &&
+                                                          Legion::Extensions::Helpers.const_defined?(:Lex)
+
+              def detect_aurora(type: :emergent, domain: :perception, contributing_subsystems: [],
+                                luminosity: Helpers::Constants::DEFAULT_LUMINOSITY,
+                                harmony_score: 0.5, engine: nil, **)
+                target_engine = engine || default_engine
+                event = target_engine.detect_aurora(
+                  type:                    type,
+                  domain:                  domain,
+                  contributing_subsystems: contributing_subsystems,
+                  luminosity:              luminosity,
+                  harmony_score:           harmony_score
+                )
+
+                Legion::Logging.debug "[cognitive_aurora] detected aurora: type=#{type} domain=#{domain} " \
+                                      "luminosity=#{luminosity.round(2)} harmony=#{harmony_score.round(2)} " \
+                                      "id=#{event.id}"
+
+                { success: true, event: event.to_h }
+              rescue StandardError => e
+                Legion::Logging.error "[cognitive_aurora] detect_aurora failed: #{e.message}"
+                { success: false, error: e.message }
+              end
+
+              def fade_all(engine: nil, **)
+                target_engine = engine || default_engine
+                before_count = target_engine.brilliant_events.size
+                target_engine.fade_all!
+                after_count = target_engine.brilliant_events.size
+
+                Legion::Logging.debug "[cognitive_aurora] fade_all: brilliant #{before_count} -> #{after_count}"
+                { success: true, faded: true, brilliant_before: before_count, brilliant_after: after_count }
+              rescue StandardError => e
+                Legion::Logging.error "[cognitive_aurora] fade_all failed: #{e.message}"
+                { success: false, error: e.message }
+              end
+
+              def list_brilliant(limit: 10, engine: nil, **)
+                target_engine = engine || default_engine
+                events = target_engine.brilliant_events.sort_by { |e| -e.luminosity }.first(limit)
+
+                Legion::Logging.debug "[cognitive_aurora] list_brilliant: found #{events.size} brilliant events (limit=#{limit})"
+                { success: true, events: events.map(&:to_h), count: events.size }
+              rescue StandardError => e
+                Legion::Logging.error "[cognitive_aurora] list_brilliant failed: #{e.message}"
+                { success: false, error: e.message }
+              end
+
+              def aurora_status(engine: nil, **)
+                target_engine = engine || default_engine
+                report = target_engine.aurora_report
+
+                Legion::Logging.debug "[cognitive_aurora] status: total=#{report[:total_events]} " \
+                                      "luminosity=#{report[:overall_luminosity].round(2)} " \
+                                      "harmony=#{report[:overall_harmony].round(2)}"
+
+                { success: true, report: report }
+              rescue StandardError => e
+                Legion::Logging.error "[cognitive_aurora] aurora_status failed: #{e.message}"
+                { success: false, error: e.message }
+              end
+
+              private
+
+              def default_engine
+                @default_engine ||= Helpers::AuroraEngine.new
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/legion/extensions/agentic/imagination/aurora/version.rb

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

data/lib/legion/extensions/agentic/imagination/aurora.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+require 'securerandom'
+
+require 'legion/extensions/agentic/imagination/aurora/version'
+require 'legion/extensions/agentic/imagination/aurora/helpers/constants'
+require 'legion/extensions/agentic/imagination/aurora/helpers/aurora_event'
+require 'legion/extensions/agentic/imagination/aurora/helpers/spectral_band'
+require 'legion/extensions/agentic/imagination/aurora/helpers/aurora_engine'
+require 'legion/extensions/agentic/imagination/aurora/runners/cognitive_aurora'
+require 'legion/extensions/agentic/imagination/aurora/client'
+
+module Legion
+  module Extensions
+    module Agentic
+      module Imagination
+        module Aurora
+        end
+      end
+    end
+  end
+end

data/lib/legion/extensions/agentic/imagination/constellation/client.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module Agentic
+      module Imagination
+        module Constellation
+          class Client
+            include Runners::CognitiveConstellation
+          end
+        end
+      end
+    end
+  end
+end

data/lib/legion/extensions/agentic/imagination/constellation/helpers/constants.rb

@@ -0,0 +1,59 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module Agentic
+      module Imagination
+        module Constellation
+          module Helpers
+            module Constants
+              # Star spectral classes (hottest to coolest)
+              SPECTRAL_CLASSES = %i[O B A F G K M].freeze
+
+              # Constellation pattern types
+              PATTERN_TYPES = %i[
+                linear circular spiral cluster
+                cross arc ring scattered
+              ].freeze
+
+              # Star domains
+              DOMAINS = %i[
+                reasoning memory emotion language
+                perception action planning social
+                creativity logic intuition ethics
+              ].freeze
+
+              MAX_STARS          = 500
+              MAX_CONSTELLATIONS = 50
+              MAGNITUDE_DECAY    = 0.01
+              MIN_MAGNITUDE      = 0.05
+
+              # Magnitude labels (higher = brighter = more important)
+              MAGNITUDE_LABELS = [
+                [(0.8..),      :supergiant],
+                [(0.6...0.8),  :giant],
+                [(0.4...0.6),  :main_sequence],
+                [(0.2...0.4),  :dwarf],
+                [(..0.2),      :brown_dwarf]
+              ].freeze
+
+              # Constellation maturity labels
+              MATURITY_LABELS = [
+                [(0.8..),      :ancient],
+                [(0.6...0.8),  :established],
+                [(0.4...0.6),  :forming],
+                [(0.2...0.4),  :nascent],
+                [(..0.2),      :proto]
+              ].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/imagination/constellation/helpers/constellation.rb

@@ -0,0 +1,90 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module Agentic
+      module Imagination
+        module Constellation
+          module Helpers
+            class Constellation
+              attr_reader :id, :name, :pattern_type, :star_ids,
+                          :formed_at
+              attr_accessor :maturity
+
+              def initialize(name:, pattern_type:, maturity: nil)
+                validate_pattern!(pattern_type)
+                @id           = SecureRandom.uuid
+                @name         = name.to_s
+                @pattern_type = pattern_type.to_sym
+                @star_ids     = []
+                @maturity     = (maturity || 0.1).to_f.clamp(0.0, 1.0).round(10)
+                @formed_at    = Time.now.utc
+              end
+
+              def add_star(star_id)
+                return false if @star_ids.include?(star_id)
+
+                @star_ids << star_id
+                @maturity = (@maturity + 0.05).clamp(0.0, 1.0).round(10)
+                true
+              end
+
+              def remove_star(star_id)
+                return false unless @star_ids.include?(star_id)
+
+                @star_ids.delete(star_id)
+                @maturity = (@maturity - 0.05).clamp(0.0, 1.0).round(10)
+                true
+              end
+
+              def size
+                @star_ids.size
+              end
+
+              def empty?
+                @star_ids.empty?
+              end
+
+              def ancient?
+                @maturity >= 0.8
+              end
+
+              def nascent?
+                @maturity < 0.2
+              end
+
+              def maturity_label
+                Constants.label_for(Constants::MATURITY_LABELS, @maturity)
+              end
+
+              def to_h
+                {
+                  id:             @id,
+                  name:           @name,
+                  pattern_type:   @pattern_type,
+                  star_ids:       @star_ids.dup,
+                  size:           size,
+                  maturity:       @maturity,
+                  maturity_label: maturity_label,
+                  formed_at:      @formed_at,
+                  ancient:        ancient?,
+                  nascent:        nascent?
+                }
+              end
+
+              private
+
+              def validate_pattern!(val)
+                return if Constants::PATTERN_TYPES.include?(val.to_sym)
+
+                raise ArgumentError,
+                      "unknown pattern type: #{val.inspect}; " \
+                      "must be one of #{Constants::PATTERN_TYPES.inspect}"
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end