lex-agentic-language 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 664d19699b188ee30a787c5c5e24211c920e81492f03da70ed7a8d0a0359a5ad
+  data.tar.gz: 437b2eb7099d2bfeeeb8d3ed027f6f4a4fdc14f867944688b602bfd5c31dd9f3
+SHA512:
+  metadata.gz: '043782a4236c9b1a204170f7e06614dde8eaac0633efb623333c4b3f0b09de34d6ad4393db898f984bc1d40ccd59cf54463cb6c377bda76b06be3855b85fda94'
+  data.tar.gz: de3e90307844b393b1eb991df41ad8fe29eeb46297f2df29f8e41281f52df10d0c15d7ce32477356276d6fce30c54bfb4618330357ccd92ccbae4347116c3db2

data/CHANGELOG.md

@@ -0,0 +1,6 @@
+# Changelog
+
+## [0.1.0] - 2026-03-17
+
+### Added
+- Initial domain gem scaffold

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-language
+
+LEX agentic language domain: linguistic processing and communication
+
+## Sub-modules
+
+*(populated as extensions are consolidated)*
+
+## Installation
+
+```ruby
+gem 'lex-agentic-language'
+```

data/lex-agentic-language.gemspec

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+require_relative 'lib/legion/extensions/agentic/language/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = 'lex-agentic-language'
+  spec.version       = Legion::Extensions::Agentic::Language::VERSION
+  spec.authors       = ['Esity']
+  spec.email         = ['matthewdiverson@gmail.com']
+
+  spec.summary       = 'LEX Agentic Language'
+  spec.description   = 'LEX agentic language domain: linguistic processing and communication'
+  spec.homepage      = 'https://github.com/LegionIO/lex-agentic-language'
+  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-language.gemspec Gemfile LICENSE README.md CHANGELOG.md]
+  end
+  spec.require_paths = ['lib']
+
+  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/language/conceptual_blending/client.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+require 'legion/extensions/agentic/language/conceptual_blending/helpers/constants'
+require 'legion/extensions/agentic/language/conceptual_blending/helpers/mental_space'
+require 'legion/extensions/agentic/language/conceptual_blending/helpers/blend'
+require 'legion/extensions/agentic/language/conceptual_blending/helpers/blending_engine'
+require 'legion/extensions/agentic/language/conceptual_blending/runners/conceptual_blending'
+
+module Legion
+  module Extensions
+    module Agentic
+      module Language
+        module ConceptualBlending
+          class Client
+            include Runners::ConceptualBlending
+
+            def initialize(engine: nil)
+              @engine = engine || Helpers::BlendingEngine.new
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/legion/extensions/agentic/language/conceptual_blending/helpers/blend.rb

@@ -0,0 +1,91 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module Agentic
+      module Language
+        module ConceptualBlending
+          module Helpers
+            class Blend
+              include Constants
+
+              attr_reader :id, :input_space_ids, :generic_space, :blended_elements,
+                          :blend_type, :strength, :use_count, :created_at, :last_used_at
+
+              def initialize(input_space_ids:, generic_space:, blended_elements:, blend_type: :double_scope)
+                @id               = ::SecureRandom.uuid
+                @input_space_ids  = input_space_ids
+                @generic_space    = generic_space
+                @blended_elements = blended_elements
+                @blend_type       = blend_type
+                @strength         = DEFAULT_STRENGTH
+                @use_count        = 0
+                @created_at       = Time.now.utc
+                @last_used_at     = Time.now.utc
+              end
+
+              def use!
+                @use_count    += 1
+                @last_used_at  = Time.now.utc
+                self
+              end
+
+              def elaborate(emergent_property:)
+                @blended_elements[:emergent_properties] ||= []
+                @blended_elements[:emergent_properties] << emergent_property
+                @strength = (@strength + ELABORATION_BOOST).clamp(STRENGTH_FLOOR, STRENGTH_CEILING)
+                self
+              end
+
+              def compress(removed_element:)
+                @blended_elements[:merged_elements]&.delete(removed_element)
+                @strength = (@strength - COMPRESSION_PENALTY).clamp(STRENGTH_FLOOR, STRENGTH_CEILING)
+                self
+              end
+
+              def quality_score
+                element_count   = Array(@blended_elements[:merged_elements]).size
+                emergent_count  = Array(@blended_elements[:emergent_properties]).size
+                use_factor      = [@use_count / 10.0, 1.0].min
+
+                raw = ((element_count / 10.0) * 0.4) +
+                      ((emergent_count / 5.0) * 0.4) +
+                      (use_factor * 0.2)
+                raw.clamp(STRENGTH_FLOOR, STRENGTH_CEILING)
+              end
+
+              def quality_label
+                score = quality_score
+                QUALITY_LABELS.each do |range, label|
+                  return label if range.cover?(score)
+                end
+                :trivial
+              end
+
+              def stale?
+                (Time.now.utc - @last_used_at).to_i > STALE_THRESHOLD
+              end
+
+              def to_h
+                {
+                  id:               @id,
+                  input_space_ids:  @input_space_ids,
+                  generic_space:    @generic_space,
+                  blended_elements: @blended_elements,
+                  blend_type:       @blend_type,
+                  strength:         @strength,
+                  use_count:        @use_count,
+                  quality_score:    quality_score,
+                  quality_label:    quality_label,
+                  stale:            stale?,
+                  created_at:       @created_at,
+                  last_used_at:     @last_used_at
+                }
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/legion/extensions/agentic/language/conceptual_blending/helpers/blending_engine.rb

@@ -0,0 +1,171 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module Agentic
+      module Language
+        module ConceptualBlending
+          module Helpers
+            class BlendingEngine
+              include Constants
+
+              def initialize
+                @spaces  = {}
+                @blends  = {}
+              end
+
+              def create_space(name:, domain:)
+                raise ArgumentError, "Max spaces (#{MAX_SPACES}) reached" if @spaces.size >= MAX_SPACES
+
+                space = MentalSpace.new(name: name, domain: domain)
+                @spaces[space.id] = space
+                space
+              end
+
+              def add_element_to_space(space_id:, name:, properties: {})
+                space = @spaces.fetch(space_id) { raise ArgumentError, "Space #{space_id} not found" }
+                space.add_element(name: name, properties: properties)
+              end
+
+              def add_relation_to_space(space_id:, from:, to:, type:)
+                space = @spaces.fetch(space_id) { raise ArgumentError, "Space #{space_id} not found" }
+                space.add_relation(from: from, to: to, type: type)
+              end
+
+              def blend(space_a_id:, space_b_id:, blend_type: :double_scope)
+                raise ArgumentError, "Max blends (#{MAX_BLENDS}) reached" if @blends.size >= MAX_BLENDS
+
+                space_a = @spaces.fetch(space_a_id) { raise ArgumentError, "Space #{space_a_id} not found" }
+                space_b = @spaces.fetch(space_b_id) { raise ArgumentError, "Space #{space_b_id} not found" }
+
+                generic_space = extract_generic_space(space_a, space_b)
+                merged        = merge_elements(space_a, space_b)
+                emergent      = generate_emergent(space_a, space_b)
+
+                blended_elements = {
+                  merged_elements:     merged,
+                  emergent_properties: emergent
+                }
+
+                b = Blend.new(
+                  input_space_ids:  [space_a_id, space_b_id],
+                  generic_space:    generic_space,
+                  blended_elements: blended_elements,
+                  blend_type:       blend_type
+                )
+                @blends[b.id] = b
+                b
+              end
+
+              def elaborate_blend(blend_id:, emergent_property:)
+                blend = @blends.fetch(blend_id) { raise ArgumentError, "Blend #{blend_id} not found" }
+                blend.elaborate(emergent_property: emergent_property)
+              end
+
+              def compress_blend(blend_id:, removed_element:)
+                blend = @blends.fetch(blend_id) { raise ArgumentError, "Blend #{blend_id} not found" }
+                blend.compress(removed_element: removed_element)
+              end
+
+              def find_blends(domain:)
+                @blends.values.select do |b|
+                  b.input_space_ids.any? do |sid|
+                    @spaces[sid]&.domain == domain
+                  end
+                end
+              end
+
+              def best_blends(limit: 5)
+                @blends.values.sort_by { |b| -b.quality_score }.first(limit)
+              end
+
+              def blend_quality(blend_id:)
+                blend = @blends.fetch(blend_id) { raise ArgumentError, "Blend #{blend_id} not found" }
+                {
+                  blend_id:      blend_id,
+                  quality_score: blend.quality_score,
+                  quality_label: blend.quality_label,
+                  strength:      blend.strength,
+                  use_count:     blend.use_count,
+                  stale:         blend.stale?
+                }
+              end
+
+              def decay_stale
+                count = 0
+                @blends.each_value do |b|
+                  next unless b.stale?
+
+                  new_strength = (b.strength - DECAY_RATE).clamp(STRENGTH_FLOOR, STRENGTH_CEILING)
+                  b.instance_variable_set(:@strength, new_strength)
+                  count += 1
+                end
+                count
+              end
+
+              def prune_weak
+                before = @blends.size
+                @blends.delete_if { |_id, b| b.strength < 0.1 }
+                before - @blends.size
+              end
+
+              def to_h
+                {
+                  spaces_count: @spaces.size,
+                  blends_count: @blends.size,
+                  best_quality: @blends.values.map(&:quality_score).max || 0.0
+                }
+              end
+
+              private
+
+              def extract_generic_space(space_a, space_b)
+                types_a = space_a.relations.to_set { |r| r[:type] }
+                types_b = space_b.relations.to_set { |r| r[:type] }
+                shared_types = types_a & types_b
+
+                {
+                  shared_relation_types: shared_types.to_a,
+                  mapped_elements:       shared_element_mappings(space_a, space_b)
+                }
+              end
+
+              def shared_element_mappings(space_a, space_b)
+                names_a = space_a.element_names.to_set(&:to_s)
+                names_b = space_b.element_names.to_set(&:to_s)
+                (names_a & names_b).to_a
+              end
+
+              def merge_elements(space_a, space_b)
+                merged = {}
+                space_a.elements.each do |name, props|
+                  merged[name] = props.dup
+                end
+                space_b.elements.each do |name, props|
+                  merged[name] = if merged.key?(name)
+                                   merged[name].merge(props)
+                                 else
+                                   props.dup
+                                 end
+                end
+                merged.keys
+              end
+
+              def generate_emergent(space_a, space_b)
+                emergent = []
+                space_a.relations.each do |rel_a|
+                  space_b.relations.each do |rel_b|
+                    next if rel_a[:type] == rel_b[:type]
+
+                    emergent << "#{rel_a[:type]}_#{rel_b[:type]}_cross_domain"
+                  end
+                end
+                emergent.uniq.first(5)
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/legion/extensions/agentic/language/conceptual_blending/helpers/constants.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module Agentic
+      module Language
+        module ConceptualBlending
+          module Helpers
+            module Constants
+              MAX_SPACES      = 200
+              MAX_BLENDS      = 100
+              MAX_MAPPINGS    = 500
+              MAX_HISTORY     = 300
+              DEFAULT_STRENGTH    = 0.5
+              STRENGTH_FLOOR      = 0.0
+              STRENGTH_CEILING    = 1.0
+              ELABORATION_BOOST   = 0.15
+              COMPRESSION_PENALTY = 0.1
+              DECAY_RATE          = 0.02
+              STALE_THRESHOLD     = 120
+              BLEND_TYPES         = %i[simplex mirror single_scope double_scope].freeze
+              QUALITY_LABELS      = {
+                (0.8..)     => :excellent,
+                (0.6...0.8) => :good,
+                (0.4...0.6) => :fair,
+                (0.2...0.4) => :weak,
+                (..0.2)     => :trivial
+              }.freeze
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/legion/extensions/agentic/language/conceptual_blending/helpers/mental_space.rb

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module Agentic
+      module Language
+        module ConceptualBlending
+          module Helpers
+            class MentalSpace
+              attr_reader :id, :name, :domain, :elements, :relations, :created_at
+
+              def initialize(name:, domain:)
+                @id         = ::SecureRandom.uuid
+                @name       = name
+                @domain     = domain
+                @elements   = {}
+                @relations  = []
+                @created_at = Time.now.utc
+              end
+
+              def add_element(name:, properties: {})
+                @elements[name] = properties
+                self
+              end
+
+              def add_relation(from:, to:, type:)
+                @relations << { from: from, to: to, type: type }
+                self
+              end
+
+              def element_names
+                @elements.keys
+              end
+
+              def to_h
+                {
+                  id:         @id,
+                  name:       @name,
+                  domain:     @domain,
+                  elements:   @elements,
+                  relations:  @relations,
+                  created_at: @created_at
+                }
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/legion/extensions/agentic/language/conceptual_blending/runners/conceptual_blending.rb

@@ -0,0 +1,106 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module Agentic
+      module Language
+        module ConceptualBlending
+          module Runners
+            module ConceptualBlending
+              include Legion::Extensions::Helpers::Lex if Legion::Extensions.const_defined?(:Helpers) &&
+                                                          Legion::Extensions::Helpers.const_defined?(:Lex)
+
+              def create_mental_space(name:, domain:, **)
+                Legion::Logging.debug "[conceptual_blending] create_space: name=#{name} domain=#{domain}"
+                space = engine.create_space(name: name, domain: domain)
+                { success: true, space: space.to_h }
+              rescue ArgumentError => e
+                Legion::Logging.debug "[conceptual_blending] create_space failed: #{e.message}"
+                { success: false, error: e.message }
+              end
+
+              def add_space_element(space_id:, name:, properties: {}, **)
+                Legion::Logging.debug "[conceptual_blending] add_element: space=#{space_id} name=#{name}"
+                engine.add_element_to_space(space_id: space_id, name: name, properties: properties)
+                { success: true, space_id: space_id, element: name }
+              rescue ArgumentError => e
+                Legion::Logging.debug "[conceptual_blending] add_element failed: #{e.message}"
+                { success: false, error: e.message }
+              end
+
+              def add_space_relation(space_id:, from:, to:, type:, **)
+                Legion::Logging.debug "[conceptual_blending] add_relation: space=#{space_id} #{from}->#{to} type=#{type}"
+                engine.add_relation_to_space(space_id: space_id, from: from, to: to, type: type)
+                { success: true, space_id: space_id, relation: { from: from, to: to, type: type } }
+              rescue ArgumentError => e
+                Legion::Logging.debug "[conceptual_blending] add_relation failed: #{e.message}"
+                { success: false, error: e.message }
+              end
+
+              def create_blend(space_a_id:, space_b_id:, blend_type: :double_scope, **)
+                Legion::Logging.debug "[conceptual_blending] blend: a=#{space_a_id} b=#{space_b_id} type=#{blend_type}"
+                blend = engine.blend(space_a_id: space_a_id, space_b_id: space_b_id, blend_type: blend_type)
+                { success: true, blend: blend.to_h }
+              rescue ArgumentError => e
+                Legion::Logging.debug "[conceptual_blending] blend failed: #{e.message}"
+                { success: false, error: e.message }
+              end
+
+              def elaborate_blend(blend_id:, emergent_property:, **)
+                Legion::Logging.debug "[conceptual_blending] elaborate: blend=#{blend_id} property=#{emergent_property}"
+                blend = engine.elaborate_blend(blend_id: blend_id, emergent_property: emergent_property)
+                { success: true, blend: blend.to_h }
+              rescue ArgumentError => e
+                Legion::Logging.debug "[conceptual_blending] elaborate failed: #{e.message}"
+                { success: false, error: e.message }
+              end
+
+              def compress_blend(blend_id:, removed_element:, **)
+                Legion::Logging.debug "[conceptual_blending] compress: blend=#{blend_id} remove=#{removed_element}"
+                blend = engine.compress_blend(blend_id: blend_id, removed_element: removed_element)
+                { success: true, blend: blend.to_h }
+              rescue ArgumentError => e
+                Legion::Logging.debug "[conceptual_blending] compress failed: #{e.message}"
+                { success: false, error: e.message }
+              end
+
+              def best_blends(limit: 5, **)
+                Legion::Logging.debug "[conceptual_blending] best_blends: limit=#{limit}"
+                blends = engine.best_blends(limit: limit)
+                { success: true, blends: blends.map(&:to_h), count: blends.size }
+              end
+
+              def blend_quality(blend_id:, **)
+                Legion::Logging.debug "[conceptual_blending] blend_quality: blend=#{blend_id}"
+                quality = engine.blend_quality(blend_id: blend_id)
+                { success: true }.merge(quality)
+              rescue ArgumentError => e
+                Legion::Logging.debug "[conceptual_blending] blend_quality failed: #{e.message}"
+                { success: false, error: e.message }
+              end
+
+              def update_conceptual_blending(**)
+                Legion::Logging.debug '[conceptual_blending] update: decay + prune cycle'
+                decayed = engine.decay_stale
+                pruned  = engine.prune_weak
+                { success: true, decayed: decayed, pruned: pruned }
+              end
+
+              def conceptual_blending_stats(**)
+                Legion::Logging.debug '[conceptual_blending] stats'
+                stats = engine.to_h
+                { success: true }.merge(stats)
+              end
+
+              private
+
+              def engine
+                @engine ||= Helpers::BlendingEngine.new
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/legion/extensions/agentic/language/conceptual_blending/version.rb

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

data/lib/legion/extensions/agentic/language/conceptual_blending.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+require 'securerandom'
+require 'legion/extensions/agentic/language/conceptual_blending/version'
+require 'legion/extensions/agentic/language/conceptual_blending/helpers/constants'
+require 'legion/extensions/agentic/language/conceptual_blending/helpers/mental_space'
+require 'legion/extensions/agentic/language/conceptual_blending/helpers/blend'
+require 'legion/extensions/agentic/language/conceptual_blending/helpers/blending_engine'
+require 'legion/extensions/agentic/language/conceptual_blending/runners/conceptual_blending'
+
+module Legion
+  module Extensions
+    module Agentic
+      module Language
+        module ConceptualBlending
+        end
+      end
+    end
+  end
+end

data/lib/legion/extensions/agentic/language/conceptual_metaphor/client.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module Agentic
+      module Language
+        module ConceptualMetaphor
+          class Client
+            include Runners::ConceptualMetaphor
+
+            def initialize(engine: nil)
+              @engine = engine || Helpers::MetaphorEngine.new
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/legion/extensions/agentic/language/conceptual_metaphor/helpers/constants.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module Agentic
+      module Language
+        module ConceptualMetaphor
+          module Helpers
+            module Constants
+              MAX_METAPHORS = 200
+              MAX_MAPPINGS = 500
+              MAX_DOMAINS = 100
+              MAX_HISTORY = 300
+
+              DEFAULT_STRENGTH = 0.5
+              STRENGTH_FLOOR = 0.0
+              STRENGTH_CEILING = 1.0
+
+              REINFORCEMENT_BOOST = 0.1
+              DECAY_RATE = 0.02
+              STALE_THRESHOLD = 120
+
+              CONVENTIONALITY_THRESHOLD = 0.7
+              NOVELTY_THRESHOLD = 0.3
+
+              METAPHOR_TYPES = %i[structural orientational ontological].freeze
+
+              CONVENTIONALITY_LABELS = {
+                (0.8..)     => :dead,
+                (0.6...0.8) => :conventional,
+                (0.4...0.6) => :familiar,
+                (0.2...0.4) => :novel,
+                (..0.2)     => :creative
+              }.freeze
+
+              STRENGTH_LABELS = {
+                (0.8..)     => :dominant,
+                (0.6...0.8) => :strong,
+                (0.4...0.6) => :moderate,
+                (0.2...0.4) => :weak,
+                (..0.2)     => :fading
+              }.freeze
+            end
+          end
+        end
+      end
+    end
+  end
+end