lex-cognitive-dissonance-resolution 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: d72d6983434957dfbd52c3215b1e0530ee36b7aad5c77fa4771ab1a36dba77da
+  data.tar.gz: c6920d4a58f990183cdb0265e86e3c86ff252d3e30c523b9bfd6d6fb6ba5dab3
+SHA512:
+  metadata.gz: b3ba90f088180c4cefedf3db2cea4026b26aba7ec5b747054214d792f55b7d2e5d14a6362412ae6c49d18ff29700381c2e70990d46af7623f4fdb349a0d7bc16
+  data.tar.gz: c359e66b35cbf3b35b114ce5ff3ff8cb3ee398e1442f878387b529aaabba29079d30323fb9d010363e382bc9c2f6c6af67cd6bd50bbd3f565c7a2d710bdf04a4

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

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module CognitiveDissonanceResolution
+      class Client
+        include Runners::CognitiveDissonanceResolution
+
+        def engine
+          @engine ||= Helpers::ResolutionEngine.new
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module CognitiveDissonanceResolution
+      module Helpers
+        module Constants
+          MAX_CONFLICTS = 200
+          MAX_STRATEGIES = 50
+
+          DEFAULT_TENSION = 0.5
+          TENSION_DECAY = 0.03
+          RESOLUTION_THRESHOLD = 0.2
+
+          STRATEGIES = %i[
+            belief_change behavior_change add_consonant
+            trivialize reframe seek_information
+            compartmentalize rationalize avoid
+          ].freeze
+
+          TENSION_LABELS = {
+            (0.8..)     => :agonizing,
+            (0.6...0.8) => :distressing,
+            (0.4...0.6) => :uncomfortable,
+            (0.2...0.4) => :mild,
+            (..0.2)     => :resolved
+          }.freeze
+
+          OUTCOME_LABELS = %i[resolved partially_resolved ongoing escalated abandoned].freeze
+        end
+      end
+    end
+  end
+end

data/lib/legion/extensions/cognitive_dissonance_resolution/helpers/dissonance_conflict.rb

@@ -0,0 +1,86 @@
+# frozen_string_literal: true
+
+require 'securerandom'
+
+module Legion
+  module Extensions
+    module CognitiveDissonanceResolution
+      module Helpers
+        class DissonanceConflict
+          include Constants
+
+          attr_reader :id, :belief_a, :belief_b, :domain, :tension,
+                      :strategy_used, :outcome, :attempts, :created_at, :resolved_at
+
+          def initialize(belief_a:, belief_b:, domain: :general, tension: DEFAULT_TENSION)
+            @id            = SecureRandom.uuid
+            @belief_a      = belief_a
+            @belief_b      = belief_b
+            @domain        = domain.to_sym
+            @tension       = tension.to_f.clamp(0.0, 1.0)
+            @strategy_used = nil
+            @outcome       = :ongoing
+            @attempts      = 0
+            @created_at    = Time.now.utc
+            @resolved_at   = nil
+          end
+
+          def tension_label
+            match = TENSION_LABELS.find { |range, _| range.cover?(@tension) }
+            match ? match.last : :resolved
+          end
+
+          def resolved?
+            @tension <= RESOLUTION_THRESHOLD
+          end
+
+          def apply_strategy!(strategy:, effectiveness: 0.3)
+            @strategy_used = strategy.to_sym
+            @attempts += 1
+            reduction = effectiveness.to_f.clamp(0.0, 0.5)
+            @tension = (@tension - reduction).clamp(0.0, 1.0).round(10)
+            @outcome = :resolved if resolved?
+            @resolved_at = Time.now.utc if resolved?
+            self
+          end
+
+          def escalate!(amount: 0.15)
+            @tension = (@tension + amount).clamp(0.0, 1.0).round(10)
+            @outcome = :escalated if @tension >= 0.9
+            self
+          end
+
+          def decay!
+            @tension = (@tension - TENSION_DECAY).clamp(0.0, 1.0).round(10)
+            @outcome = :resolved if resolved? && @outcome == :ongoing
+            @resolved_at = Time.now.utc if resolved? && @resolved_at.nil?
+            self
+          end
+
+          def abandon!
+            @outcome = :abandoned
+            @resolved_at = Time.now.utc
+            self
+          end
+
+          def to_h
+            {
+              id:            @id,
+              belief_a:      @belief_a,
+              belief_b:      @belief_b,
+              domain:        @domain,
+              tension:       @tension,
+              tension_label: tension_label,
+              resolved:      resolved?,
+              strategy_used: @strategy_used,
+              outcome:       @outcome,
+              attempts:      @attempts,
+              created_at:    @created_at,
+              resolved_at:   @resolved_at
+            }
+          end
+        end
+      end
+    end
+  end
+end

data/lib/legion/extensions/cognitive_dissonance_resolution/helpers/resolution_engine.rb

@@ -0,0 +1,151 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module CognitiveDissonanceResolution
+      module Helpers
+        class ResolutionEngine
+          include Constants
+
+          def initialize
+            @conflicts         = {}
+            @strategy_history  = Hash.new(0)
+            @strategy_successes = Hash.new(0)
+          end
+
+          def create_conflict(belief_a:, belief_b:, domain: :general, tension: DEFAULT_TENSION)
+            prune_if_needed
+            conflict = DissonanceConflict.new(
+              belief_a: belief_a,
+              belief_b: belief_b,
+              domain:   domain,
+              tension:  tension
+            )
+            @conflicts[conflict.id] = conflict
+            conflict
+          end
+
+          def apply_strategy(conflict_id:, strategy:, effectiveness: 0.3)
+            conflict = @conflicts[conflict_id]
+            return nil unless conflict
+
+            strat = strategy.to_sym
+            @strategy_history[strat] += 1
+            conflict.apply_strategy!(strategy: strat, effectiveness: effectiveness)
+            @strategy_successes[strat] += 1 if conflict.resolved?
+            conflict
+          end
+
+          def escalate_conflict(conflict_id:, amount: 0.15)
+            conflict = @conflicts[conflict_id]
+            return nil unless conflict
+
+            conflict.escalate!(amount: amount)
+          end
+
+          def abandon_conflict(conflict_id:)
+            conflict = @conflicts[conflict_id]
+            return nil unless conflict
+
+            conflict.abandon!
+          end
+
+          def decay_all
+            @conflicts.each_value(&:decay!)
+            @conflicts.size
+          end
+
+          def best_strategy
+            return nil if @strategy_history.empty?
+
+            @strategy_history.max_by do |strat, uses|
+              rate = uses.positive? ? @strategy_successes[strat].to_f / uses : 0.0
+              rate
+            end&.first
+          end
+
+          def strategy_report
+            STRATEGIES.map do |strat|
+              uses = @strategy_history[strat]
+              successes = @strategy_successes[strat]
+              {
+                strategy:     strat,
+                uses:         uses,
+                successes:    successes,
+                success_rate: uses.positive? ? (successes.to_f / uses).round(4) : 0.0
+              }
+            end
+          end
+
+          def ongoing_conflicts
+            @conflicts.values.select { |c| c.outcome == :ongoing }
+          end
+
+          def resolved_conflicts
+            @conflicts.values.select { |c| c.outcome == :resolved }
+          end
+
+          def conflicts_by_domain(domain:)
+            d = domain.to_sym
+            @conflicts.values.select { |c| c.domain == d }
+          end
+
+          def most_tense(limit: 5)
+            @conflicts.values.sort_by { |c| -c.tension }.first(limit)
+          end
+
+          def resolution_rate
+            total = @conflicts.size
+            return 0.0 if total.zero?
+
+            resolved = resolved_conflicts.size
+            (resolved.to_f / total).round(4)
+          end
+
+          def average_tension
+            return 0.0 if @conflicts.empty?
+
+            tensions = @conflicts.values.map(&:tension)
+            (tensions.sum / tensions.size).round(10)
+          end
+
+          def dissonance_report
+            {
+              total_conflicts: @conflicts.size,
+              ongoing:         ongoing_conflicts.size,
+              resolved:        resolved_conflicts.size,
+              resolution_rate: resolution_rate,
+              average_tension: average_tension,
+              best_strategy:   best_strategy,
+              most_tense:      most_tense(limit: 3).map(&:to_h)
+            }
+          end
+
+          def to_h
+            {
+              total_conflicts: @conflicts.size,
+              ongoing:         ongoing_conflicts.size,
+              resolved:        resolved_conflicts.size,
+              resolution_rate: resolution_rate,
+              average_tension: average_tension
+            }
+          end
+
+          private
+
+          def prune_if_needed
+            return if @conflicts.size < MAX_CONFLICTS
+
+            oldest_resolved = resolved_conflicts.min_by(&:created_at)
+            if oldest_resolved
+              @conflicts.delete(oldest_resolved.id)
+            else
+              lowest = @conflicts.values.min_by(&:tension)
+              @conflicts.delete(lowest.id) if lowest
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,70 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module CognitiveDissonanceResolution
+      module Runners
+        module CognitiveDissonanceResolution
+          include Legion::Extensions::Helpers::Lex if defined?(Legion::Extensions::Helpers::Lex)
+
+          def create_dissonance_conflict(belief_a:, belief_b:, domain: :general,
+                                         tension: nil, **)
+            t = tension || Helpers::Constants::DEFAULT_TENSION
+            conflict = engine.create_conflict(belief_a: belief_a, belief_b: belief_b,
+                                              domain: domain, tension: t)
+            { success: true }.merge(conflict.to_h)
+          end
+
+          def apply_resolution_strategy(conflict_id:, strategy:, effectiveness: 0.3, **)
+            result = engine.apply_strategy(conflict_id: conflict_id, strategy: strategy,
+                                           effectiveness: effectiveness)
+            return { success: false, error: 'conflict not found' } unless result
+
+            { success: true }.merge(result.to_h)
+          end
+
+          def escalate_dissonance(conflict_id:, amount: 0.15, **)
+            result = engine.escalate_conflict(conflict_id: conflict_id, amount: amount)
+            return { success: false, error: 'conflict not found' } unless result
+
+            { success: true }.merge(result.to_h)
+          end
+
+          def abandon_dissonance(conflict_id:, **)
+            result = engine.abandon_conflict(conflict_id: conflict_id)
+            return { success: false, error: 'conflict not found' } unless result
+
+            { success: true }.merge(result.to_h)
+          end
+
+          def ongoing_dissonance_report(**)
+            conflicts = engine.ongoing_conflicts
+            { success: true, count: conflicts.size, conflicts: conflicts.map(&:to_h) }
+          end
+
+          def most_tense_report(limit: 5, **)
+            conflicts = engine.most_tense(limit: limit)
+            { success: true, limit: limit, conflicts: conflicts.map(&:to_h) }
+          end
+
+          def strategy_effectiveness_report(**)
+            { success: true, strategies: engine.strategy_report, best: engine.best_strategy }
+          end
+
+          def dissonance_report(**)
+            engine.dissonance_report
+          end
+
+          def update_dissonance_resolution(**)
+            decayed = engine.decay_all
+            { success: true, decayed: decayed, stats: engine.to_h }
+          end
+
+          def dissonance_resolution_stats(**)
+            engine.to_h
+          end
+        end
+      end
+    end
+  end
+end

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

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

data/lib/legion/extensions/cognitive_dissonance_resolution.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+require_relative 'cognitive_dissonance_resolution/version'
+require_relative 'cognitive_dissonance_resolution/helpers/constants'
+require_relative 'cognitive_dissonance_resolution/helpers/dissonance_conflict'
+require_relative 'cognitive_dissonance_resolution/helpers/resolution_engine'
+require_relative 'cognitive_dissonance_resolution/runners/cognitive_dissonance_resolution'
+require_relative 'cognitive_dissonance_resolution/client'
+
+module Legion
+  module Extensions
+    module CognitiveDissonanceResolution
+      extend Legion::Extensions::Core if defined?(Legion::Extensions::Core)
+    end
+  end
+end

metadata

@@ -0,0 +1,68 @@
+--- !ruby/object:Gem::Specification
+name: lex-cognitive-dissonance-resolution
+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: Models dissonance conflicts between beliefs and applies resolution strategies
+  (belief change, rationalization, reframing) with effectiveness tracking.
+email:
+- matthewdiverson@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/legion/extensions/cognitive_dissonance_resolution.rb
+- lib/legion/extensions/cognitive_dissonance_resolution/client.rb
+- lib/legion/extensions/cognitive_dissonance_resolution/helpers/constants.rb
+- lib/legion/extensions/cognitive_dissonance_resolution/helpers/dissonance_conflict.rb
+- lib/legion/extensions/cognitive_dissonance_resolution/helpers/resolution_engine.rb
+- lib/legion/extensions/cognitive_dissonance_resolution/runners/cognitive_dissonance_resolution.rb
+- lib/legion/extensions/cognitive_dissonance_resolution/version.rb
+homepage: https://github.com/LegionIO/lex-cognitive-dissonance-resolution
+licenses:
+- MIT
+metadata:
+  homepage_uri: https://github.com/LegionIO/lex-cognitive-dissonance-resolution
+  source_code_uri: https://github.com/LegionIO/lex-cognitive-dissonance-resolution
+  documentation_uri: https://github.com/LegionIO/lex-cognitive-dissonance-resolution
+  changelog_uri: https://github.com/LegionIO/lex-cognitive-dissonance-resolution/blob/main/CHANGELOG.md
+  bug_tracker_uri: https://github.com/LegionIO/lex-cognitive-dissonance-resolution/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 dissonance resolution strategies for LegionIO
+test_files: []