lex-personality 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 900b7ca389f94db331c1959497b8d65678c85e81052e4cab54c1871f436ba638
+  data.tar.gz: 724436bf9d1e2e5d476b76c822097964ce75f92db4e2f9f1315e119472b13c9a
+SHA512:
+  metadata.gz: 5579277a9f55a11a0bec90b5744e2a2695ad37c2e115b35f43eeb065bacee8e704e8570b8c47b0594c49ccc6ead158cc360680a43acb4853c8d40cc4842e1971
+  data.tar.gz: 57498f12959d05594f69021b638f45a46269f309fd5fcec0c186a775af14faf127d490cbff86ca64d4d5aa31817f179d9a915814c6e9279c025690b3b793ea3e

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

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module Personality
+      class Client
+        include Runners::Personality
+
+        attr_reader :personality_store
+
+        def initialize(personality_store: nil, **)
+          @personality_store = personality_store || Helpers::PersonalityStore.new
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,80 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module Personality
+      module Helpers
+        module Constants
+          # The Big Five personality dimensions (OCEAN)
+          TRAITS = %i[openness conscientiousness extraversion agreeableness neuroticism].freeze
+
+          # Starting values — neutral personality (0.5 = average on each trait)
+          DEFAULT_TRAIT_VALUE = 0.5
+
+          # EMA alpha for trait updates — very slow (personality is stable)
+          TRAIT_ALPHA = 0.02
+
+          # Minimum observations before personality is considered "formed"
+          FORMATION_THRESHOLD = 100
+
+          # Maximum trait history entries
+          MAX_HISTORY = 200
+
+          # Trait descriptors for each level
+          TRAIT_DESCRIPTORS = {
+            openness:          {
+              high: 'highly curious and open to new experiences',
+              mid:  'moderately exploratory',
+              low:  'preferring familiar approaches and known domains'
+            },
+            conscientiousness: {
+              high: 'very reliable, consistent, and detail-oriented',
+              mid:  'reasonably organized and dependable',
+              low:  'flexible but sometimes inconsistent'
+            },
+            extraversion:      {
+              high: 'socially engaged, frequently communicating with other agents',
+              mid:  'balanced between collaboration and independent work',
+              low:  'preferring independent work with minimal social interaction'
+            },
+            agreeableness:     {
+              high: 'cooperative, trusting, and conflict-averse',
+              mid:  'balanced between cooperation and independent judgment',
+              low:  'assertive and willing to challenge others'
+            },
+            neuroticism:       {
+              high: 'emotionally sensitive, prone to anxiety under stress',
+              mid:  'moderately resilient to emotional fluctuation',
+              low:  'emotionally stable and stress-resistant'
+            }
+          }.freeze
+
+          # Signal extraction: maps tick_results keys to trait influences
+          # Each entry: [trait, direction, weight]
+          # direction: :positive means high signal increases trait, :negative means high signal decreases it
+          SIGNAL_MAP = {
+            curiosity_intensity:   [:openness, :positive, 0.3],
+            novel_domains:         [:openness, :positive, 0.4],
+            prediction_accuracy:   [:conscientiousness, :positive, 0.3],
+            habit_automatic_ratio: [:conscientiousness, :positive, 0.3],
+            error_rate:            [:conscientiousness, :negative, 0.4],
+            mesh_message_count:    [:extraversion, :positive, 0.4],
+            empathy_model_count:   [:extraversion, :positive, 0.3],
+            cooperation_ratio:     [:agreeableness, :positive, 0.4],
+            trust_extension_rate:  [:agreeableness, :positive, 0.3],
+            conflict_frequency:    [:agreeableness, :negative, 0.3],
+            emotional_volatility:  [:neuroticism, :positive, 0.4],
+            anxiety_frequency:     [:neuroticism, :positive, 0.3],
+            mood_stability:        [:neuroticism, :negative, 0.3]
+          }.freeze
+
+          # Threshold for "high" trait descriptor
+          HIGH_THRESHOLD = 0.65
+
+          # Threshold for "low" trait descriptor
+          LOW_THRESHOLD = 0.35
+        end
+      end
+    end
+  end
+end

data/lib/legion/extensions/personality/helpers/personality_store.rb

@@ -0,0 +1,122 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module Personality
+      module Helpers
+        class PersonalityStore
+          attr_reader :model
+
+          def initialize
+            @model = TraitModel.new
+          end
+
+          def update(tick_results)
+            signals = extract_signals(tick_results)
+            @model.update(signals)
+          end
+
+          def full_description
+            return 'Personality not yet formed — insufficient observations.' unless @model.formed?
+
+            parts = Constants::TRAITS.filter_map do |trait|
+              @model.describe(trait)
+            end
+            "#{parts.join('. ')}."
+          end
+
+          def compatibility_score(other_profile)
+            return nil unless other_profile.is_a?(Hash)
+
+            diffs = Constants::TRAITS.map do |trait|
+              mine = @model.trait(trait) || 0.5
+              theirs = other_profile[trait] || 0.5
+              (mine - theirs).abs
+            end
+            avg_diff = diffs.sum / diffs.size.to_f
+            (1.0 - avg_diff).round(3)
+          end
+
+          private
+
+          def extract_signals(tick_results)
+            signals = {}
+
+            signals[:curiosity_intensity] = extract_curiosity(tick_results)
+            signals[:novel_domains] = extract_novelty(tick_results)
+            signals[:prediction_accuracy] = extract_prediction(tick_results)
+            signals[:error_rate] = extract_error_rate(tick_results)
+            signals[:mesh_message_count] = extract_mesh(tick_results)
+            signals[:empathy_model_count] = extract_empathy(tick_results)
+            signals[:cooperation_ratio] = extract_cooperation(tick_results)
+            signals[:conflict_frequency] = extract_conflict(tick_results)
+            signals[:emotional_volatility] = extract_volatility(tick_results)
+            signals[:mood_stability] = extract_mood_stability(tick_results)
+
+            signals.compact
+          end
+
+          def extract_curiosity(tick_results)
+            tick_results.dig(:working_memory_integration, :intensity) ||
+              tick_results.dig(:curiosity, :intensity)
+          end
+
+          def extract_novelty(tick_results)
+            count = tick_results.dig(:working_memory_integration, :wonder_count) ||
+                    tick_results.dig(:curiosity, :wonder_count)
+            return nil unless count.is_a?(Numeric)
+
+            (count / 10.0).clamp(0.0, 1.0)
+          end
+
+          def extract_prediction(tick_results)
+            tick_results.dig(:prediction_engine, :accuracy) ||
+              tick_results.dig(:prediction, :accuracy)
+          end
+
+          def extract_error_rate(tick_results)
+            accuracy = extract_prediction(tick_results)
+            return nil unless accuracy.is_a?(Numeric)
+
+            1.0 - accuracy
+          end
+
+          def extract_mesh(tick_results)
+            count = tick_results.dig(:mesh_interface, :message_count) ||
+                    tick_results.dig(:mesh, :message_count)
+            return nil unless count.is_a?(Numeric)
+
+            (count / 20.0).clamp(0.0, 1.0)
+          end
+
+          def extract_empathy(tick_results)
+            count = tick_results.dig(:empathy, :model_count)
+            return nil unless count.is_a?(Numeric)
+
+            (count / 10.0).clamp(0.0, 1.0)
+          end
+
+          def extract_cooperation(tick_results)
+            tick_results.dig(:empathy, :cooperation_ratio)
+          end
+
+          def extract_conflict(tick_results)
+            count = tick_results.dig(:conflict, :active_count)
+            return nil unless count.is_a?(Numeric)
+
+            (count / 5.0).clamp(0.0, 1.0)
+          end
+
+          def extract_volatility(tick_results)
+            tick_results.dig(:emotional_evaluation, :volatility) ||
+              tick_results.dig(:emotion, :volatility)
+          end
+
+          def extract_mood_stability(tick_results)
+            tick_results.dig(:mood, :stability)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/legion/extensions/personality/helpers/trait_model.rb

@@ -0,0 +1,143 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module Personality
+      module Helpers
+        class TraitModel
+          attr_reader :traits, :observation_count, :history
+
+          def initialize
+            @traits = Constants::TRAITS.to_h do |trait|
+              [trait, Constants::DEFAULT_TRAIT_VALUE]
+            end
+            @observation_count = 0
+            @history = []
+          end
+
+          def update(signals)
+            observations = extract_observations(signals)
+            return if observations.empty?
+
+            apply_observations(observations)
+            @observation_count += 1
+            record_snapshot
+          end
+
+          def trait(name)
+            @traits[name.to_sym]
+          end
+
+          def formed?
+            @observation_count >= Constants::FORMATION_THRESHOLD
+          end
+
+          def dominant_trait
+            @traits.max_by { |_k, v| (v - 0.5).abs }&.first
+          end
+
+          def trait_level(name)
+            value = @traits[name.to_sym]
+            return nil unless value
+
+            if value >= Constants::HIGH_THRESHOLD
+              :high
+            elsif value <= Constants::LOW_THRESHOLD
+              :low
+            else
+              :mid
+            end
+          end
+
+          def describe(name)
+            level = trait_level(name)
+            return nil unless level
+
+            Constants::TRAIT_DESCRIPTORS.dig(name.to_sym, level)
+          end
+
+          def profile
+            @traits.transform_values { |v| v.round(3) }
+          end
+
+          def stability
+            return 0.0 if @history.size < 5
+
+            recent = @history.last(10)
+            variances = Constants::TRAITS.map do |t|
+              values = recent.map { |h| h[:traits][t] }
+              mean = values.sum / values.size.to_f
+              values.map { |v| (v - mean)**2 }.sum / values.size.to_f
+            end
+            avg_variance = variances.sum / variances.size.to_f
+            (1.0 - (avg_variance * 10)).clamp(0.0, 1.0)
+          end
+
+          def trend(name)
+            return :insufficient_data if @history.size < 5
+
+            values = @history.last(10).map { |h| h[:traits][name.to_sym] }
+            first_half = values[0...(values.size / 2)]
+            second_half = values[(values.size / 2)..]
+            diff = (second_half.sum / second_half.size.to_f) - (first_half.sum / first_half.size.to_f)
+
+            if diff > 0.02
+              :increasing
+            elsif diff < -0.02
+              :decreasing
+            else
+              :stable
+            end
+          end
+
+          def to_h
+            {
+              traits:            profile,
+              observation_count: @observation_count,
+              formed:            formed?,
+              stability:         stability,
+              dominant_trait:    dominant_trait,
+              history_size:      @history.size
+            }
+          end
+
+          private
+
+          def extract_observations(signals)
+            observations = Hash.new { |h, k| h[k] = [] }
+
+            Constants::SIGNAL_MAP.each do |signal_key, (trait, direction, weight)|
+              value = signals[signal_key]
+              next unless value.is_a?(Numeric)
+
+              effective = direction == :positive ? value : 1.0 - value
+              observations[trait] << { value: effective, weight: weight }
+            end
+
+            observations
+          end
+
+          def apply_observations(observations)
+            observations.each do |trait, obs_list|
+              weighted_sum = obs_list.sum { |o| o[:value] * o[:weight] }
+              total_weight = obs_list.sum { |o| o[:weight] }
+              next if total_weight.zero?
+
+              target = (weighted_sum / total_weight).clamp(0.0, 1.0)
+              @traits[trait] = ema(@traits[trait], target, Constants::TRAIT_ALPHA)
+            end
+          end
+
+          def ema(current, observed, alpha)
+            (current * (1.0 - alpha)) + (observed * alpha)
+          end
+
+          def record_snapshot
+            @history << { traits: @traits.dup, at: Time.now.utc }
+            @history.shift while @history.size > Constants::MAX_HISTORY
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,98 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module Personality
+      module Runners
+        module Personality
+          include Legion::Extensions::Helpers::Lex if defined?(Legion::Extensions::Helpers::Lex)
+
+          def update_personality(tick_results: {}, **)
+            personality_store.update(tick_results)
+            model = personality_store.model
+
+            {
+              updated:           true,
+              observation_count: model.observation_count,
+              formed:            model.formed?,
+              profile:           model.profile,
+              dominant_trait:    model.dominant_trait
+            }
+          end
+
+          def personality_profile(**)
+            model = personality_store.model
+            {
+              traits:       model.profile,
+              formed:       model.formed?,
+              stability:    model.stability,
+              dominant:     model.dominant_trait,
+              observations: model.observation_count,
+              history_size: model.history.size
+            }
+          end
+
+          def describe_personality(**)
+            {
+              description: personality_store.full_description,
+              formed:      personality_store.model.formed?
+            }
+          end
+
+          def trait_detail(trait:, **)
+            model = personality_store.model
+            value = model.trait(trait)
+            return { trait: trait.to_sym, error: :unknown_trait } unless value
+
+            {
+              trait:       trait.to_sym,
+              value:       value.round(3),
+              level:       model.trait_level(trait),
+              description: model.describe(trait),
+              trend:       model.trend(trait)
+            }
+          end
+
+          def personality_compatibility(other_profile:, **)
+            score = personality_store.compatibility_score(other_profile)
+            {
+              compatibility:  score,
+              interpretation: interpret_compatibility(score)
+            }
+          end
+
+          def personality_stats(**)
+            model = personality_store.model
+            {
+              observation_count: model.observation_count,
+              formed:            model.formed?,
+              stability:         model.stability,
+              dominant_trait:    model.dominant_trait,
+              profile:           model.profile,
+              history_size:      model.history.size,
+              trait_trends:      Helpers::Constants::TRAITS.to_h { |t| [t, model.trend(t)] }
+            }
+          end
+
+          private
+
+          def interpret_compatibility(score)
+            return :unknown unless score.is_a?(Numeric)
+
+            if score >= 0.85
+              :highly_compatible
+            elsif score >= 0.7
+              :compatible
+            elsif score >= 0.5
+              :neutral
+            elsif score >= 0.3
+              :divergent
+            else
+              :incompatible
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

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

data/lib/legion/extensions/personality.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+require_relative 'personality/version'
+require_relative 'personality/helpers/constants'
+require_relative 'personality/helpers/trait_model'
+require_relative 'personality/helpers/personality_store'
+require_relative 'personality/runners/personality'
+require_relative 'personality/client'
+
+module Legion
+  module Extensions
+    module Personality
+      extend Legion::Extensions::Core if defined?(Legion::Extensions::Core)
+    end
+  end
+end

metadata

@@ -0,0 +1,63 @@
+--- !ruby/object:Gem::Specification
+name: lex-personality
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Matthew Iverson
+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: Big Five personality model emerging from accumulated cognitive behavior
+  patterns
+email:
+- matt@legionIO.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/legion/extensions/personality.rb
+- lib/legion/extensions/personality/client.rb
+- lib/legion/extensions/personality/helpers/constants.rb
+- lib/legion/extensions/personality/helpers/personality_store.rb
+- lib/legion/extensions/personality/helpers/trait_model.rb
+- lib/legion/extensions/personality/runners/personality.rb
+- lib/legion/extensions/personality/version.rb
+homepage: https://github.com/LegionIO/lex-personality
+licenses:
+- MIT
+metadata:
+  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: Emergent personality traits for LegionIO cognitive agents
+test_files: []