lex-cognitive-empathy 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 1f590431e81d898d029f4728f145da572298e5d07f3a7b9c105d0ffd05519a8c
+  data.tar.gz: e7ad498fdb8d1ae424fd5cac5b3463031358e0b74a6573f8d970c4dac68a042e
+SHA512:
+  metadata.gz: e5bcfb9c8f0a05cc9bdea9d19fc031a461cb4ae5b05a159ee22eedfbb671797dde95ab424b94e804f18eb208bb78e73f8476642df35fc4764568b395a003f90b
+  data.tar.gz: 659247e264da0939ade120322f814014b604c966ec4cac8921b46bfae5d1deca84ccfc5c263a51693d432a61fa93efee60f4fb0de06f5c1c8150375b769bbdf2

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

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

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

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    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

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

@@ -0,0 +1,147 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    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

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

@@ -0,0 +1,88 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    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

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

@@ -0,0 +1,89 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    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

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

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

metadata

@@ -0,0 +1,67 @@
+--- !ruby/object:Gem::Specification
+name: lex-cognitive-empathy
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Esity
+bindir: bin
+cert_chain: []
+date: 1980-01-02 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: legion-gaia
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: Perspective-taking, emotional contagion modeling, and empathic accuracy
+  tracking for LegionIO agentic extensions
+email:
+- matthewdiverson@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/legion/extensions/cognitive_empathy/client.rb
+- lib/legion/extensions/cognitive_empathy/helpers/constants.rb
+- lib/legion/extensions/cognitive_empathy/helpers/empathy_engine.rb
+- lib/legion/extensions/cognitive_empathy/helpers/perspective.rb
+- lib/legion/extensions/cognitive_empathy/runners/cognitive_empathy.rb
+- lib/legion/extensions/cognitive_empathy/version.rb
+homepage: https://github.com/LegionIO/lex-cognitive-empathy
+licenses:
+- MIT
+metadata:
+  homepage_uri: https://github.com/LegionIO/lex-cognitive-empathy
+  source_code_uri: https://github.com/LegionIO/lex-cognitive-empathy
+  documentation_uri: https://github.com/LegionIO/lex-cognitive-empathy/blob/master/README.md
+  changelog_uri: https://github.com/LegionIO/lex-cognitive-empathy/blob/master/CHANGELOG.md
+  bug_tracker_uri: https://github.com/LegionIO/lex-cognitive-empathy/issues
+  rubygems_mfa_required: 'true'
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '3.4'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.6.9
+specification_version: 4
+summary: Cognitive empathy engine for LegionIO
+test_files: []