lex-agentic-affect 0.1.0

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

@@ -0,0 +1,97 @@
+# frozen_string_literal: true
+
+require 'securerandom'
+
+module Legion
+  module Extensions
+    module Agentic
+      module Affect
+        module Contagion
+          module Helpers
+            class Meme
+              attr_reader :id, :label, :contagion_type, :virulence,
+                          :carriers, :recovered, :immune,
+                          :total_transmissions, :created_at
+
+              def initialize(label:, contagion_type: :cognitive, virulence: Constants::DEFAULT_VIRULENCE)
+                @id                  = SecureRandom.uuid
+                @label               = label
+                @contagion_type      = validate_contagion_type(contagion_type)
+                @virulence           = virulence.clamp(0.0, 1.0).round(10)
+                @carriers            = Set.new
+                @recovered           = Set.new
+                @immune              = Set.new
+                @total_transmissions = 0
+                @created_at          = Time.now.utc
+              end
+
+              def virulence_label
+                Constants::VIRULENCE_LABELS.find { |range, _| range.cover?(@virulence) }&.last || :contained
+              end
+
+              def carrier_count
+                @carriers.size
+              end
+
+              def transmission_rate
+                return 0.0 if @carriers.empty?
+
+                (@total_transmissions.to_f / @carriers.size).round(10)
+              end
+
+              def infect!(agent_id:)
+                return :already_carrier if @carriers.include?(agent_id)
+                return :immune          if @immune.include?(agent_id)
+
+                @carriers.add(agent_id)
+                @recovered.delete(agent_id)
+                @total_transmissions += 1
+                :infected
+              end
+
+              def recover!(agent_id:)
+                return :not_a_carrier unless @carriers.include?(agent_id)
+
+                @carriers.delete(agent_id)
+                @recovered.add(agent_id)
+                :recovered
+              end
+
+              def immunize!(agent_id:)
+                @carriers.delete(agent_id)
+                @immune.add(agent_id)
+                :immunized
+              end
+
+              def carrying?(agent_id:)
+                @carriers.include?(agent_id)
+              end
+
+              def to_h
+                {
+                  id:                  @id,
+                  label:               @label,
+                  contagion_type:      @contagion_type,
+                  virulence:           @virulence,
+                  virulence_label:     virulence_label,
+                  carrier_count:       carrier_count,
+                  recovered_count:     @recovered.size,
+                  immune_count:        @immune.size,
+                  total_transmissions: @total_transmissions,
+                  transmission_rate:   transmission_rate,
+                  created_at:          @created_at
+                }
+              end
+
+              private
+
+              def validate_contagion_type(type)
+                Constants::CONTAGION_TYPES.include?(type) ? type : :cognitive
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/legion/extensions/agentic/affect/contagion/runners/cognitive_contagion.rb

@@ -0,0 +1,125 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module Agentic
+      module Affect
+        module Contagion
+          module Runners
+            module CognitiveContagion
+              include Legion::Extensions::Helpers::Lex if Legion::Extensions.const_defined?(:Helpers) &&
+                                                          Legion::Extensions::Helpers.const_defined?(:Lex)
+
+              def create_meme(label:, contagion_type: :cognitive, virulence: nil, **)
+                v      = virulence || Helpers::Constants::DEFAULT_VIRULENCE
+                result = engine.create_meme(label: label, contagion_type: contagion_type, virulence: v)
+
+                if result.is_a?(Hash) && result[:error]
+                  Legion::Logging.warn "[cognitive_contagion] create_meme failed: #{result[:error]}"
+                  return result
+                end
+
+                Legion::Logging.info "[cognitive_contagion] meme created: id=#{result.id} label=#{label} " \
+                                     "virulence=#{result.virulence} type=#{contagion_type}"
+                result.to_h
+              end
+
+              def register_agent(agent_id:, resistance: nil, **)
+                r      = resistance || Helpers::Constants::DEFAULT_RESISTANCE
+                result = engine.register_agent(agent_id: agent_id, resistance: r)
+
+                if result.is_a?(Hash) && result[:error]
+                  Legion::Logging.warn "[cognitive_contagion] register_agent failed: #{result[:error]}"
+                  return result
+                end
+
+                Legion::Logging.debug "[cognitive_contagion] agent registered: id=#{agent_id} resistance=#{r}"
+                result
+              end
+
+              def attempt_transmission(meme_id:, source_agent_id:, target_agent_id:, **)
+                result = engine.attempt_transmission(
+                  meme_id:         meme_id,
+                  source_agent_id: source_agent_id,
+                  target_agent_id: target_agent_id
+                )
+                Legion::Logging.debug "[cognitive_contagion] transmission: meme=#{meme_id} " \
+                                      "#{source_agent_id}->#{target_agent_id} transmitted=#{result[:transmitted]}"
+                result
+              end
+
+              def recover_agent(meme_id:, agent_id:, **)
+                result = engine.recover_agent(meme_id: meme_id, agent_id: agent_id)
+                Legion::Logging.debug "[cognitive_contagion] recover: meme=#{meme_id} agent=#{agent_id} " \
+                                      "result=#{result[:result]}"
+                result
+              end
+
+              def infect_agent(meme_id:, agent_id:, **)
+                meme = engine.memes[meme_id]
+                return { infected: false, reason: :meme_not_found } unless meme
+
+                result = meme.infect!(agent_id: agent_id)
+                Legion::Logging.debug "[cognitive_contagion] infect_agent: meme=#{meme_id} agent=#{agent_id} result=#{result}"
+                { infected: result == :infected, agent_id: agent_id, meme_id: meme_id, result: result }
+              end
+
+              def immunize_agent(meme_id:, agent_id:, **)
+                result = engine.immunize_agent(meme_id: meme_id, agent_id: agent_id)
+                Legion::Logging.debug "[cognitive_contagion] immunize: meme=#{meme_id} agent=#{agent_id}"
+                result
+              end
+
+              def spread_step(meme_id:, **)
+                result = engine.spread_step(meme_id: meme_id)
+                Legion::Logging.info "[cognitive_contagion] spread_step: meme=#{meme_id} " \
+                                     "transmissions=#{result[:transmissions]} recoveries=#{result[:recoveries]}"
+                result
+              end
+
+              def epidemic_report(meme_id:, **)
+                result = engine.epidemic_report(meme_id: meme_id)
+                Legion::Logging.debug "[cognitive_contagion] epidemic_report: meme=#{meme_id} " \
+                                      "infected=#{result[:infected]} virulence_label=#{result[:virulence_label]}"
+                result
+              end
+
+              def most_viral(limit: 5, **)
+                results = engine.most_viral(limit: limit)
+                Legion::Logging.debug "[cognitive_contagion] most_viral: limit=#{limit} count=#{results.size}"
+                { memes: results, count: results.size }
+              end
+
+              def agent_status(agent_id:, meme_id:, **)
+                result = engine.agent_status(agent_id: agent_id, meme_id: meme_id)
+                Legion::Logging.debug "[cognitive_contagion] agent_status: agent=#{agent_id} " \
+                                      "meme=#{meme_id} status=#{result[:status]}"
+                result
+              end
+
+              def susceptible_agents(meme_id:, **)
+                agents = engine.susceptible_agents(meme_id: meme_id)
+                Legion::Logging.debug "[cognitive_contagion] susceptible_agents: meme=#{meme_id} count=#{agents.size}"
+                { agents: agents, count: agents.size, meme_id: meme_id }
+              end
+
+              def contagion_status(**)
+                Legion::Logging.debug '[cognitive_contagion] contagion_status requested'
+                summary = engine.to_h.slice(:meme_count, :agent_count)
+                summary.merge(contagion_types: Helpers::Constants::CONTAGION_TYPES,
+                              max_agents:      Helpers::Constants::MAX_AGENTS,
+                              max_memes:       Helpers::Constants::MAX_MEMES)
+              end
+
+              private
+
+              def engine
+                @engine ||= Helpers::ContagionEngine.new
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

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

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

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+require 'legion/extensions/agentic/affect/contagion/version'
+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'
+require 'legion/extensions/agentic/affect/contagion/client'
+
+module Legion
+  module Extensions
+    module Agentic
+      module Affect
+        module Contagion
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+require 'legion/extensions/agentic/affect/defusion/helpers/constants'
+require 'legion/extensions/agentic/affect/defusion/helpers/thought'
+require 'legion/extensions/agentic/affect/defusion/helpers/defusion_engine'
+require 'legion/extensions/agentic/affect/defusion/runners/cognitive_defusion'
+
+module Legion
+  module Extensions
+    module Agentic
+      module Affect
+        module Defusion
+          class Client
+            include Runners::CognitiveDefusion
+
+            def initialize(engine: nil)
+              @defusion_engine = engine || Helpers::DefusionEngine.new
+            end
+
+            private
+
+            attr_reader :defusion_engine
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,64 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module Agentic
+      module Affect
+        module Defusion
+          module Helpers
+            module Constants
+              MAX_THOUGHTS       = 300
+              DEFAULT_FUSION     = 0.7
+              FUSION_DELTA_FUSE  = 0.05
+              FUSION_DELTA_VISIT = 0.02
+
+              DEFUSION_TECHNIQUES = %i[labeling distancing contextualization acceptance reframing metaphor].freeze
+
+              TECHNIQUE_POTENCY = {
+                labeling:          0.08,
+                distancing:        0.12,
+                contextualization: 0.10,
+                acceptance:        0.15,
+                reframing:         0.10,
+                metaphor:          0.06
+              }.freeze
+
+              FUSION_LABELS = {
+                (0.8..)     => :enmeshed,
+                (0.6...0.8) => :fused,
+                (0.4...0.6) => :partially_fused,
+                (0.2...0.4) => :defused,
+                (..0.2)     => :fully_defused
+              }.freeze
+
+              BELIEF_LABELS = {
+                (0.8..)     => :entrenched,
+                (0.6...0.8) => :strong,
+                (0.4...0.6) => :moderate,
+                (0.2...0.4) => :weak,
+                (..0.2)     => :negligible
+              }.freeze
+
+              FUSION_THRESHOLD  = 0.7
+              DEFUSED_THRESHOLD = 0.3
+              RUMINATION_COUNT  = 3
+
+              THOUGHT_TYPES = %i[belief assumption evaluation prediction judgment self_concept rule].freeze
+
+              # Technique recommendations by thought type
+              RECOMMENDED_TECHNIQUES = {
+                belief:       :acceptance,
+                assumption:   :contextualization,
+                evaluation:   :distancing,
+                prediction:   :reframing,
+                judgment:     :labeling,
+                self_concept: :distancing,
+                rule:         :contextualization
+              }.freeze
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/legion/extensions/agentic/affect/defusion/helpers/defusion_engine.rb

@@ -0,0 +1,167 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module Agentic
+      module Affect
+        module Defusion
+          module Helpers
+            class DefusionEngine
+              include Constants
+
+              attr_reader :thoughts, :defusion_history
+
+              def initialize
+                @thoughts         = {}
+                @defusion_history = []
+              end
+
+              def register_thought(content:, thought_type:, belief_strength: 0.5)
+                return { error: :invalid_thought_type, valid: THOUGHT_TYPES } unless THOUGHT_TYPES.include?(thought_type)
+
+                if @thoughts.size >= MAX_THOUGHTS
+                  oldest = @thoughts.values.min_by(&:created_at)
+                  @thoughts.delete(oldest.id) if oldest
+                end
+
+                thought = Thought.new(content: content, thought_type: thought_type, belief_strength: belief_strength)
+                @thoughts[thought.id] = thought
+                { thought_id: thought.id, thought: thought.to_h }
+              end
+
+              def apply_defusion(thought_id:, technique:)
+                thought = @thoughts[thought_id]
+                return { error: :thought_not_found } unless thought
+                return { error: :invalid_technique, valid: DEFUSION_TECHNIQUES } unless DEFUSION_TECHNIQUES.include?(technique)
+
+                before_fusion = thought.fusion_level
+                result = thought.defuse!(technique: technique)
+
+                @defusion_history << {
+                  thought_id:    thought_id,
+                  technique:     technique,
+                  before_fusion: before_fusion,
+                  after_fusion:  thought.fusion_level,
+                  at:            Time.now.utc
+                }
+
+                {
+                  success:      true,
+                  thought_id:   thought_id,
+                  technique:    technique,
+                  before:       result[:before],
+                  after:        result[:after],
+                  reduction:    result[:reduction],
+                  fusion_label: thought.fusion_label,
+                  defused:      thought.defused?
+                }
+              end
+
+              def apply_all_techniques(thought_id:)
+                thought = @thoughts[thought_id]
+                return { error: :thought_not_found } unless thought
+
+                results = DEFUSION_TECHNIQUES.map do |technique|
+                  apply_defusion(thought_id: thought_id, technique: technique)
+                end
+
+                {
+                  thought_id:    thought_id,
+                  techniques:    results,
+                  final_fusion:  thought.fusion_level,
+                  fusion_label:  thought.fusion_label,
+                  defused:       thought.defused?,
+                  total_applied: results.size
+                }
+              end
+
+              def visit_thought(thought_id:)
+                thought = @thoughts[thought_id]
+                return { error: :thought_not_found } unless thought
+
+                result = thought.visit!
+                {
+                  thought_id:  thought_id,
+                  visit_count: result[:visit_count],
+                  fusion:      thought.fusion_level,
+                  ruminating:  thought.ruminating?
+                }
+              end
+
+              def enmeshed_thoughts
+                @thoughts.values.select(&:enmeshed?)
+              end
+
+              def defused_thoughts
+                @thoughts.values.select(&:defused?)
+              end
+
+              def ruminating_thoughts
+                @thoughts.values.select(&:ruminating?)
+              end
+
+              def most_fused(limit: 5)
+                @thoughts.values
+                         .sort_by { |t| -t.fusion_level }
+                         .first(limit)
+              end
+
+              def recommend_technique(thought_id:)
+                thought = @thoughts[thought_id]
+                return { error: :thought_not_found } unless thought
+
+                technique = RECOMMENDED_TECHNIQUES.fetch(thought.thought_type, :acceptance)
+                potency   = TECHNIQUE_POTENCY[technique]
+
+                {
+                  thought_id:       thought_id,
+                  thought_type:     thought.thought_type,
+                  technique:        technique,
+                  potency:          potency,
+                  current_fusion:   thought.fusion_level,
+                  projected_fusion: (thought.fusion_level - potency).clamp(0.0, 1.0).round(10)
+                }
+              end
+
+              def average_fusion
+                return 0.0 if @thoughts.empty?
+
+                total = @thoughts.values.sum(&:fusion_level)
+                (total / @thoughts.size).round(10)
+              end
+
+              def defusion_effectiveness
+                return 0.0 if @defusion_history.empty?
+
+                total_reduction = @defusion_history.sum { |h| h[:before_fusion] - h[:after_fusion] }
+                (total_reduction / @defusion_history.size).round(10)
+              end
+
+              def defusion_report
+                all = @thoughts.values
+                {
+                  total_thoughts:         all.size,
+                  enmeshed_count:         all.count(&:enmeshed?),
+                  defused_count:          all.count(&:defused?),
+                  ruminating_count:       all.count(&:ruminating?),
+                  average_fusion:         average_fusion,
+                  defusion_attempts:      @defusion_history.size,
+                  defusion_effectiveness: defusion_effectiveness,
+                  most_fused:             most_fused(limit: 3).map(&:to_h)
+                }
+              end
+
+              def to_h
+                {
+                  thoughts:         @thoughts.transform_values(&:to_h),
+                  defusion_history: @defusion_history,
+                  report:           defusion_report
+                }
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/legion/extensions/agentic/affect/defusion/helpers/thought.rb

@@ -0,0 +1,92 @@
+# frozen_string_literal: true
+
+require 'securerandom'
+
+module Legion
+  module Extensions
+    module Agentic
+      module Affect
+        module Defusion
+          module Helpers
+            class Thought
+              include Constants
+
+              attr_reader :id, :content, :thought_type, :belief_strength,
+                          :fusion_level, :defusion_count, :visit_count, :created_at
+
+              def initialize(content:, thought_type:, belief_strength:)
+                @id              = SecureRandom.uuid
+                @content         = content
+                @thought_type    = thought_type
+                @belief_strength = belief_strength.clamp(0.0, 1.0)
+                @fusion_level    = DEFAULT_FUSION
+                @defusion_count  = 0
+                @visit_count     = 0
+                @created_at      = Time.now.utc
+              end
+
+              def defuse!(technique:)
+                potency = TECHNIQUE_POTENCY.fetch(technique, 0.0)
+                before  = @fusion_level
+                @fusion_level = (@fusion_level - potency).clamp(0.0, 1.0).round(10)
+                @defusion_count += 1
+                { before: before, after: @fusion_level, technique: technique, reduction: (before - @fusion_level).round(10) }
+              end
+
+              def fuse!
+                before = @fusion_level
+                @fusion_level = (@fusion_level + FUSION_DELTA_FUSE).clamp(0.0, 1.0).round(10)
+                { before: before, after: @fusion_level }
+              end
+
+              def visit!
+                @visit_count += 1
+                before = @fusion_level
+                @fusion_level = (@fusion_level + FUSION_DELTA_VISIT).clamp(0.0, 1.0).round(10)
+                { visit_count: @visit_count, fusion_before: before, fusion_after: @fusion_level }
+              end
+
+              def enmeshed?
+                @fusion_level >= FUSION_THRESHOLD
+              end
+
+              def defused?
+                @fusion_level <= DEFUSED_THRESHOLD
+              end
+
+              def ruminating?
+                @visit_count >= RUMINATION_COUNT
+              end
+
+              def fusion_label
+                FUSION_LABELS.find { |range, _| range.cover?(@fusion_level) }&.last || :unknown
+              end
+
+              def belief_label
+                BELIEF_LABELS.find { |range, _| range.cover?(@belief_strength) }&.last || :unknown
+              end
+
+              def to_h
+                {
+                  id:              @id,
+                  content:         @content,
+                  thought_type:    @thought_type,
+                  belief_strength: @belief_strength,
+                  fusion_level:    @fusion_level,
+                  defusion_count:  @defusion_count,
+                  visit_count:     @visit_count,
+                  fusion_label:    fusion_label,
+                  belief_label:    belief_label,
+                  enmeshed:        enmeshed?,
+                  defused:         defused?,
+                  ruminating:      ruminating?,
+                  created_at:      @created_at
+                }
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end