lex-agentic-affect 0.1.0

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

@@ -0,0 +1,151 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module Agentic
+      module Affect
+        module CognitiveEmpathy
+          module Helpers
+            class EmpathyEngine
+              include Constants
+
+              attr_reader :perspectives, :contagion_level, :history
+
+              def initialize
+                @perspectives     = {}
+                @contagion_level  = 0.0
+                @counter          = 0
+                @history          = []
+              end
+
+              def take_perspective(agent_id:, perspective_type:, predicted_state:, confidence:)
+                return nil if @perspectives.size >= MAX_PERSPECTIVES
+                return nil unless PERSPECTIVE_TYPES.include?(perspective_type)
+
+                @counter += 1
+                id = :"perspective_#{@counter}"
+                perspective = Perspective.new(
+                  id:               id,
+                  agent_id:         agent_id,
+                  perspective_type: perspective_type,
+                  predicted_state:  predicted_state,
+                  confidence:       confidence
+                )
+                @perspectives[id] = perspective
+                record_event(:perspective_taken, id: id, agent_id: agent_id)
+                perspective
+              end
+
+              def record_outcome(perspective_id:, actual_state:)
+                perspective = @perspectives[perspective_id]
+                return nil unless perspective
+
+                perspective.record_actual(actual_state: actual_state)
+                record_event(:outcome_recorded, id: perspective_id, accuracy: perspective.accuracy)
+                perspective
+              end
+
+              def empathic_accuracy(agent_id:)
+                agent_perspectives = perspectives_for(agent_id: agent_id)
+                resolved = agent_perspectives.select(&:resolved?)
+                return DEFAULT_ACCURACY if resolved.empty?
+
+                resolved.sum(&:accuracy) / resolved.size
+              end
+
+              def overall_accuracy
+                resolved = @perspectives.values.select(&:resolved?)
+                return DEFAULT_ACCURACY if resolved.empty?
+
+                resolved.sum(&:accuracy) / resolved.size
+              end
+
+              def emotional_contagion(emotion_valence:, intensity:)
+                intensity_f = intensity.to_f.clamp(0.0, 1.0)
+                absorption  = CONTAGION_RATE * intensity_f
+                @contagion_level = (@contagion_level + absorption).clamp(0.0, 1.0)
+                record_event(:contagion, valence: emotion_valence, intensity: intensity_f,
+                                         level: @contagion_level)
+                @contagion_level
+              end
+
+              def contagion_decay
+                @contagion_level = [@contagion_level - CONTAGION_DECAY, 0.0].max
+              end
+
+              def empathic_state
+                return :immersed   if @contagion_level >= 0.75
+                return :resonating if @contagion_level >= 0.45
+                return :observing  if @contagion_level >= 0.15
+
+                :detached
+              end
+
+              def perspectives_for(agent_id:)
+                @perspectives.values.select { |p| p.agent_id == agent_id }
+              end
+
+              def most_accurate_agent
+                agent_accuracies = build_agent_accuracies
+                return nil if agent_accuracies.empty?
+
+                agent_accuracies.max_by { |_, acc| acc }&.first
+              end
+
+              def least_accurate_agent
+                agent_accuracies = build_agent_accuracies
+                return nil if agent_accuracies.empty?
+
+                agent_accuracies.min_by { |_, acc| acc }&.first
+              end
+
+              def tick
+                contagion_decay
+                prune_old_perspectives
+                self
+              end
+
+              def to_h
+                {
+                  perspective_count: @perspectives.size,
+                  resolved_count:    @perspectives.values.count(&:resolved?),
+                  overall_accuracy:  overall_accuracy.round(4),
+                  contagion_level:   @contagion_level.round(4),
+                  empathic_state:    empathic_state,
+                  history_size:      @history.size
+                }
+              end
+
+              private
+
+              def build_agent_accuracies
+                agent_ids = @perspectives.values.map(&:agent_id).uniq
+                accuracies = {}
+                agent_ids.each do |aid|
+                  resolved = perspectives_for(agent_id: aid).select(&:resolved?)
+                  next if resolved.empty?
+
+                  accuracies[aid] = resolved.sum(&:accuracy) / resolved.size
+                end
+                accuracies
+              end
+
+              def prune_old_perspectives
+                resolved = @perspectives.select { |_, p| p.resolved? }
+                return unless resolved.size > MAX_PERSPECTIVES / 2
+
+                oldest_keys = resolved.keys.first(resolved.size - (MAX_PERSPECTIVES / 4))
+                oldest_keys.each { |k| @perspectives.delete(k) }
+              end
+
+              def record_event(type, **details)
+                @history << { type: type, at: Time.now.utc }.merge(details)
+                @history.shift while @history.size > MAX_HISTORY
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,92 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module Agentic
+      module Affect
+        module CognitiveEmpathy
+          module Helpers
+            class Perspective
+              include Constants
+
+              attr_reader :id, :agent_id, :perspective_type, :predicted_state, :actual_state,
+                          :confidence, :accuracy
+
+              def initialize(id:, agent_id:, perspective_type: :cognitive, predicted_state: {}, confidence: 0.5)
+                @id               = id
+                @agent_id         = agent_id
+                @perspective_type = perspective_type
+                @predicted_state  = predicted_state
+                @confidence       = confidence.to_f.clamp(0.0, 1.0)
+                @actual_state     = nil
+                @accuracy         = DEFAULT_ACCURACY
+                @created_at       = Time.now.utc
+                @resolved_at      = nil
+              end
+
+              def record_actual(actual_state:)
+                @actual_state = actual_state
+                @resolved_at  = Time.now.utc
+                error = compute_error(predicted_state, actual_state)
+                observed_accuracy = (1.0 - error).clamp(ACCURACY_FLOOR, ACCURACY_CEILING)
+                @accuracy = ((1.0 - ACCURACY_ALPHA) * @accuracy) + (ACCURACY_ALPHA * observed_accuracy)
+                @accuracy = @accuracy.clamp(ACCURACY_FLOOR, ACCURACY_CEILING)
+                self
+              end
+
+              def accurate?
+                @accuracy > 0.6
+              end
+
+              def resolved?
+                !@actual_state.nil?
+              end
+
+              def to_h
+                {
+                  id:               @id,
+                  agent_id:         @agent_id,
+                  perspective_type: @perspective_type,
+                  predicted_state:  @predicted_state,
+                  actual_state:     @actual_state,
+                  confidence:       @confidence.round(4),
+                  accuracy:         @accuracy.round(4),
+                  accurate:         accurate?,
+                  resolved:         resolved?,
+                  created_at:       @created_at,
+                  resolved_at:      @resolved_at
+                }
+              end
+
+              private
+
+              def compute_error(predicted, actual)
+                return 0.0 if predicted.empty? && actual.empty?
+                return 1.0 if predicted.empty? || actual.empty?
+
+                keys = (predicted.keys | actual.keys)
+                return 1.0 if keys.empty?
+
+                total_error = keys.sum do |k|
+                  p_val = numeric_value(predicted[k])
+                  a_val = numeric_value(actual[k])
+                  (p_val - a_val).abs
+                end
+
+                (total_error / keys.size).clamp(0.0, 1.0)
+              end
+
+              def numeric_value(val)
+                return val.to_f if val.is_a?(Numeric)
+                return 1.0 if val == true
+                return 0.0 if val == false || val.nil?
+
+                0.5
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,93 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module Agentic
+      module Affect
+        module CognitiveEmpathy
+          module Runners
+            module CognitiveEmpathy
+              include Helpers::Constants
+              include Legion::Extensions::Helpers::Lex if defined?(Legion::Extensions::Helpers::Lex)
+
+              def take_empathic_perspective(agent_id:, perspective_type:, predicted_state:, confidence: 0.5, **)
+                perspective = engine.take_perspective(
+                  agent_id:         agent_id,
+                  perspective_type: perspective_type,
+                  predicted_state:  predicted_state,
+                  confidence:       confidence
+                )
+                return { success: false, reason: :limit_or_invalid_type } unless perspective
+
+                { success: true, perspective_id: perspective.id, agent_id: agent_id,
+                  perspective_type: perspective_type }
+              end
+
+              def record_empathic_outcome(perspective_id:, actual_state:, **)
+                perspective = engine.record_outcome(perspective_id: perspective_id, actual_state: actual_state)
+                return { success: false, reason: :not_found } unless perspective
+
+                { success: true, perspective_id: perspective_id,
+                  accuracy: perspective.accuracy.round(4), accurate: perspective.accurate? }
+              end
+
+              def empathic_accuracy_for(agent_id:, **)
+                accuracy = engine.empathic_accuracy(agent_id: agent_id)
+                label = accuracy_label(accuracy)
+                { success: true, agent_id: agent_id, accuracy: accuracy.round(4), label: label }
+              end
+
+              def overall_empathic_accuracy(**)
+                accuracy = engine.overall_accuracy
+                label = accuracy_label(accuracy)
+                { success: true, accuracy: accuracy.round(4), label: label }
+              end
+
+              def apply_emotional_contagion(emotion_valence:, intensity:, **)
+                level = engine.emotional_contagion(emotion_valence: emotion_valence, intensity: intensity)
+                { success: true, contagion_level: level.round(4), empathic_state: engine.empathic_state }
+              end
+
+              def current_empathic_state(**)
+                { success: true, empathic_state: engine.empathic_state,
+                  contagion_level: engine.contagion_level.round(4) }
+              end
+
+              def perspectives_for_agent(agent_id:, **)
+                list = engine.perspectives_for(agent_id: agent_id).map(&:to_h)
+                { success: true, agent_id: agent_id, perspectives: list, count: list.size }
+              end
+
+              def empathic_blind_spots(**)
+                least = engine.least_accurate_agent
+                most  = engine.most_accurate_agent
+                { success: true, least_accurate_agent: least, most_accurate_agent: most,
+                  overall_accuracy: engine.overall_accuracy.round(4) }
+              end
+
+              def update_cognitive_empathy(**)
+                engine.tick
+                { success: true }.merge(engine.to_h)
+              end
+
+              def cognitive_empathy_stats(**)
+                { success: true }.merge(engine.to_h)
+              end
+
+              private
+
+              def engine
+                @engine ||= Helpers::EmpathyEngine.new
+              end
+
+              def accuracy_label(accuracy)
+                ACCURACY_LABELS.each { |range, lbl| return lbl if range.cover?(accuracy) }
+                :blind
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

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

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

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+require_relative 'cognitive_empathy/version'
+require_relative 'cognitive_empathy/helpers/constants'
+require_relative 'cognitive_empathy/helpers/empathy_engine'
+require_relative 'cognitive_empathy/helpers/perspective'
+require_relative 'cognitive_empathy/runners/cognitive_empathy'
+require_relative 'cognitive_empathy/client'
+
+module Legion
+  module Extensions
+    module Agentic
+      module Affect
+        module CognitiveEmpathy
+          # Sub-module for cognitive empathy: affective and cognitive empathy modeling
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+require 'legion/extensions/agentic/affect/contagion/helpers/constants'
+require 'legion/extensions/agentic/affect/contagion/helpers/meme'
+require 'legion/extensions/agentic/affect/contagion/helpers/contagion_engine'
+require 'legion/extensions/agentic/affect/contagion/runners/cognitive_contagion'
+
+module Legion
+  module Extensions
+    module Agentic
+      module Affect
+        module Contagion
+          class Client
+            include Runners::CognitiveContagion
+
+            def initialize(**)
+              @engine = Helpers::ContagionEngine.new
+            end
+
+            private
+
+            attr_reader :engine
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module Agentic
+      module Affect
+        module Contagion
+          module Helpers
+            module Constants
+              MAX_AGENTS        = 200
+              MAX_MEMES         = 500
+              DEFAULT_VIRULENCE = 0.3
+              DEFAULT_RESISTANCE = 0.5
+              TRANSMISSION_RATE = 0.15
+              RECOVERY_RATE     = 0.05
+              IMMUNITY_BOOST    = 0.1
+
+              VIRULENCE_LABELS = {
+                (0.8..)     => :pandemic,
+                (0.6...0.8) => :epidemic,
+                (0.4...0.6) => :endemic,
+                (0.2...0.4) => :sporadic,
+                (..0.2)     => :contained
+              }.freeze
+
+              STATUS_LABELS    = %i[susceptible exposed infected recovered immune].freeze
+              CONTAGION_TYPES  = %i[emotional belief behavioral cognitive].freeze
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/legion/extensions/agentic/affect/contagion/helpers/contagion_engine.rb

@@ -0,0 +1,184 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module Agentic
+      module Affect
+        module Contagion
+          module Helpers
+            class ContagionEngine
+              attr_reader :memes, :agent_resistance
+
+              def initialize
+                @memes            = {}
+                @agent_resistance = {}
+              end
+
+              def create_meme(label:, contagion_type: :cognitive, virulence: Constants::DEFAULT_VIRULENCE)
+                return { error: :too_many_memes } if @memes.size >= Constants::MAX_MEMES
+
+                meme = Meme.new(label: label, contagion_type: contagion_type, virulence: virulence)
+                @memes[meme.id] = meme
+                meme
+              end
+
+              def register_agent(agent_id:, resistance: Constants::DEFAULT_RESISTANCE)
+                return { error: :too_many_agents } if @agent_resistance.size >= Constants::MAX_AGENTS
+
+                @agent_resistance[agent_id] = resistance.clamp(0.0, 1.0).round(10)
+                { agent_id: agent_id, resistance: @agent_resistance[agent_id] }
+              end
+
+              def attempt_transmission(meme_id:, source_agent_id:, target_agent_id:)
+                meme = @memes.fetch(meme_id, nil)
+                return { transmitted: false, reason: :meme_not_found } unless meme
+                return { transmitted: false, reason: :source_not_carrying } unless meme.carrying?(agent_id: source_agent_id)
+
+                resistance = @agent_resistance.fetch(target_agent_id, Constants::DEFAULT_RESISTANCE)
+                probability = (meme.virulence * Constants::TRANSMISSION_RATE * (1.0 - resistance)).round(10)
+
+                if rand <= probability
+                  result = meme.infect!(agent_id: target_agent_id)
+                  { transmitted: result == :infected, reason: result, meme_id: meme_id,
+                    source: source_agent_id, target: target_agent_id, probability: probability }
+                else
+                  { transmitted: false, reason: :blocked_by_resistance, meme_id: meme_id,
+                    source: source_agent_id, target: target_agent_id, probability: probability }
+                end
+              end
+
+              def recover_agent(meme_id:, agent_id:)
+                meme = @memes.fetch(meme_id, nil)
+                return { recovered: false, reason: :meme_not_found } unless meme
+
+                result = meme.recover!(agent_id: agent_id)
+                boost_resistance(agent_id)
+                { recovered: result == :recovered, agent_id: agent_id, meme_id: meme_id, result: result }
+              end
+
+              def immunize_agent(meme_id:, agent_id:)
+                meme = @memes.fetch(meme_id, nil)
+                return { immunized: false, reason: :meme_not_found } unless meme
+
+                result = meme.immunize!(agent_id: agent_id)
+                { immunized: true, agent_id: agent_id, meme_id: meme_id, result: result }
+              end
+
+              def spread_step(meme_id:)
+                meme = @memes.fetch(meme_id, nil)
+                return { transmissions: 0, reason: :meme_not_found } unless meme
+
+                susceptible = susceptible_agents(meme_id: meme_id)
+                carriers    = meme.carriers.to_a
+                transmissions = 0
+
+                carriers.each do |carrier_id|
+                  susceptible.each do |target_id|
+                    result = attempt_transmission(meme_id: meme_id, source_agent_id: carrier_id,
+                                                  target_agent_id: target_id)
+                    transmissions += 1 if result[:transmitted]
+                  end
+                end
+
+                recoveries = apply_natural_recovery(meme_id: meme_id)
+                { meme_id: meme_id, transmissions: transmissions, recoveries: recoveries,
+                  carrier_count: meme.carrier_count }
+              end
+
+              def epidemic_report(meme_id:)
+                meme = @memes.fetch(meme_id, nil)
+                return { error: :meme_not_found } unless meme
+
+                total = @agent_resistance.size
+                infected   = meme.carriers.size
+                recovered  = meme.recovered.size
+                immune     = meme.immune.size
+                susceptible_count = [total - infected - recovered - immune, 0].max
+
+                {
+                  meme_id:             meme_id,
+                  label:               meme.label,
+                  contagion_type:      meme.contagion_type,
+                  virulence:           meme.virulence,
+                  virulence_label:     meme.virulence_label,
+                  susceptible:         susceptible_count,
+                  infected:            infected,
+                  recovered:           recovered,
+                  immune:              immune,
+                  total_agents:        total,
+                  total_transmissions: meme.total_transmissions,
+                  transmission_rate:   meme.transmission_rate
+                }
+              end
+
+              def most_viral(limit: 5)
+                @memes.values
+                      .sort_by { |m| -m.virulence }
+                      .first(limit)
+                      .map(&:to_h)
+              end
+
+              def agent_status(agent_id:, meme_id:)
+                meme = @memes.fetch(meme_id, nil)
+                return { status: :unknown, reason: :meme_not_found } unless meme
+
+                status = if meme.immune.include?(agent_id)
+                           :immune
+                         elsif meme.carrying?(agent_id: agent_id)
+                           :infected
+                         elsif meme.recovered.include?(agent_id)
+                           :recovered
+                         else
+                           :susceptible
+                         end
+
+                { agent_id: agent_id, meme_id: meme_id, status: status,
+                  resistance: @agent_resistance.fetch(agent_id, Constants::DEFAULT_RESISTANCE) }
+              end
+
+              def susceptible_agents(meme_id:)
+                meme = @memes.fetch(meme_id, nil)
+                return [] unless meme
+
+                @agent_resistance.keys.reject do |id|
+                  meme.carrying?(agent_id: id) || meme.immune.include?(id)
+                end
+              end
+
+              def to_h
+                {
+                  meme_count:       @memes.size,
+                  agent_count:      @agent_resistance.size,
+                  memes:            @memes.values.map(&:to_h),
+                  agent_resistance: @agent_resistance
+                }
+              end
+
+              private
+
+              def boost_resistance(agent_id)
+                current = @agent_resistance.fetch(agent_id, Constants::DEFAULT_RESISTANCE)
+                @agent_resistance[agent_id] = (current + Constants::IMMUNITY_BOOST).clamp(0.0, 1.0).round(10)
+              end
+
+              def apply_natural_recovery(meme_id:)
+                meme = @memes.fetch(meme_id, nil)
+                return 0 unless meme
+
+                recoveries = 0
+                meme.carriers.to_a.each do |carrier_id|
+                  next unless rand <= Constants::RECOVERY_RATE
+
+                  meme.recover!(agent_id: carrier_id)
+                  boost_resistance(carrier_id)
+                  recoveries += 1
+                end
+                recoveries
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end