lex-agentic-affect 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: d03176e4d632c5182d79f6c122b06ee6492b7a330ea28f26de0bdf2b38464d3c
+  data.tar.gz: 036f318f959c28fd2e4ab3d33b439ac81742b52b406702a56667ad2a78c35f3b
+SHA512:
+  metadata.gz: 923827c5b0fae5871187437b4e0ffc7672ff52214ff0261c857c240128c4d1bd5a6dbbbe14b50e3caf22db645cd76e71c7ff490dbb348fd8ab5ed55dac6b4230
+  data.tar.gz: e27fe89064ed41221e4879b841830058d759158eda0e7f396cf7acd22252c6c60d5b739ebc7956e3691713c6aaf8f08de0d556a15eadb5eddc1b3340f9f211df

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-affect
+
+LEX agentic affect domain: emotions, valence, mood regulation
+
+## Sub-modules
+
+*(populated as extensions are consolidated)*
+
+## Installation
+
+```ruby
+gem 'lex-agentic-affect'
+```

data/lex-agentic-affect.gemspec

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

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+require 'legion/extensions/agentic/affect/appraisal/helpers/constants'
+require 'legion/extensions/agentic/affect/appraisal/helpers/appraisal'
+require 'legion/extensions/agentic/affect/appraisal/helpers/appraisal_engine'
+require 'legion/extensions/agentic/affect/appraisal/runners/appraisal'
+
+module Legion
+  module Extensions
+    module Agentic
+      module Affect
+        module Appraisal
+          class Client
+            include Runners::Appraisal
+          end
+        end
+      end
+    end
+  end
+end

data/lib/legion/extensions/agentic/affect/appraisal/helpers/appraisal.rb

@@ -0,0 +1,112 @@
+# frozen_string_literal: true
+
+require 'securerandom'
+
+module Legion
+  module Extensions
+    module Agentic
+      module Affect
+        module Appraisal
+          module Helpers
+            class Appraisal
+              include Constants
+
+              attr_reader :id, :event, :domain, :primary, :secondary,
+                          :emotional_outcome, :intensity, :coping_strategy,
+                          :reappraised, :created_at, :reappraised_at
+
+              def initialize(event:, primary:, secondary:, domain: nil)
+                @id               = SecureRandom.uuid
+                @event            = event
+                @domain           = domain
+                @primary          = normalize_dimensions(primary, PRIMARY_DIMENSIONS)
+                @secondary        = normalize_dimensions(secondary, SECONDARY_DIMENSIONS)
+                @intensity        = DEFAULT_INTENSITY
+                @coping_strategy  = nil
+                @reappraised      = false
+                @created_at       = Time.now.utc
+                @reappraised_at   = nil
+                @emotional_outcome = compute_emotion
+              end
+
+              def reappraise(new_primary:, new_secondary:)
+                @primary          = normalize_dimensions(new_primary, PRIMARY_DIMENSIONS)
+                @secondary        = normalize_dimensions(new_secondary, SECONDARY_DIMENSIONS)
+                @emotional_outcome = compute_emotion
+                @intensity        = (@intensity * (1 - REAPPRAISAL_DISCOUNT)).clamp(INTENSITY_FLOOR, INTENSITY_CEILING)
+                @reappraised      = true
+                @reappraised_at   = Time.now.utc
+                self
+              end
+
+              def compute_emotion
+                relevance        = @primary[:relevance]
+                goal_congruence  = @primary[:goal_congruence]
+                coping_potential = @secondary[:coping_potential]
+
+                return :indifference if relevance < 0.3
+
+                classify_emotion(goal_congruence, coping_potential)
+              end
+
+              def to_h
+                {
+                  id:                @id,
+                  event:             @event,
+                  domain:            @domain,
+                  primary:           @primary,
+                  secondary:         @secondary,
+                  emotional_outcome: @emotional_outcome,
+                  intensity:         @intensity,
+                  coping_strategy:   @coping_strategy,
+                  reappraised:       @reappraised,
+                  created_at:        @created_at,
+                  reappraised_at:    @reappraised_at
+                }
+              end
+
+              def assign_coping(strategy_name)
+                @coping_strategy = strategy_name
+              end
+
+              def decay!
+                @intensity = (@intensity - DECAY_RATE).clamp(INTENSITY_FLOOR, INTENSITY_CEILING)
+              end
+
+              private
+
+              def classify_emotion(goal_congruence, coping_potential)
+                if goal_congruence < 0.4
+                  low_congruence_emotion(goal_congruence, coping_potential)
+                elsif goal_congruence > 0.7
+                  :joy
+                else
+                  :sadness
+                end
+              end
+
+              def low_congruence_emotion(goal_congruence, coping_potential)
+                if goal_congruence < 0.3
+                  :anger
+                elsif coping_potential < 0.4
+                  :anxiety
+                elsif coping_potential >= 0.6
+                  :challenge
+                else
+                  :sadness
+                end
+              end
+
+              def normalize_dimensions(raw, dimensions)
+                dimensions.to_h do |dim|
+                  val = raw.fetch(dim, 0.0).to_f
+                  [dim, val.clamp(INTENSITY_FLOOR, INTENSITY_CEILING)]
+                end
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/legion/extensions/agentic/affect/appraisal/helpers/appraisal_engine.rb

@@ -0,0 +1,129 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module Agentic
+      module Affect
+        module Appraisal
+          module Helpers
+            class AppraisalEngine
+              include Constants
+
+              def initialize
+                @appraisals        = {}
+                @coping_strategies = {}
+                @history           = []
+              end
+
+              def appraise(event:, primary:, secondary:, domain: nil)
+                record = Appraisal.new(event: event, primary: primary, secondary: secondary, domain: domain)
+                prune_appraisals if @appraisals.size >= MAX_APPRAISALS
+                @appraisals[record.id] = record
+                archive(record)
+                record
+              end
+
+              def reappraise(appraisal_id:, new_primary:, new_secondary:)
+                record = @appraisals[appraisal_id]
+                return nil unless record
+
+                record.reappraise(new_primary: new_primary, new_secondary: new_secondary)
+                archive(record)
+                record
+              end
+
+              def select_coping(appraisal_id:, coping_type:)
+                record = @appraisals[appraisal_id]
+                return nil unless record
+
+                strategy = find_best_strategy(coping_type)
+                name = strategy ? strategy[:name] : coping_type.to_s
+                record.assign_coping(name)
+                record
+              end
+
+              def add_coping_strategy(name:, coping_type:, effectiveness:)
+                return false if @coping_strategies.size >= MAX_COPING_STRATEGIES
+
+                @coping_strategies[name] = {
+                  name:          name,
+                  coping_type:   coping_type,
+                  effectiveness: effectiveness.to_f.clamp(INTENSITY_FLOOR, INTENSITY_CEILING)
+                }
+                true
+              end
+
+              def evaluate_coping(appraisal_id:)
+                record = @appraisals[appraisal_id]
+                return { effectiveness: 0.0, resolved: false } unless record
+                return { effectiveness: 0.0, resolved: false } unless record.coping_strategy
+
+                strategy    = @coping_strategies[record.coping_strategy]
+                base        = strategy ? strategy[:effectiveness] : DEFAULT_INTENSITY
+                resolved    = record.intensity < 0.3
+                {
+                  appraisal_id:  appraisal_id,
+                  coping:        record.coping_strategy,
+                  effectiveness: base,
+                  intensity:     record.intensity,
+                  resolved:      resolved
+                }
+              end
+
+              def by_emotion(emotion:)
+                @appraisals.values.select { |rec| rec.emotional_outcome == emotion }
+              end
+
+              def by_domain(domain:)
+                @appraisals.values.select { |rec| rec.domain == domain }
+              end
+
+              def unresolved
+                @appraisals.values.select { |rec| rec.coping_strategy.nil? }
+              end
+
+              def emotional_pattern
+                counts = Hash.new(0)
+                recent_appraisals.each { |rec| counts[rec.emotional_outcome] += 1 }
+                counts.sort_by { |_, cnt| -cnt }.to_h
+              end
+
+              def decay_all
+                @appraisals.each_value(&:decay!)
+              end
+
+              def to_h
+                {
+                  appraisals:        @appraisals.transform_values(&:to_h),
+                  coping_strategies: @coping_strategies,
+                  history_size:      @history.size
+                }
+              end
+
+              private
+
+              def archive(record)
+                @history << { id: record.id, emotion: record.emotional_outcome, at: Time.now.utc }
+                @history.shift while @history.size > MAX_HISTORY
+              end
+
+              def prune_appraisals
+                oldest_key = @appraisals.min_by { |_, rec| rec.created_at }&.first
+                @appraisals.delete(oldest_key) if oldest_key
+              end
+
+              def find_best_strategy(coping_type)
+                matches = @coping_strategies.values.select { |str| str[:coping_type] == coping_type }
+                matches.max_by { |str| str[:effectiveness] }
+              end
+
+              def recent_appraisals
+                @appraisals.values.last(50)
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/legion/extensions/agentic/affect/appraisal/helpers/constants.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module Agentic
+      module Affect
+        module Appraisal
+          module Helpers
+            module Constants
+              MAX_APPRAISALS = 200
+              MAX_COPING_STRATEGIES = 50
+              MAX_HISTORY         = 300
+
+              DEFAULT_INTENSITY   = 0.5
+              INTENSITY_FLOOR     = 0.0
+              INTENSITY_CEILING   = 1.0
+
+              DECAY_RATE = 0.02
+              REAPPRAISAL_DISCOUNT = 0.3
+
+              PRIMARY_DIMENSIONS = %i[relevance goal_congruence goal_importance].freeze
+
+              SECONDARY_DIMENSIONS = %i[coping_potential control_expectation future_expectancy].freeze
+
+              APPRAISAL_EMOTIONS = {
+                threat_low_coping:   :anxiety,
+                threat_high_coping:  :challenge,
+                loss:                :sadness,
+                goal_incongruent:    :anger,
+                goal_congruent:      :joy,
+                irrelevant:          :indifference,
+                unexpected_positive: :surprise,
+                moral_violation:     :disgust
+              }.freeze
+
+              COPING_TYPES = %i[problem_focused emotion_focused meaning_focused avoidant social_support].freeze
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/legion/extensions/agentic/affect/appraisal/runners/appraisal.rb

@@ -0,0 +1,105 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module Agentic
+      module Affect
+        module Appraisal
+          module Runners
+            module Appraisal
+              def appraise_event(event:, primary:, secondary:, domain: nil, **)
+                Legion::Logging.debug("[lex-appraisal] appraise_event event=#{event} domain=#{domain}")
+                record = engine.appraise(event: event, primary: primary, secondary: secondary, domain: domain)
+                { success: true, appraisal: record.to_h }
+              rescue StandardError => e
+                Legion::Logging.error("[lex-appraisal] appraise_event error: #{e.message}")
+                { success: false, error: e.message }
+              end
+
+              def reappraise_event(appraisal_id:, new_primary:, new_secondary:, **)
+                Legion::Logging.debug("[lex-appraisal] reappraise_event id=#{appraisal_id}")
+                record = engine.reappraise(appraisal_id: appraisal_id, new_primary: new_primary,
+                                           new_secondary: new_secondary)
+                return { success: false, error: 'appraisal not found' } unless record
+
+                { success: true, appraisal: record.to_h }
+              rescue StandardError => e
+                Legion::Logging.error("[lex-appraisal] reappraise_event error: #{e.message}")
+                { success: false, error: e.message }
+              end
+
+              def select_coping_strategy(appraisal_id:, coping_type:, **)
+                Legion::Logging.debug("[lex-appraisal] select_coping appraisal_id=#{appraisal_id}")
+                record = engine.select_coping(appraisal_id: appraisal_id, coping_type: coping_type)
+                return { success: false, error: 'appraisal not found' } unless record
+
+                { success: true, appraisal: record.to_h }
+              rescue StandardError => e
+                Legion::Logging.error("[lex-appraisal] select_coping error: #{e.message}")
+                { success: false, error: e.message }
+              end
+
+              def add_coping_strategy(name:, coping_type:, effectiveness:, **)
+                Legion::Logging.debug("[lex-appraisal] add_coping_strategy name=#{name}")
+                added = engine.add_coping_strategy(name: name, coping_type: coping_type, effectiveness: effectiveness)
+                { success: added, name: name, coping_type: coping_type }
+              rescue StandardError => e
+                Legion::Logging.error("[lex-appraisal] add_coping_strategy error: #{e.message}")
+                { success: false, error: e.message }
+              end
+
+              def evaluate_coping(appraisal_id:, **)
+                Legion::Logging.debug("[lex-appraisal] evaluate_coping id=#{appraisal_id}")
+                result = engine.evaluate_coping(appraisal_id: appraisal_id)
+                { success: true }.merge(result)
+              rescue StandardError => e
+                Legion::Logging.error("[lex-appraisal] evaluate_coping error: #{e.message}")
+                { success: false, error: e.message }
+              end
+
+              def emotional_pattern(**)
+                Legion::Logging.debug('[lex-appraisal] emotional_pattern')
+                pattern = engine.emotional_pattern
+                { success: true, pattern: pattern }
+              rescue StandardError => e
+                Legion::Logging.error("[lex-appraisal] emotional_pattern error: #{e.message}")
+                { success: false, error: e.message }
+              end
+
+              def update_appraisal(**)
+                Legion::Logging.debug('[lex-appraisal] update_appraisal (decay cycle)')
+                engine.decay_all
+                { success: true }
+              rescue StandardError => e
+                Legion::Logging.error("[lex-appraisal] update_appraisal error: #{e.message}")
+                { success: false, error: e.message }
+              end
+
+              def appraisal_stats(**)
+                Legion::Logging.debug('[lex-appraisal] appraisal_stats')
+                data = engine.to_h
+                unresolved = engine.unresolved.size
+                {
+                  success:      true,
+                  total:        data[:appraisals].size,
+                  unresolved:   unresolved,
+                  history_size: data[:history_size],
+                  pattern:      engine.emotional_pattern
+                }
+              rescue StandardError => e
+                Legion::Logging.error("[lex-appraisal] appraisal_stats error: #{e.message}")
+                { success: false, error: e.message }
+              end
+
+              private
+
+              def engine
+                @engine ||= Helpers::AppraisalEngine.new
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/legion/extensions/agentic/affect/appraisal/version.rb

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

data/lib/legion/extensions/agentic/affect/appraisal.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+require 'legion/extensions/agentic/affect/appraisal/version'
+require 'legion/extensions/agentic/affect/appraisal/helpers/constants'
+require 'legion/extensions/agentic/affect/appraisal/helpers/appraisal'
+require 'legion/extensions/agentic/affect/appraisal/helpers/appraisal_engine'
+require 'legion/extensions/agentic/affect/appraisal/runners/appraisal'
+require 'legion/extensions/agentic/affect/appraisal/client'
+
+module Legion
+  module Extensions
+    module Agentic
+      module Affect
+        module Appraisal
+        end
+      end
+    end
+  end
+end

data/lib/legion/extensions/agentic/affect/cognitive_empathy/client.rb

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

data/lib/legion/extensions/agentic/affect/cognitive_empathy/helpers/constants.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module Agentic
+      module Affect
+        module CognitiveEmpathy
+          module Helpers
+            module Constants
+              MAX_PERSPECTIVES  = 50
+              MAX_INTERACTIONS  = 200
+              MAX_HISTORY       = 200
+
+              DEFAULT_ACCURACY  = 0.5
+              ACCURACY_FLOOR    = 0.1
+              ACCURACY_CEILING  = 0.95
+              CONTAGION_RATE    = 0.15
+              CONTAGION_DECAY   = 0.05
+              ACCURACY_ALPHA    = 0.1
+
+              PERSPECTIVE_TYPES = %i[cognitive affective motivational situational].freeze
+              EMPATHIC_STATES   = %i[detached observing resonating immersed].freeze
+
+              ACCURACY_LABELS = {
+                (0.8..)     => :excellent,
+                (0.6...0.8) => :good,
+                (0.4...0.6) => :moderate,
+                (0.2...0.4) => :poor,
+                (..0.2)     => :blind
+              }.freeze
+            end
+          end
+        end
+      end
+    end
+  end
+end