lex-agentic-memory 0.1.0

data/lib/legion/extensions/agentic/memory/echo/helpers/echo_engine.rb

@@ -0,0 +1,136 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module Agentic
+      module Memory
+        module Echo
+          module Helpers
+            class EchoEngine
+              include Constants
+
+              def initialize
+                @echoes = {}
+              end
+
+              def create_echo(content:, echo_type: :thought, domain: :general, intensity: DEFAULT_INTENSITY)
+                prune_silent
+                echo = Echo.new(content: content, echo_type: echo_type, domain: domain, intensity: intensity)
+                @echoes[echo.id] = echo
+                echo
+              end
+
+              def reinforce_echo(echo_id:, amount: REINFORCEMENT)
+                echo = @echoes[echo_id]
+                return nil unless echo
+
+                echo.reinforce!(amount)
+                echo
+              end
+
+              def decay_all!
+                @echoes.each_value(&:decay!)
+                prune_silent
+                { echoes_decayed: @echoes.size, pruned: count_silent }
+              end
+
+              def active_echoes = @echoes.values.select(&:active?)
+              def priming_echoes = @echoes.values.select(&:priming?)
+              def interfering_echoes = @echoes.values.select(&:interfering?)
+
+              def echoes_by_type(echo_type:)
+                @echoes.values.select { |e| e.echo_type == echo_type.to_sym }
+              end
+
+              def echoes_by_domain(domain:)
+                @echoes.values.select { |e| e.domain == domain.to_sym }
+              end
+
+              def strongest_echoes(limit: 5) = @echoes.values.sort_by { |e| -e.intensity }.first(limit)
+              def faintest_echoes(limit: 5) = @echoes.values.select(&:active?).sort_by(&:intensity).first(limit)
+
+              def echo_chamber_score
+                return 0.0 if @echoes.empty?
+
+                domains = @echoes.values.map(&:domain).uniq
+                return 1.0 if domains.size <= 1
+
+                domain_concentration(domains)
+              end
+
+              def chamber_label = Constants.label_for(CHAMBER_LABELS, echo_chamber_score)
+
+              def priming_effect_for(domain:)
+                matching = echoes_by_domain(domain: domain).select(&:priming?)
+                return 0.0 if matching.empty?
+
+                matching.sum(&:intensity).clamp(0.0, 1.0).round(10)
+              end
+
+              def interference_level
+                interfering = interfering_echoes
+                return 0.0 if interfering.empty?
+
+                (interfering.sum(&:intensity) / @echoes.size).clamp(0.0, 1.0).round(10)
+              end
+
+              def average_intensity
+                return 0.0 if @echoes.empty?
+
+                (@echoes.values.sum(&:intensity) / @echoes.size).round(10)
+              end
+
+              def echo_report
+                {
+                  total_echoes:       @echoes.size,
+                  active_count:       active_echoes.size,
+                  priming_count:      priming_echoes.size,
+                  interfering_count:  interfering_echoes.size,
+                  average_intensity:  average_intensity,
+                  echo_chamber_score: echo_chamber_score,
+                  chamber_label:      chamber_label,
+                  interference_level: interference_level,
+                  strongest:          strongest_echoes(limit: 3).map(&:to_h)
+                }
+              end
+
+              def to_h
+                {
+                  total_echoes:      @echoes.size,
+                  active:            active_echoes.size,
+                  average_intensity: average_intensity,
+                  chamber_score:     echo_chamber_score
+                }
+              end
+
+              private
+
+              def domain_concentration(domains)
+                intensities = domains.map { |d| @echoes.values.select { |e| e.domain == d }.sum(&:intensity) }
+                total = intensities.sum
+                return 0.0 if total.zero?
+
+                (intensities.max / total).round(10)
+              end
+
+              def count_silent
+                @echoes.values.count(&:silent?)
+              end
+
+              def prune_silent
+                return if @echoes.size < MAX_ECHOES
+
+                silent = @echoes.values.select(&:silent?)
+                silent.each { |e| @echoes.delete(e.id) }
+                return unless @echoes.size >= MAX_ECHOES
+
+                faintest = @echoes.values.min_by(&:intensity)
+                @echoes.delete(faintest.id) if faintest
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/legion/extensions/agentic/memory/echo/runners/cognitive_echo.rb

@@ -0,0 +1,81 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module Agentic
+      module Memory
+        module Echo
+          module Runners
+            module CognitiveEcho
+              include Legion::Extensions::Helpers::Lex if defined?(Legion::Extensions::Helpers::Lex)
+
+              def create_echo(content:, echo_type: :thought, domain: :general, intensity: 0.8, engine: nil, **)
+                eng = engine || default_engine
+                echo = eng.create_echo(content: content, echo_type: echo_type, domain: domain, intensity: intensity)
+                { success: true, echo: echo.to_h }
+              end
+
+              def reinforce_echo(echo_id:, amount: 0.15, engine: nil, **)
+                eng = engine || default_engine
+                echo = eng.reinforce_echo(echo_id: echo_id, amount: amount)
+                return { success: false, error: 'echo not found' } unless echo
+
+                { success: true, echo: echo.to_h }
+              end
+
+              def decay_all(engine: nil, **)
+                eng = engine || default_engine
+                result = eng.decay_all!
+                { success: true, **result }
+              end
+
+              def active_echoes(engine: nil, **)
+                eng = engine || default_engine
+                { success: true, echoes: eng.active_echoes.map(&:to_h), count: eng.active_echoes.size }
+              end
+
+              def priming_echoes(engine: nil, **)
+                eng = engine || default_engine
+                { success: true, echoes: eng.priming_echoes.map(&:to_h), count: eng.priming_echoes.size }
+              end
+
+              def interfering_echoes(engine: nil, **)
+                eng = engine || default_engine
+                { success: true, echoes: eng.interfering_echoes.map(&:to_h), count: eng.interfering_echoes.size }
+              end
+
+              def echoes_by_domain(domain:, engine: nil, **)
+                eng = engine || default_engine
+                echoes = eng.echoes_by_domain(domain: domain)
+                { success: true, echoes: echoes.map(&:to_h), count: echoes.size }
+              end
+
+              def strongest_echoes(limit: 5, engine: nil, **)
+                eng = engine || default_engine
+                { success: true, echoes: eng.strongest_echoes(limit: limit).map(&:to_h) }
+              end
+
+              def priming_effect(domain:, engine: nil, **)
+                eng = engine || default_engine
+                effect = eng.priming_effect_for(domain: domain)
+                label = Helpers::Constants.label_for(Helpers::Constants::EFFECT_LABELS, effect)
+                { success: true, domain: domain.to_sym, priming_effect: effect, effect_label: label }
+              end
+
+              def echo_status(engine: nil, **)
+                eng = engine || default_engine
+                { success: true, **eng.echo_report }
+              end
+
+              private
+
+              def default_engine
+                @default_engine ||= Helpers::EchoEngine.new
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/legion/extensions/agentic/memory/echo/version.rb

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

data/lib/legion/extensions/agentic/memory/echo.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+require_relative 'echo/version'
+require_relative 'echo/helpers/constants'
+require_relative 'echo/helpers/echo'
+require_relative 'echo/helpers/echo_engine'
+require_relative 'echo/runners/cognitive_echo'
+require_relative 'echo/client'
+
+module Legion
+  module Extensions
+    module Agentic
+      module Memory
+        module Echo
+        end
+      end
+    end
+  end
+end

data/lib/legion/extensions/agentic/memory/echo_chamber/client.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module Agentic
+      module Memory
+        module EchoChamber
+          class Client
+            include Runners::CognitiveEchoChamber
+
+            def initialize(engine: nil)
+              @default_engine = engine || Helpers::ChamberEngine.new
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/legion/extensions/agentic/memory/echo_chamber/helpers/chamber.rb

@@ -0,0 +1,134 @@
+# frozen_string_literal: true
+
+require 'securerandom'
+
+module Legion
+  module Extensions
+    module Agentic
+      module Memory
+        module EchoChamber
+          module Helpers
+            class Chamber
+              include Constants
+
+              attr_reader :id, :label, :domain, :state, :wall_thickness,
+                          :resonance_frequency, :created_at, :disruption_count
+
+              def initialize(label:, domain: :general, wall_thickness: DEFAULT_WALL_THICKNESS)
+                @id                  = SecureRandom.uuid
+                @label               = label
+                @domain              = domain.to_sym
+                @state               = :forming
+                @wall_thickness      = wall_thickness.to_f.clamp(0.0, 1.0).round(10)
+                @resonance_frequency = 0.0
+                @echoes              = {}
+                @disruption_count    = 0
+                @created_at          = Time.now.utc
+              end
+
+              def add_echo(echo)
+                return false if @echoes.size >= MAX_ECHOES
+
+                @echoes[echo.id] = echo
+                recalculate_resonance
+                update_state
+                true
+              end
+
+              def remove_echo(echo_id)
+                removed = @echoes.delete(echo_id)
+                recalculate_resonance if removed
+                update_state
+                !removed.nil?
+              end
+
+              def amplify_all!(rate = AMPLIFICATION_RATE)
+                @echoes.each_value { |e| e.amplify!(rate) }
+                recalculate_resonance
+                update_state
+                { amplified: @echoes.size, resonance_frequency: @resonance_frequency }
+              end
+
+              def disrupt!(force)
+                force = force.to_f.clamp(0.0, 1.0)
+                return { success: false, reason: 'insufficient_force', force: force, wall: @wall_thickness } if force <= @wall_thickness
+
+                @disruption_count += 1
+                breakthrough = force - @wall_thickness
+                @wall_thickness = (@wall_thickness - (breakthrough * BREAKTHROUGH_BONUS)).clamp(0.0, 1.0).round(10)
+                @echoes.each_value { |e| e.dampen!(breakthrough.round(10)) }
+                @state = :disrupted
+                recalculate_resonance
+                { success: true, force: force, breakthrough: breakthrough.round(10), wall_remaining: @wall_thickness }
+              end
+
+              def sealed?
+                @wall_thickness >= SEALED_THRESHOLD
+              end
+
+              def porous?
+                @wall_thickness <= POROUS_THRESHOLD
+              end
+
+              def resonance_level
+                Constants.label_for(RESONANCE_LABELS, @resonance_frequency)
+              end
+
+              def echo_count
+                @echoes.size
+              end
+
+              def active_echoes
+                @echoes.values.reject(&:silent?)
+              end
+
+              def resonating_echoes
+                @echoes.values.select(&:resonate?)
+              end
+
+              def to_h
+                {
+                  id:                  @id,
+                  label:               @label,
+                  domain:              @domain,
+                  state:               @state,
+                  wall_thickness:      @wall_thickness,
+                  resonance_frequency: @resonance_frequency,
+                  resonance_level:     resonance_level,
+                  sealed:              sealed?,
+                  porous:              porous?,
+                  echo_count:          echo_count,
+                  active_echo_count:   active_echoes.size,
+                  disruption_count:    @disruption_count,
+                  created_at:          @created_at
+                }
+              end
+
+              private
+
+              def recalculate_resonance
+                return @resonance_frequency = 0.0 if @echoes.empty?
+
+                resonating = resonating_echoes
+                @resonance_frequency = (resonating.size.to_f / @echoes.size).round(10)
+              end
+
+              def update_state
+                return if @state == :disrupted || @state == :collapsed
+                return @state = :forming if @echoes.empty?
+
+                @state = if @resonance_frequency >= DISRUPTION_THRESHOLD
+                           :saturated
+                         elsif @resonance_frequency >= POROUS_THRESHOLD
+                           :resonating
+                         else
+                           :forming
+                         end
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/legion/extensions/agentic/memory/echo_chamber/helpers/chamber_engine.rb

@@ -0,0 +1,156 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module Agentic
+      module Memory
+        module EchoChamber
+          module Helpers
+            class ChamberEngine
+              include Constants
+
+              def initialize
+                @echoes           = {}
+                @chambers         = {}
+                @disruption_history = []
+              end
+
+              def create_echo(content:, echo_type: :belief, domain: :general,
+                              source_agent: nil, amplitude: DEFAULT_AMPLITUDE)
+                prune_echoes
+                echo = Echo.new(
+                  content:      content,
+                  echo_type:    echo_type,
+                  domain:       domain,
+                  source_agent: source_agent,
+                  amplitude:    amplitude
+                )
+                @echoes[echo.id] = echo
+                echo
+              end
+
+              def create_chamber(label:, domain: :general, wall_thickness: DEFAULT_WALL_THICKNESS)
+                prune_chambers
+                chamber = Chamber.new(label: label, domain: domain, wall_thickness: wall_thickness)
+                @chambers[chamber.id] = chamber
+                chamber
+              end
+
+              def amplify_echo(echo_id:, rate: AMPLIFICATION_RATE)
+                echo = @echoes[echo_id]
+                return nil unless echo
+
+                echo.amplify!(rate)
+                echo
+              end
+
+              def disrupt_chamber(chamber_id:, force:)
+                chamber = @chambers[chamber_id]
+                return { success: false, error: 'chamber not found' } unless chamber
+
+                result = chamber.disrupt!(force)
+                record_disruption(chamber_id: chamber_id, force: force, result: result) if result[:success]
+                result
+              end
+
+              def decay_all!
+                echo_count = @echoes.size
+                @echoes.each_value { |e| e.dampen!(DECAY_RATE) }
+                prune_silent_echoes
+                { decayed: echo_count, remaining: @echoes.size, pruned: echo_count - @echoes.size }
+              end
+
+              def echoes_by_type(echo_type:)
+                @echoes.values.select { |e| e.echo_type == echo_type.to_sym }
+              end
+
+              def loudest_echoes(limit: 5)
+                @echoes.values.sort_by { |e| -e.amplitude }.first(limit)
+              end
+
+              def most_sealed_chambers(limit: 5)
+                @chambers.values.sort_by { |c| -c.wall_thickness }.first(limit)
+              end
+
+              def disruption_history
+                @disruption_history.dup
+              end
+
+              def add_echo_to_chamber(echo_id:, chamber_id:)
+                echo    = @echoes[echo_id]
+                chamber = @chambers[chamber_id]
+                return { success: false, error: 'echo not found' } unless echo
+                return { success: false, error: 'chamber not found' } unless chamber
+
+                added = chamber.add_echo(echo)
+                { success: added, echo_id: echo_id, chamber_id: chamber_id }
+              end
+
+              def echo_report
+                {
+                  total_echoes:      @echoes.size,
+                  active_echoes:     active_echoes.size,
+                  resonating_echoes: resonating_echoes.size,
+                  total_chambers:    @chambers.size,
+                  sealed_chambers:   @chambers.values.count(&:sealed?),
+                  porous_chambers:   @chambers.values.count(&:porous?),
+                  disruption_count:  @disruption_history.size,
+                  loudest:           loudest_echoes(limit: 3).map(&:to_h)
+                }
+              end
+
+              def active_echoes
+                @echoes.values.reject(&:silent?)
+              end
+
+              def resonating_echoes
+                @echoes.values.select(&:resonate?)
+              end
+
+              def chamber_by_id(chamber_id)
+                @chambers[chamber_id]
+              end
+
+              def echo_by_id(echo_id)
+                @echoes[echo_id]
+              end
+
+              private
+
+              def prune_echoes
+                return if @echoes.size < MAX_ECHOES
+
+                silent = @echoes.values.select(&:silent?)
+                silent.each { |e| @echoes.delete(e.id) }
+                return unless @echoes.size >= MAX_ECHOES
+
+                faintest = @echoes.values.min_by(&:amplitude)
+                @echoes.delete(faintest.id) if faintest
+              end
+
+              def prune_chambers
+                return if @chambers.size < MAX_CHAMBERS
+
+                collapsed = @chambers.values.select { |c| c.state == :collapsed }
+                collapsed.each { |c| @chambers.delete(c.id) }
+              end
+
+              def prune_silent_echoes
+                @echoes.select { |_, e| e.silent? }.each_key { |id| @echoes.delete(id) }
+              end
+
+              def record_disruption(chamber_id:, force:, result:)
+                @disruption_history << {
+                  chamber_id:   chamber_id,
+                  force:        force,
+                  breakthrough: result[:breakthrough],
+                  occurred_at:  Time.now.utc
+                }
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/legion/extensions/agentic/memory/echo_chamber/helpers/constants.rb

@@ -0,0 +1,60 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module Agentic
+      module Memory
+        module EchoChamber
+          module Helpers
+            module Constants
+              MAX_ECHOES             = 500
+              MAX_CHAMBERS           = 50
+              AMPLIFICATION_RATE     = 0.1
+              DECAY_RATE             = 0.02
+              DISRUPTION_THRESHOLD   = 0.7
+              SEALED_THRESHOLD       = 0.8
+              POROUS_THRESHOLD       = 0.3
+              BREAKTHROUGH_BONUS     = 0.15
+              SILENT_THRESHOLD       = 0.05
+              DEFAULT_AMPLITUDE      = 0.5
+              DEFAULT_WALL_THICKNESS = 0.5
+
+              ECHO_TYPES = %i[belief assumption bias hypothesis conviction].freeze
+
+              CHAMBER_STATES = %i[forming resonating saturated disrupted collapsed].freeze
+
+              RESONANCE_LABELS = {
+                (0.8..)     => :thunderous,
+                (0.6...0.8) => :resonant,
+                (0.4...0.6) => :humming,
+                (0.2...0.4) => :fading,
+                (..0.2)     => :silent
+              }.freeze
+
+              AMPLIFICATION_LABELS = {
+                (0.8..)     => :deafening,
+                (0.6...0.8) => :loud,
+                (0.4...0.6) => :moderate,
+                (0.2...0.4) => :quiet,
+                (..0.2)     => :muted
+              }.freeze
+
+              CHAMBER_STATE_LABELS = {
+                forming:    'Chamber is newly formed, echoes still accumulating',
+                resonating: 'Chamber is actively reinforcing beliefs',
+                saturated:  'Chamber has reached maximum self-reinforcement',
+                disrupted:  'External input has broken through the chamber walls',
+                collapsed:  'Chamber has lost coherence and dissolved'
+              }.freeze
+
+              def self.label_for(table, value)
+                match = table.find { |range, _| range.cover?(value) }
+                match&.last
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end