lex-agentic-imagination 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 0b20e2342a0aa0fda9926d3c23410f918230481cb5add0095a098511e434756a
+  data.tar.gz: 0105f7cdf9636df8db506367dde12346db7aeb54699ef6e5c2e022c7d326e6ce
+SHA512:
+  metadata.gz: 9ae7d8d4b5acbfcaadadbee2b7620434ab4f0c097fe4c91918b6fecf9f9bd0318a4f7b4989f9f67612d4ec3e5750ace3a0dff232bd1c9a6c5c4af4ff2032bcd3
+  data.tar.gz: 8ecba0c2c73bb641c8adb60aec34491ccff21a9b32d02d6c55a80c7ed4ec16a964ad5984c4f0a7930fcf7a0b9f5073bd1cf76f2345ddedccf7c5685c439d3d9d

data/CHANGELOG.md

@@ -0,0 +1,12 @@
+# Changelog
+
+## [Unreleased]
+
+## [0.1.0] - 2026-03-18
+
+### Added
+- Initial release as domain consolidation gem
+- Consolidated source extensions into unified domain gem under `Legion::Extensions::Agentic::<Domain>`
+- All sub-modules loaded from single entry point
+- Full spec suite with zero failures
+- RuboCop compliance across all files

data/Gemfile

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+source 'https://rubygems.org'
+
+gemspec

data/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Matthew Iverson
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

data/README.md

@@ -0,0 +1,13 @@
+# lex-agentic-imagination
+
+LEX agentic imagination domain: mental simulation, creativity, prospection
+
+## Sub-modules
+
+*(populated as extensions are consolidated)*
+
+## Installation
+
+```ruby
+gem 'lex-agentic-imagination'
+```

data/lex-agentic-imagination.gemspec

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+require_relative 'lib/legion/extensions/agentic/imagination/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = 'lex-agentic-imagination'
+  spec.version       = Legion::Extensions::Agentic::Imagination::VERSION
+  spec.authors       = ['Esity']
+  spec.email         = ['matthewdiverson@gmail.com']
+
+  spec.summary       = 'LEX Agentic Imagination'
+  spec.description   = 'LEX agentic imagination domain: mental simulation, creativity, prospection'
+  spec.homepage      = 'https://github.com/LegionIO/lex-agentic-imagination'
+  spec.license       = 'MIT'
+  spec.required_ruby_version = '>= 3.4'
+
+  spec.metadata['homepage_uri']      = spec.homepage
+  spec.metadata['source_code_uri']   = spec.homepage
+  spec.metadata['changelog_uri']     = "#{spec.homepage}/blob/main/CHANGELOG.md"
+  spec.metadata['rubygems_mfa_required'] = 'true'
+
+  spec.files = Dir.chdir(__dir__) do
+    Dir.glob('{lib,spec}/**/*.rb') + %w[lex-agentic-imagination.gemspec Gemfile LICENSE README.md CHANGELOG.md]
+  end
+  spec.require_paths = ['lib']
+
+  spec.add_development_dependency 'lex-emotion'
+  spec.add_development_dependency 'lex-identity'
+  spec.add_development_dependency 'lex-memory'
+  spec.add_development_dependency 'lex-tick'
+  spec.add_development_dependency 'rspec', '~> 3.13'
+  spec.add_development_dependency 'rubocop', '~> 1.60'
+  spec.add_development_dependency 'rubocop-rspec', '~> 2.26'
+end

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

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

data/lib/legion/extensions/agentic/imagination/alchemy/helpers/alchemy_engine.rb

@@ -0,0 +1,140 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module Agentic
+      module Imagination
+        module Alchemy
+          module Helpers
+            class AlchemyEngine
+              def initialize
+                @substances = {}
+                @reactions  = {}
+              end
+
+              def create_substance(element_type:, domain:, content:, purity: nil, potency: nil)
+                raise ArgumentError, 'athanor full' if @substances.size >= Constants::MAX_SUBSTANCES
+
+                sub = Substance.new(element_type: element_type, domain: domain,
+                                    content: content, purity: purity, potency: potency)
+                @substances[sub.id] = sub
+                sub
+              end
+
+              def advance_stage(substance_id:)
+                fetch_substance(substance_id).advance_stage!
+              end
+
+              def catalyze(substance_id:, multiplier: Constants::CATALYST_MULTIPLIER)
+                fetch_substance(substance_id).catalyze!(multiplier: multiplier)
+              end
+
+              def react(reaction_type:, input_ids:, heat: 0.5, pressure: 0.5)
+                raise ArgumentError, 'too many reactions' if @reactions.size >= Constants::MAX_REACTIONS
+
+                inputs = input_ids.map { |id| fetch_substance(id) }
+                crucible = Crucible.new(reaction_type: reaction_type, input_ids: input_ids,
+                                        heat: heat, pressure: pressure)
+
+                output = synthesize(inputs, crucible)
+                @substances[output.id] = output
+                crucible.complete!(output.id)
+                @reactions[crucible.id] = crucible
+
+                { crucible: crucible, output: output }
+              end
+
+              def decay_all!(rate: Constants::SUBSTANCE_DECAY)
+                @substances.each_value { |s| s.decay!(rate: rate) }
+                pruned = @substances.select { |_, s| s.inert? }.keys
+                pruned.each { |id| @substances.delete(id) }
+                { decayed: @substances.size, pruned: pruned.size }
+              end
+
+              def substances_by_stage
+                counts = Constants::STAGES.to_h { |s| [s, 0] }
+                @substances.each_value { |s| counts[s.stage] += 1 }
+                counts
+              end
+
+              def substances_by_type
+                counts = Constants::ELEMENT_TYPES.to_h { |t| [t, 0] }
+                @substances.each_value { |s| counts[s.element_type] += 1 }
+                counts
+              end
+
+              def gold_count
+                @substances.count { |_, s| s.gold? }
+              end
+
+              def prima_materia_count
+                @substances.count { |_, s| s.prima_materia? }
+              end
+
+              def purest(limit: 5)
+                @substances.values.sort_by { |s| -s.purity }.first(limit)
+              end
+
+              def most_potent(limit: 5)
+                @substances.values.sort_by { |s| -s.potency }.first(limit)
+              end
+
+              def alchemy_report
+                {
+                  total_substances: @substances.size,
+                  total_reactions:  @reactions.size,
+                  by_stage:         substances_by_stage,
+                  by_type:          substances_by_type,
+                  gold_count:       gold_count,
+                  prima_materia:    prima_materia_count,
+                  avg_purity:       avg_metric(:purity),
+                  avg_potency:      avg_metric(:potency)
+                }
+              end
+
+              def all_substances
+                @substances.values
+              end
+
+              def all_reactions
+                @reactions.values
+              end
+
+              private
+
+              def fetch_substance(id)
+                @substances.fetch(id) do
+                  raise ArgumentError, "substance not found: #{id}"
+                end
+              end
+
+              def synthesize(inputs, crucible)
+                avg_purity  = inputs.sum(&:purity) / inputs.size
+                avg_potency = inputs.sum(&:potency) / inputs.size
+                boost       = crucible.intensity * Constants::TRANSMUTATION_RATE
+
+                create_substance(
+                  element_type: inputs.first.element_type,
+                  domain:       inputs.first.domain,
+                  content:      "synthesis(#{inputs.map(&:content).join(' + ')})",
+                  purity:       (avg_purity + boost).clamp(0.0, 1.0),
+                  potency:      (avg_potency + (boost * 0.5)).clamp(0.0, 1.0)
+                )
+              end
+
+              def avg_metric(attr)
+                return 0.0 if @substances.empty?
+
+                (substances_metric_sum(attr) / @substances.size).round(10)
+              end
+
+              def substances_metric_sum(attr)
+                @substances.values.sum(&attr)
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,76 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module Agentic
+      module Imagination
+        module Alchemy
+          module Helpers
+            module Constants
+              # Alchemical stages (Magnum Opus)
+              STAGES = %i[nigredo albedo citrinitas rubedo].freeze
+
+              # Transmutation element types
+              ELEMENT_TYPES = %i[
+                concept belief skill memory emotion
+                pattern habit intuition hypothesis
+              ].freeze
+
+              # Crucible reaction types
+              REACTION_TYPES = %i[
+                calcination dissolution separation conjunction
+                fermentation distillation coagulation
+              ].freeze
+
+              # Maximum substances in the athanor
+              MAX_SUBSTANCES = 200
+
+              # Maximum crucible reactions
+              MAX_REACTIONS = 100
+
+              # Base transmutation rate per stage advance
+              TRANSMUTATION_RATE = 0.15
+
+              # Decay rate for unreacted substances
+              SUBSTANCE_DECAY = 0.02
+
+              # Philosopher's stone catalyst multiplier
+              CATALYST_MULTIPLIER = 3.0
+
+              # Stage labels
+              STAGE_LABELS = {
+                nigredo:    'Blackening — decomposition of raw material',
+                albedo:     'Whitening — purification and washing',
+                citrinitas: 'Yellowing — solar awakening',
+                rubedo:     'Reddening — final integration and gold'
+              }.freeze
+
+              # Purity labels (range-based)
+              PURITY_LABELS = [
+                [(0.8..),      :aurum],
+                [(0.6...0.8),  :argentum],
+                [(0.4...0.6),  :cuprum],
+                [(0.2...0.4),  :ferrum],
+                [(..0.2),      :plumbum]
+              ].freeze
+
+              # Potency labels
+              POTENCY_LABELS = [
+                [(0.8..),      :transcendent],
+                [(0.6...0.8),  :potent],
+                [(0.4...0.6),  :moderate],
+                [(0.2...0.4),  :weak],
+                [(..0.2),      :inert]
+              ].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/alchemy/helpers/crucible.rb

@@ -0,0 +1,80 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module Agentic
+      module Imagination
+        module Alchemy
+          module Helpers
+            class Crucible
+              attr_reader :id, :reaction_type, :input_ids, :output_id,
+                          :heat, :pressure, :started_at, :completed_at
+
+              def initialize(reaction_type:, input_ids:,
+                             heat: 0.5, pressure: 0.5)
+                validate_reaction!(reaction_type)
+                @id            = SecureRandom.uuid
+                @reaction_type = reaction_type.to_sym
+                @input_ids     = Array(input_ids).dup
+                @output_id     = nil
+                @heat          = heat.to_f.clamp(0.0, 1.0).round(10)
+                @pressure      = pressure.to_f.clamp(0.0, 1.0).round(10)
+                @started_at    = Time.now.utc
+                @completed_at  = nil
+              end
+
+              def complete!(output_id)
+                @output_id    = output_id
+                @completed_at = Time.now.utc
+                self
+              end
+
+              def completed?
+                !@completed_at.nil?
+              end
+
+              def intensity
+                ((@heat + @pressure) / 2.0).round(10)
+              end
+
+              def volatile?
+                @heat > 0.8 && @pressure > 0.8
+              end
+
+              def mild?
+                intensity < 0.3
+              end
+
+              def to_h
+                {
+                  id:            @id,
+                  reaction_type: @reaction_type,
+                  input_ids:     @input_ids,
+                  output_id:     @output_id,
+                  heat:          @heat,
+                  pressure:      @pressure,
+                  intensity:     intensity,
+                  volatile:      volatile?,
+                  mild:          mild?,
+                  started_at:    @started_at,
+                  completed_at:  @completed_at,
+                  completed:     completed?
+                }
+              end
+
+              private
+
+              def validate_reaction!(val)
+                return if Constants::REACTION_TYPES.include?(val.to_sym)
+
+                raise ArgumentError,
+                      "unknown reaction type: #{val.inspect}; " \
+                      "must be one of #{Constants::REACTION_TYPES.inspect}"
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/legion/extensions/agentic/imagination/alchemy/helpers/substance.rb

@@ -0,0 +1,118 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module Agentic
+      module Imagination
+        module Alchemy
+          module Helpers
+            class Substance
+              attr_reader :id, :element_type, :domain, :content,
+                          :stage, :discovered_at, :transmutation_count
+              attr_accessor :purity, :potency
+
+              def initialize(element_type:, domain:, content:,
+                             purity: nil, potency: nil)
+                validate_type!(element_type)
+                assign_core(element_type, domain, content)
+                assign_metadata(purity, potency)
+              end
+
+              def advance_stage!
+                idx = Constants::STAGES.index(@stage)
+                return self if idx >= Constants::STAGES.size - 1
+
+                @stage = Constants::STAGES[idx + 1]
+                @purity = (@purity + Constants::TRANSMUTATION_RATE).clamp(0.0, 1.0).round(10)
+                @transmutation_count += 1
+                self
+              end
+
+              def decay!(rate: Constants::SUBSTANCE_DECAY)
+                @potency = (@potency - rate.abs).clamp(0.0, 1.0).round(10)
+                self
+              end
+
+              def catalyze!(multiplier: Constants::CATALYST_MULTIPLIER)
+                boost = Constants::TRANSMUTATION_RATE * multiplier
+                @purity = (@purity + boost).clamp(0.0, 1.0).round(10)
+                @potency = (@potency + (boost * 0.5)).clamp(0.0, 1.0).round(10)
+                @transmutation_count += 1
+                self
+              end
+
+              def prima_materia?
+                @stage == :nigredo && @purity < 0.2
+              end
+
+              def gold?
+                @stage == :rubedo && @purity >= 0.8
+              end
+
+              def inert?
+                @potency < 0.1
+              end
+
+              def purity_label
+                Constants.label_for(Constants::PURITY_LABELS, @purity)
+              end
+
+              def potency_label
+                Constants.label_for(Constants::POTENCY_LABELS, @potency)
+              end
+
+              def stage_label
+                Constants::STAGE_LABELS.fetch(@stage, 'unknown')
+              end
+
+              def to_h
+                {
+                  id:                  @id,
+                  element_type:        @element_type,
+                  domain:              @domain,
+                  content:             @content,
+                  stage:               @stage,
+                  stage_label:         stage_label,
+                  purity:              @purity,
+                  purity_label:        purity_label,
+                  potency:             @potency,
+                  potency_label:       potency_label,
+                  transmutation_count: @transmutation_count,
+                  discovered_at:       @discovered_at,
+                  prima_materia:       prima_materia?,
+                  gold:                gold?,
+                  inert:               inert?
+                }
+              end
+
+              private
+
+              def assign_core(element_type, domain, content)
+                @id           = SecureRandom.uuid
+                @element_type = element_type.to_sym
+                @domain       = domain.to_sym
+                @content      = content.to_s
+              end
+
+              def assign_metadata(purity, potency)
+                @stage               = :nigredo
+                @purity              = (purity || 0.1).to_f.clamp(0.0, 1.0).round(10)
+                @potency             = (potency || 0.5).to_f.clamp(0.0, 1.0).round(10)
+                @transmutation_count = 0
+                @discovered_at       = Time.now.utc
+              end
+
+              def validate_type!(val)
+                return if Constants::ELEMENT_TYPES.include?(val.to_sym)
+
+                raise ArgumentError,
+                      "unknown element type: #{val.inspect}; " \
+                      "must be one of #{Constants::ELEMENT_TYPES.inspect}"
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/legion/extensions/agentic/imagination/alchemy/runners/cognitive_alchemy.rb

@@ -0,0 +1,88 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module Agentic
+      module Imagination
+        module Alchemy
+          module Runners
+            module CognitiveAlchemy
+              extend self
+
+              def create_substance(element_type:, domain:, content:,
+                                   purity: nil, potency: nil, engine: nil, **)
+                eng = resolve_engine(engine)
+                sub = eng.create_substance(element_type: element_type, domain: domain,
+                                           content: content, purity: purity, potency: potency)
+                { success: true, substance: sub.to_h }
+              rescue ArgumentError => e
+                { success: false, error: e.message }
+              end
+
+              def advance_stage(substance_id:, engine: nil, **)
+                eng = resolve_engine(engine)
+                sub = eng.advance_stage(substance_id: substance_id)
+                { success: true, substance: sub.to_h }
+              rescue ArgumentError => e
+                { success: false, error: e.message }
+              end
+
+              def catalyze(substance_id:, multiplier: nil, engine: nil, **)
+                eng  = resolve_engine(engine)
+                opts = { substance_id: substance_id }
+                opts[:multiplier] = multiplier if multiplier
+                sub = eng.catalyze(**opts)
+                { success: true, substance: sub.to_h }
+              rescue ArgumentError => e
+                { success: false, error: e.message }
+              end
+
+              def react(reaction_type:, input_ids:, heat: 0.5,
+                        pressure: 0.5, engine: nil, **)
+                eng    = resolve_engine(engine)
+                result = eng.react(reaction_type: reaction_type, input_ids: input_ids,
+                                   heat: heat, pressure: pressure)
+                { success: true, crucible: result[:crucible].to_h,
+                  output: result[:output].to_h }
+              rescue ArgumentError => e
+                { success: false, error: e.message }
+              end
+
+              def list_substances(engine: nil, stage: nil, element_type: nil, **)
+                eng     = resolve_engine(engine)
+                results = filter_substances(eng.all_substances,
+                                            stage: stage, element_type: element_type)
+                { success: true, substances: results.map(&:to_h),
+                  count: results.size }
+              end
+
+              def alchemy_status(engine: nil, **)
+                eng = resolve_engine(engine)
+                { success: true, report: eng.alchemy_report }
+              end
+
+              include Legion::Extensions::Helpers::Lex if defined?(Legion::Extensions::Helpers::Lex)
+
+              private
+
+              def filter_substances(substances, stage:, element_type:)
+                r = substances
+                r = r.select { |s| s.stage == stage.to_sym } if stage
+                r = r.select { |s| s.element_type == element_type.to_sym } if element_type
+                r
+              end
+
+              def resolve_engine(engine)
+                engine || default_engine
+              end
+
+              def default_engine
+                @default_engine ||= Helpers::AlchemyEngine.new
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

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

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

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+require 'securerandom'
+
+require_relative 'alchemy/version'
+require_relative 'alchemy/helpers/constants'
+require_relative 'alchemy/helpers/substance'
+require_relative 'alchemy/helpers/crucible'
+require_relative 'alchemy/helpers/alchemy_engine'
+require_relative 'alchemy/runners/cognitive_alchemy'
+require_relative 'alchemy/client'
+
+module Legion
+  module Extensions
+    module Agentic
+      module Imagination
+        module Alchemy
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+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'
+
+module Legion
+  module Extensions
+    module Agentic
+      module Imagination
+        module Aurora
+          class Client
+            include Runners::CognitiveAurora
+
+            def initialize(**)
+              @default_engine = Helpers::AuroraEngine.new
+            end
+          end
+        end
+      end
+    end
+  end
+end