lex-agentic-integration 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 7932995a4925fd067cb3f9c308ef3c3d78f3b1b231d62b15c4e9fc5963a970ec
+  data.tar.gz: 78a023175248ee9054ca4fbaa56c95de34b49915a64818f97b713cf914fbfc77
+SHA512:
+  metadata.gz: c346f01d4ede05e6e4ceab65e58807bbba6387c0b506485fdfa276a47b28db309e6dcf2f6cafd9a5a005efe2b37c64f1bd5070ed53a7407bdb79b4fec125ee64
+  data.tar.gz: ab2124216a9a6d73473ef334853efc82a9873e6747bff7a16f8e5312b07addd905897c88a8bfddc567057c163c4d38c1ff7b823c259f4b05b9d11fe9850c6cdc

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-integration
+
+LEX agentic integration domain: cross-domain binding and synthesis
+
+## Sub-modules
+
+*(populated as extensions are consolidated)*
+
+## Installation
+
+```ruby
+gem 'lex-agentic-integration'
+```

data/lex-agentic-integration.gemspec

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+require_relative 'lib/legion/extensions/agentic/integration/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = 'lex-agentic-integration'
+  spec.version       = Legion::Extensions::Agentic::Integration::VERSION
+  spec.authors       = ['Esity']
+  spec.email         = ['matthewdiverson@gmail.com']
+
+  spec.summary       = 'LEX Agentic Integration'
+  spec.description   = 'LEX agentic integration domain: cross-domain binding and synthesis'
+  spec.homepage      = 'https://github.com/LegionIO/lex-agentic-integration'
+  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-integration.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/integration/boundary/client.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module Agentic
+      module Integration
+        module Boundary
+          class Client
+            include Runners::CognitiveBoundary
+          end
+        end
+      end
+    end
+  end
+end

data/lib/legion/extensions/agentic/integration/boundary/helpers/boundary.rb

@@ -0,0 +1,90 @@
+# frozen_string_literal: true
+
+require 'securerandom'
+
+module Legion
+  module Extensions
+    module Agentic
+      module Integration
+        module Boundary
+          module Helpers
+            class Boundary
+              include Constants
+
+              attr_reader :id, :name, :boundary_type, :permeability, :violations,
+                          :created_at
+
+              def initialize(name:, boundary_type: :cognitive, permeability: DEFAULT_PERMEABILITY)
+                @id           = SecureRandom.uuid
+                @name         = name
+                @boundary_type = boundary_type.to_sym
+                @permeability = permeability.to_f.clamp(0.0, 1.0)
+                @violations   = 0
+                @created_at   = Time.now.utc
+              end
+
+              def integrity
+                base = 1.0 - (@violations * 0.05)
+                [base, 0.0].max.round(10)
+              end
+
+              def integrity_label
+                match = INTEGRITY_LABELS.find { |range, _| range.cover?(integrity) }
+                match ? match.last : :breached
+              end
+
+              def permeability_label
+                match = PERMEABILITY_LABELS.find { |range, _| range.cover?(@permeability) }
+                match ? match.last : :sealed
+              end
+
+              def breached?
+                @permeability >= BREACH_THRESHOLD || integrity < 0.2
+              end
+
+              def open!(amount: PERMEABILITY_BOOST)
+                @permeability = (@permeability + amount).clamp(0.0, 1.0).round(10)
+                self
+              end
+
+              def close!(amount: PERMEABILITY_BOOST)
+                @permeability = (@permeability - amount).clamp(0.0, 1.0).round(10)
+                self
+              end
+
+              def violate!
+                @violations += 1
+                self
+              end
+
+              def repair!
+                @violations = [(@violations - 1), 0].max
+                self
+              end
+
+              def seal!
+                @permeability = 0.0
+                self
+              end
+
+              def to_h
+                {
+                  id:                 @id,
+                  name:               @name,
+                  boundary_type:      @boundary_type,
+                  permeability:       @permeability,
+                  permeability_label: permeability_label,
+                  integrity:          integrity,
+                  integrity_label:    integrity_label,
+                  breached:           breached?,
+                  violations:         @violations,
+                  created_at:         @created_at
+                }
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/legion/extensions/agentic/integration/boundary/helpers/boundary_engine.rb

@@ -0,0 +1,123 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module Agentic
+      module Integration
+        module Boundary
+          module Helpers
+            class BoundaryEngine
+              include Constants
+
+              def initialize
+                @boundaries = {}
+              end
+
+              def create_boundary(name:, boundary_type: :cognitive,
+                                  permeability: DEFAULT_PERMEABILITY)
+                prune_if_needed
+                boundary = Boundary.new(
+                  name:          name,
+                  boundary_type: boundary_type,
+                  permeability:  permeability
+                )
+                @boundaries[boundary.id] = boundary
+                boundary
+              end
+
+              def open_boundary(boundary_id:, amount: PERMEABILITY_BOOST)
+                boundary = @boundaries[boundary_id]
+                return nil unless boundary
+
+                boundary.open!(amount: amount)
+              end
+
+              def close_boundary(boundary_id:, amount: PERMEABILITY_BOOST)
+                boundary = @boundaries[boundary_id]
+                return nil unless boundary
+
+                boundary.close!(amount: amount)
+              end
+
+              def violate_boundary(boundary_id:)
+                boundary = @boundaries[boundary_id]
+                return nil unless boundary
+
+                boundary.violate!
+              end
+
+              def repair_boundary(boundary_id:)
+                boundary = @boundaries[boundary_id]
+                return nil unless boundary
+
+                boundary.repair!
+              end
+
+              def seal_boundary(boundary_id:)
+                boundary = @boundaries[boundary_id]
+                return nil unless boundary
+
+                boundary.seal!
+              end
+
+              def breached_boundaries
+                @boundaries.values.select(&:breached?)
+              end
+
+              def boundaries_by_type(boundary_type:)
+                bt = boundary_type.to_sym
+                @boundaries.values.select { |b| b.boundary_type == bt }
+              end
+
+              def most_violated(limit: 5)
+                @boundaries.values.sort_by { |b| -b.violations }.first(limit)
+              end
+
+              def overall_integrity
+                return 1.0 if @boundaries.empty?
+
+                scores = @boundaries.values.map(&:integrity)
+                (scores.sum / scores.size).round(10)
+              end
+
+              def overall_permeability
+                return 0.5 if @boundaries.empty?
+
+                perms = @boundaries.values.map(&:permeability)
+                (perms.sum / perms.size).round(10)
+              end
+
+              def boundary_report
+                {
+                  total_boundaries:     @boundaries.size,
+                  breached_count:       breached_boundaries.size,
+                  overall_integrity:    overall_integrity,
+                  overall_permeability: overall_permeability,
+                  most_violated:        most_violated(limit: 3).map(&:to_h)
+                }
+              end
+
+              def to_h
+                {
+                  total_boundaries:     @boundaries.size,
+                  breached_count:       breached_boundaries.size,
+                  overall_integrity:    overall_integrity,
+                  overall_permeability: overall_permeability
+                }
+              end
+
+              private
+
+              def prune_if_needed
+                return if @boundaries.size < MAX_BOUNDARIES
+
+                least_violated = @boundaries.values.min_by(&:violations)
+                @boundaries.delete(least_violated.id) if least_violated
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/legion/extensions/agentic/integration/boundary/helpers/constants.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module Agentic
+      module Integration
+        module Boundary
+          module Helpers
+            module Constants
+              MAX_BOUNDARIES = 100
+              MAX_VIOLATIONS = 500
+
+              DEFAULT_PERMEABILITY = 0.5
+              PERMEABILITY_BOOST = 0.05
+              PERMEABILITY_DECAY = 0.03
+              BREACH_THRESHOLD = 0.8
+
+              PERMEABILITY_LABELS = {
+                (0.8..)     => :open,
+                (0.6...0.8) => :permeable,
+                (0.4...0.6) => :selective,
+                (0.2...0.4) => :guarded,
+                (..0.2)     => :sealed
+              }.freeze
+
+              INTEGRITY_LABELS = {
+                (0.8..)     => :intact,
+                (0.6...0.8) => :stable,
+                (0.4...0.6) => :stressed,
+                (0.2...0.4) => :compromised,
+                (..0.2)     => :breached
+              }.freeze
+
+              BOUNDARY_TYPES = %i[
+                cognitive emotional social informational
+                temporal authority privacy
+              ].freeze
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/legion/extensions/agentic/integration/boundary/runners/cognitive_boundary.rb

@@ -0,0 +1,100 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module Agentic
+      module Integration
+        module Boundary
+          module Runners
+            module CognitiveBoundary
+              include Helpers::Constants
+
+              include Legion::Extensions::Helpers::Lex if defined?(Legion::Extensions::Helpers::Lex)
+
+              def create_boundary(name:, engine: nil, boundary_type: :cognitive,
+                                  permeability: DEFAULT_PERMEABILITY, **)
+                eng = engine || default_engine
+                boundary = eng.create_boundary(name: name, boundary_type: boundary_type,
+                                               permeability: permeability)
+                { success: true, boundary: boundary.to_h }
+              end
+
+              def open_boundary(boundary_id:, engine: nil, amount: PERMEABILITY_BOOST, **)
+                eng = engine || default_engine
+                result = eng.open_boundary(boundary_id: boundary_id, amount: amount)
+                return { success: false, error: 'boundary not found' } unless result
+
+                { success: true, boundary: result.to_h }
+              end
+
+              def close_boundary(boundary_id:, engine: nil, amount: PERMEABILITY_BOOST, **)
+                eng = engine || default_engine
+                result = eng.close_boundary(boundary_id: boundary_id, amount: amount)
+                return { success: false, error: 'boundary not found' } unless result
+
+                { success: true, boundary: result.to_h }
+              end
+
+              def violate_boundary(boundary_id:, engine: nil, **)
+                eng = engine || default_engine
+                result = eng.violate_boundary(boundary_id: boundary_id)
+                return { success: false, error: 'boundary not found' } unless result
+
+                { success: true, boundary: result.to_h }
+              end
+
+              def repair_boundary(boundary_id:, engine: nil, **)
+                eng = engine || default_engine
+                result = eng.repair_boundary(boundary_id: boundary_id)
+                return { success: false, error: 'boundary not found' } unless result
+
+                { success: true, boundary: result.to_h }
+              end
+
+              def seal_boundary(boundary_id:, engine: nil, **)
+                eng = engine || default_engine
+                result = eng.seal_boundary(boundary_id: boundary_id)
+                return { success: false, error: 'boundary not found' } unless result
+
+                { success: true, boundary: result.to_h }
+              end
+
+              def breached_boundaries(engine: nil, **)
+                eng = engine || default_engine
+                breached = eng.breached_boundaries.map(&:to_h)
+                { success: true, breached: breached, count: breached.size }
+              end
+
+              def boundaries_by_type(boundary_type:, engine: nil, **)
+                eng = engine || default_engine
+                boundaries = eng.boundaries_by_type(boundary_type: boundary_type).map(&:to_h)
+                { success: true, boundaries: boundaries, count: boundaries.size }
+              end
+
+              def overall_integrity(engine: nil, **)
+                eng = engine || default_engine
+                { success: true, integrity: eng.overall_integrity }
+              end
+
+              def overall_permeability(engine: nil, **)
+                eng = engine || default_engine
+                { success: true, permeability: eng.overall_permeability }
+              end
+
+              def boundary_report(engine: nil, **)
+                eng = engine || default_engine
+                { success: true, report: eng.boundary_report }
+              end
+
+              private
+
+              def default_engine
+                @default_engine ||= Helpers::BoundaryEngine.new
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/legion/extensions/agentic/integration/boundary/version.rb

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

data/lib/legion/extensions/agentic/integration/boundary.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+require_relative 'boundary/version'
+require_relative 'boundary/helpers/constants'
+require_relative 'boundary/helpers/boundary'
+require_relative 'boundary/helpers/boundary_engine'
+require_relative 'boundary/runners/cognitive_boundary'
+require_relative 'boundary/client'
+
+module Legion
+  module Extensions
+    module Agentic
+      module Integration
+        module Boundary
+        end
+      end
+    end
+  end
+end

data/lib/legion/extensions/agentic/integration/context/client.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+require 'legion/extensions/agentic/integration/context/helpers/constants'
+require 'legion/extensions/agentic/integration/context/helpers/frame'
+require 'legion/extensions/agentic/integration/context/helpers/context_manager'
+require 'legion/extensions/agentic/integration/context/runners/context'
+
+module Legion
+  module Extensions
+    module Agentic
+      module Integration
+        module Context
+          class Client
+            include Runners::Context
+
+            attr_reader :context_manager
+
+            def initialize(context_manager: nil, **)
+              @context_manager = context_manager || Helpers::ContextManager.new
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/legion/extensions/agentic/integration/context/helpers/constants.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module Agentic
+      module Integration
+        module Context
+          module Helpers
+            module Constants
+              MAX_FRAMES           = 50
+              MAX_FRAME_STACK      = 10
+              FRAME_DECAY          = 0.02
+              FRAME_STRENGTH_FLOOR = 0.05
+              SWITCH_COST          = 0.15
+              SWITCH_COOLDOWN      = 5
+              FAMILIARITY_ALPHA    = 0.12
+              DEFAULT_FAMILIARITY  = 0.3
+              RELEVANCE_THRESHOLD  = 0.2
+              MAX_CUES_PER_FRAME   = 30
+              MAX_HISTORY          = 200
+
+              FRAME_LABELS = {
+                (0.8..)     => :dominant,
+                (0.5...0.8) => :active,
+                (0.2...0.5) => :background,
+                (..0.2)     => :fading
+              }.freeze
+            end
+          end
+        end
+      end
+    end
+  end
+end