lex-agentic-memory 0.1.0

data/spec/legion/extensions/agentic/memory/echo_chamber/helpers/chamber_engine_spec.rb

@@ -0,0 +1,266 @@
+# frozen_string_literal: true
+
+RSpec.describe Legion::Extensions::Agentic::Memory::EchoChamber::Helpers::ChamberEngine do
+  subject(:engine) { described_class.new }
+
+  describe '#create_echo' do
+    it 'creates an echo with default parameters' do
+      echo = engine.create_echo(content: 'test belief')
+      expect(echo.content).to eq('test belief')
+    end
+
+    it 'creates an echo with custom echo_type' do
+      echo = engine.create_echo(content: 'test', echo_type: :bias)
+      expect(echo.echo_type).to eq(:bias)
+    end
+
+    it 'creates an echo with custom domain' do
+      echo = engine.create_echo(content: 'test', domain: :science)
+      expect(echo.domain).to eq(:science)
+    end
+
+    it 'creates an echo with custom source_agent' do
+      echo = engine.create_echo(content: 'test', source_agent: 'agent-1')
+      expect(echo.source_agent).to eq('agent-1')
+    end
+
+    it 'creates an echo with custom amplitude' do
+      echo = engine.create_echo(content: 'test', amplitude: 0.8)
+      expect(echo.amplitude).to eq(0.8)
+    end
+
+    it 'returns an Echo instance' do
+      echo = engine.create_echo(content: 'test')
+      expect(echo).to be_a(Legion::Extensions::Agentic::Memory::EchoChamber::Helpers::Echo)
+    end
+  end
+
+  describe '#create_chamber' do
+    it 'creates a chamber with label' do
+      chamber = engine.create_chamber(label: 'ideology chamber')
+      expect(chamber.label).to eq('ideology chamber')
+    end
+
+    it 'creates a chamber with custom domain' do
+      chamber = engine.create_chamber(label: 'x', domain: :politics)
+      expect(chamber.domain).to eq(:politics)
+    end
+
+    it 'creates a chamber with custom wall_thickness' do
+      chamber = engine.create_chamber(label: 'x', wall_thickness: 0.8)
+      expect(chamber.wall_thickness).to eq(0.8)
+    end
+
+    it 'returns a Chamber instance' do
+      chamber = engine.create_chamber(label: 'test')
+      expect(chamber).to be_a(Legion::Extensions::Agentic::Memory::EchoChamber::Helpers::Chamber)
+    end
+  end
+
+  describe '#amplify_echo' do
+    it 'increases echo amplitude' do
+      echo = engine.create_echo(content: 'test', amplitude: 0.5)
+      engine.amplify_echo(echo_id: echo.id)
+      expect(echo.amplitude).to be > 0.5
+    end
+
+    it 'returns nil for unknown echo_id' do
+      expect(engine.amplify_echo(echo_id: 'nonexistent')).to be_nil
+    end
+
+    it 'accepts custom rate' do
+      echo = engine.create_echo(content: 'test', amplitude: 0.5)
+      engine.amplify_echo(echo_id: echo.id, rate: 0.2)
+      expect(echo.amplitude).to be_within(0.001).of(0.7)
+    end
+  end
+
+  describe '#disrupt_chamber' do
+    let(:chamber) { engine.create_chamber(label: 'test', wall_thickness: 0.4) }
+
+    it 'returns error for unknown chamber_id' do
+      result = engine.disrupt_chamber(chamber_id: 'nonexistent', force: 0.9)
+      expect(result[:success]).to be false
+      expect(result[:error]).to eq('chamber not found')
+    end
+
+    it 'succeeds with sufficient force' do
+      result = engine.disrupt_chamber(chamber_id: chamber.id, force: 0.9)
+      expect(result[:success]).to be true
+    end
+
+    it 'fails with insufficient force' do
+      result = engine.disrupt_chamber(chamber_id: chamber.id, force: 0.2)
+      expect(result[:success]).to be false
+    end
+
+    it 'records disruption in history on success' do
+      engine.disrupt_chamber(chamber_id: chamber.id, force: 0.9)
+      expect(engine.disruption_history).not_to be_empty
+    end
+
+    it 'does not record failed disruption in history' do
+      engine.disrupt_chamber(chamber_id: chamber.id, force: 0.1)
+      expect(engine.disruption_history).to be_empty
+    end
+  end
+
+  describe '#decay_all!' do
+    it 'reduces amplitude of all echoes' do
+      echo = engine.create_echo(content: 'test', amplitude: 0.8)
+      original = echo.amplitude
+      engine.decay_all!
+      expect(echo.amplitude).to be < original
+    end
+
+    it 'returns a hash with decay stats' do
+      engine.create_echo(content: 'test')
+      result = engine.decay_all!
+      expect(result).to include(:decayed, :remaining, :pruned)
+    end
+
+    it 'prunes silent echoes after decay' do
+      engine.create_echo(content: 'faint', amplitude: 0.02)
+      engine.decay_all!
+      expect(engine.active_echoes).to be_empty
+    end
+  end
+
+  describe '#echoes_by_type' do
+    it 'filters echoes by type' do
+      engine.create_echo(content: 'a', echo_type: :bias)
+      engine.create_echo(content: 'b', echo_type: :conviction)
+      expect(engine.echoes_by_type(echo_type: :bias).size).to eq(1)
+    end
+
+    it 'returns empty array when no matching type' do
+      engine.create_echo(content: 'a', echo_type: :belief)
+      expect(engine.echoes_by_type(echo_type: :hypothesis)).to be_empty
+    end
+  end
+
+  describe '#loudest_echoes' do
+    it 'returns echoes sorted by amplitude descending' do
+      engine.create_echo(content: 'quiet', amplitude: 0.3)
+      loud = engine.create_echo(content: 'loud', amplitude: 0.9)
+      expect(engine.loudest_echoes(limit: 1).first.id).to eq(loud.id)
+    end
+
+    it 'respects limit parameter' do
+      3.times { |i| engine.create_echo(content: "echo #{i}") }
+      expect(engine.loudest_echoes(limit: 2).size).to eq(2)
+    end
+  end
+
+  describe '#most_sealed_chambers' do
+    it 'returns chambers sorted by wall_thickness descending' do
+      engine.create_chamber(label: 'thin', wall_thickness: 0.2)
+      thick = engine.create_chamber(label: 'thick', wall_thickness: 0.9)
+      expect(engine.most_sealed_chambers(limit: 1).first.id).to eq(thick.id)
+    end
+
+    it 'respects limit parameter' do
+      3.times { |i| engine.create_chamber(label: "chamber #{i}") }
+      expect(engine.most_sealed_chambers(limit: 2).size).to eq(2)
+    end
+  end
+
+  describe '#disruption_history' do
+    it 'returns empty initially' do
+      expect(engine.disruption_history).to be_empty
+    end
+
+    it 'returns a copy, not the internal array' do
+      chamber = engine.create_chamber(label: 'test', wall_thickness: 0.2)
+      engine.disrupt_chamber(chamber_id: chamber.id, force: 0.9)
+      history = engine.disruption_history
+      expect(history).not_to equal(engine.disruption_history)
+    end
+  end
+
+  describe '#add_echo_to_chamber' do
+    it 'adds echo to chamber successfully' do
+      echo    = engine.create_echo(content: 'test')
+      chamber = engine.create_chamber(label: 'test chamber')
+      result  = engine.add_echo_to_chamber(echo_id: echo.id, chamber_id: chamber.id)
+      expect(result[:success]).to be true
+    end
+
+    it 'returns error for unknown echo' do
+      chamber = engine.create_chamber(label: 'test')
+      result  = engine.add_echo_to_chamber(echo_id: 'bad', chamber_id: chamber.id)
+      expect(result[:error]).to eq('echo not found')
+    end
+
+    it 'returns error for unknown chamber' do
+      echo   = engine.create_echo(content: 'test')
+      result = engine.add_echo_to_chamber(echo_id: echo.id, chamber_id: 'bad')
+      expect(result[:error]).to eq('chamber not found')
+    end
+  end
+
+  describe '#active_echoes' do
+    it 'returns non-silent echoes' do
+      engine.create_echo(content: 'active', amplitude: 0.5)
+      engine.create_echo(content: 'silent', amplitude: 0.01)
+      expect(engine.active_echoes.size).to eq(1)
+    end
+  end
+
+  describe '#resonating_echoes' do
+    it 'returns echoes above disruption threshold' do
+      engine.create_echo(content: 'resonating', amplitude: 0.8)
+      engine.create_echo(content: 'quiet', amplitude: 0.3)
+      expect(engine.resonating_echoes.size).to eq(1)
+    end
+  end
+
+  describe '#echo_report' do
+    it 'includes expected keys' do
+      report = engine.echo_report
+      expect(report).to include(
+        :total_echoes, :active_echoes, :resonating_echoes,
+        :total_chambers, :sealed_chambers, :porous_chambers,
+        :disruption_count, :loudest
+      )
+    end
+
+    it 'counts sealed chambers correctly' do
+      engine.create_chamber(label: 'sealed', wall_thickness: 0.9)
+      engine.create_chamber(label: 'open', wall_thickness: 0.2)
+      expect(engine.echo_report[:sealed_chambers]).to eq(1)
+    end
+
+    it 'counts porous chambers correctly' do
+      engine.create_chamber(label: 'porous', wall_thickness: 0.1)
+      expect(engine.echo_report[:porous_chambers]).to eq(1)
+    end
+
+    it 'includes loudest echoes array' do
+      engine.create_echo(content: 'loud', amplitude: 0.9)
+      expect(engine.echo_report[:loudest]).not_to be_empty
+    end
+  end
+
+  describe '#echo_by_id' do
+    it 'returns the echo if found' do
+      echo = engine.create_echo(content: 'find me')
+      expect(engine.echo_by_id(echo.id)).to eq(echo)
+    end
+
+    it 'returns nil if not found' do
+      expect(engine.echo_by_id('missing')).to be_nil
+    end
+  end
+
+  describe '#chamber_by_id' do
+    it 'returns the chamber if found' do
+      chamber = engine.create_chamber(label: 'find me')
+      expect(engine.chamber_by_id(chamber.id)).to eq(chamber)
+    end
+
+    it 'returns nil if not found' do
+      expect(engine.chamber_by_id('missing')).to be_nil
+    end
+  end
+end

data/spec/legion/extensions/agentic/memory/echo_chamber/helpers/chamber_spec.rb

@@ -0,0 +1,249 @@
+# frozen_string_literal: true
+
+RSpec.describe Legion::Extensions::Agentic::Memory::EchoChamber::Helpers::Chamber do
+  subject(:chamber) { described_class.new(label: 'political beliefs', domain: :politics) }
+
+  let(:echo) do
+    Legion::Extensions::Agentic::Memory::EchoChamber::Helpers::Echo.new(
+      content: 'my side is always right',
+      domain:  :politics
+    )
+  end
+
+  let(:strong_echo) do
+    Legion::Extensions::Agentic::Memory::EchoChamber::Helpers::Echo.new(
+      content:   'opponents are always wrong',
+      domain:    :politics,
+      amplitude: 0.9
+    )
+  end
+
+  describe '#initialize' do
+    it 'assigns a UUID id' do
+      expect(chamber.id).to match(/\A[0-9a-f-]{36}\z/)
+    end
+
+    it 'stores label' do
+      expect(chamber.label).to eq('political beliefs')
+    end
+
+    it 'stores domain' do
+      expect(chamber.domain).to eq(:politics)
+    end
+
+    it 'initializes state as :forming' do
+      expect(chamber.state).to eq(:forming)
+    end
+
+    it 'defaults wall_thickness to 0.5' do
+      expect(chamber.wall_thickness).to eq(0.5)
+    end
+
+    it 'initializes resonance_frequency to 0.0' do
+      expect(chamber.resonance_frequency).to eq(0.0)
+    end
+
+    it 'initializes disruption_count to 0' do
+      expect(chamber.disruption_count).to eq(0)
+    end
+
+    it 'records created_at' do
+      expect(chamber.created_at).to be_a(Time)
+    end
+
+    it 'clamps wall_thickness above 1.0' do
+      thick = described_class.new(label: 'x', wall_thickness: 2.0)
+      expect(thick.wall_thickness).to eq(1.0)
+    end
+
+    it 'clamps wall_thickness below 0.0' do
+      thin = described_class.new(label: 'x', wall_thickness: -1.0)
+      expect(thin.wall_thickness).to eq(0.0)
+    end
+  end
+
+  describe '#add_echo' do
+    it 'returns true on success' do
+      expect(chamber.add_echo(echo)).to be true
+    end
+
+    it 'increases echo_count' do
+      chamber.add_echo(echo)
+      expect(chamber.echo_count).to eq(1)
+    end
+
+    it 'updates resonance_frequency' do
+      chamber.add_echo(strong_echo)
+      expect(chamber.resonance_frequency).to be > 0.0
+    end
+  end
+
+  describe '#remove_echo' do
+    before { chamber.add_echo(echo) }
+
+    it 'returns true when echo exists' do
+      expect(chamber.remove_echo(echo.id)).to be true
+    end
+
+    it 'decreases echo_count' do
+      chamber.remove_echo(echo.id)
+      expect(chamber.echo_count).to eq(0)
+    end
+
+    it 'returns false when echo does not exist' do
+      expect(chamber.remove_echo('nonexistent-id')).to be false
+    end
+  end
+
+  describe '#amplify_all!' do
+    before do
+      chamber.add_echo(echo)
+      chamber.add_echo(strong_echo)
+    end
+
+    it 'returns a hash with amplified count' do
+      result = chamber.amplify_all!
+      expect(result[:amplified]).to eq(2)
+    end
+
+    it 'returns updated resonance_frequency' do
+      result = chamber.amplify_all!
+      expect(result[:resonance_frequency]).to be_a(Float)
+    end
+
+    it 'increases amplitudes of echoes' do
+      original = echo.amplitude
+      chamber.amplify_all!
+      expect(echo.amplitude).to be > original
+    end
+  end
+
+  describe '#disrupt!' do
+    context 'with insufficient force' do
+      it 'returns success: false' do
+        result = chamber.disrupt!(0.3)
+        expect(result[:success]).to be false
+      end
+
+      it 'includes reason in result' do
+        result = chamber.disrupt!(0.3)
+        expect(result[:reason]).to eq('insufficient_force')
+      end
+    end
+
+    context 'with sufficient force' do
+      subject(:thick_chamber) { described_class.new(label: 'ideology', wall_thickness: 0.4) }
+
+      before { thick_chamber.add_echo(strong_echo) }
+
+      it 'returns success: true' do
+        result = thick_chamber.disrupt!(0.9)
+        expect(result[:success]).to be true
+      end
+
+      it 'includes breakthrough value' do
+        result = thick_chamber.disrupt!(0.9)
+        expect(result[:breakthrough]).to be > 0.0
+      end
+
+      it 'reduces wall_thickness' do
+        original = thick_chamber.wall_thickness
+        thick_chamber.disrupt!(0.9)
+        expect(thick_chamber.wall_thickness).to be < original
+      end
+
+      it 'increments disruption_count' do
+        thick_chamber.disrupt!(0.9)
+        expect(thick_chamber.disruption_count).to eq(1)
+      end
+
+      it 'transitions state to :disrupted' do
+        thick_chamber.disrupt!(0.9)
+        expect(thick_chamber.state).to eq(:disrupted)
+      end
+
+      it 'dampens echoes in the chamber' do
+        original = strong_echo.amplitude
+        thick_chamber.disrupt!(0.9)
+        expect(strong_echo.amplitude).to be < original
+      end
+    end
+  end
+
+  describe '#sealed?' do
+    it 'is false at default wall_thickness (0.5)' do
+      expect(chamber.sealed?).to be false
+    end
+
+    it 'is true when wall_thickness >= 0.8' do
+      thick = described_class.new(label: 'x', wall_thickness: 0.85)
+      expect(thick.sealed?).to be true
+    end
+  end
+
+  describe '#porous?' do
+    it 'is false at default wall_thickness (0.5)' do
+      expect(chamber.porous?).to be false
+    end
+
+    it 'is true when wall_thickness <= 0.3' do
+      thin = described_class.new(label: 'x', wall_thickness: 0.2)
+      expect(thin.porous?).to be true
+    end
+  end
+
+  describe '#resonance_level' do
+    it 'returns :silent with no echoes' do
+      expect(chamber.resonance_level).to eq(:silent)
+    end
+
+    it 'returns a symbol after adding resonating echoes' do
+      resonating = Legion::Extensions::Agentic::Memory::EchoChamber::Helpers::Echo.new(
+        content:   'strong belief',
+        amplitude: 0.9
+      )
+      chamber.add_echo(resonating)
+      expect(chamber.resonance_level).to be_a(Symbol)
+    end
+  end
+
+  describe '#active_echoes' do
+    it 'returns empty array initially' do
+      expect(chamber.active_echoes).to be_empty
+    end
+
+    it 'returns echoes that are not silent' do
+      chamber.add_echo(echo)
+      expect(chamber.active_echoes.size).to eq(1)
+    end
+  end
+
+  describe '#resonating_echoes' do
+    it 'returns empty when no high-amplitude echoes' do
+      chamber.add_echo(echo)
+      expect(chamber.resonating_echoes).to be_empty
+    end
+
+    it 'returns echoes above disruption threshold' do
+      chamber.add_echo(strong_echo)
+      expect(chamber.resonating_echoes.size).to eq(1)
+    end
+  end
+
+  describe '#to_h' do
+    let(:hash) { chamber.to_h }
+
+    it 'includes all expected keys' do
+      expect(hash).to include(
+        :id, :label, :domain, :state, :wall_thickness,
+        :resonance_frequency, :resonance_level, :sealed, :porous,
+        :echo_count, :active_echo_count, :disruption_count, :created_at
+      )
+    end
+
+    it 'reflects current echo_count' do
+      chamber.add_echo(echo)
+      expect(chamber.to_h[:echo_count]).to eq(1)
+    end
+  end
+end

data/spec/legion/extensions/agentic/memory/echo_chamber/helpers/constants_spec.rb

@@ -0,0 +1,130 @@
+# frozen_string_literal: true
+
+RSpec.describe Legion::Extensions::Agentic::Memory::EchoChamber::Helpers::Constants do
+  describe 'numeric constants' do
+    it 'defines MAX_ECHOES as 500' do
+      expect(described_class::MAX_ECHOES).to eq(500)
+    end
+
+    it 'defines MAX_CHAMBERS as 50' do
+      expect(described_class::MAX_CHAMBERS).to eq(50)
+    end
+
+    it 'defines AMPLIFICATION_RATE as 0.1' do
+      expect(described_class::AMPLIFICATION_RATE).to eq(0.1)
+    end
+
+    it 'defines DECAY_RATE as 0.02' do
+      expect(described_class::DECAY_RATE).to eq(0.02)
+    end
+
+    it 'defines DISRUPTION_THRESHOLD as 0.7' do
+      expect(described_class::DISRUPTION_THRESHOLD).to eq(0.7)
+    end
+
+    it 'defines SEALED_THRESHOLD as 0.8' do
+      expect(described_class::SEALED_THRESHOLD).to eq(0.8)
+    end
+
+    it 'defines POROUS_THRESHOLD as 0.3' do
+      expect(described_class::POROUS_THRESHOLD).to eq(0.3)
+    end
+  end
+
+  describe 'ECHO_TYPES' do
+    it 'contains belief' do
+      expect(described_class::ECHO_TYPES).to include(:belief)
+    end
+
+    it 'contains assumption' do
+      expect(described_class::ECHO_TYPES).to include(:assumption)
+    end
+
+    it 'contains bias' do
+      expect(described_class::ECHO_TYPES).to include(:bias)
+    end
+
+    it 'contains hypothesis' do
+      expect(described_class::ECHO_TYPES).to include(:hypothesis)
+    end
+
+    it 'contains conviction' do
+      expect(described_class::ECHO_TYPES).to include(:conviction)
+    end
+
+    it 'is frozen' do
+      expect(described_class::ECHO_TYPES).to be_frozen
+    end
+  end
+
+  describe 'CHAMBER_STATES' do
+    it 'contains all expected states' do
+      expect(described_class::CHAMBER_STATES).to contain_exactly(
+        :forming, :resonating, :saturated, :disrupted, :collapsed
+      )
+    end
+
+    it 'is frozen' do
+      expect(described_class::CHAMBER_STATES).to be_frozen
+    end
+  end
+
+  describe 'RESONANCE_LABELS' do
+    it 'maps high values to :thunderous' do
+      expect(described_class::RESONANCE_LABELS.find { |r, _| r.cover?(0.9) }&.last).to eq(:thunderous)
+    end
+
+    it 'maps mid values to :humming' do
+      expect(described_class::RESONANCE_LABELS.find { |r, _| r.cover?(0.5) }&.last).to eq(:humming)
+    end
+
+    it 'maps low values to :silent' do
+      expect(described_class::RESONANCE_LABELS.find { |r, _| r.cover?(0.1) }&.last).to eq(:silent)
+    end
+
+    it 'is frozen' do
+      expect(described_class::RESONANCE_LABELS).to be_frozen
+    end
+  end
+
+  describe 'AMPLIFICATION_LABELS' do
+    it 'maps high values to :deafening' do
+      expect(described_class::AMPLIFICATION_LABELS.find { |r, _| r.cover?(0.9) }&.last).to eq(:deafening)
+    end
+
+    it 'maps mid values to :moderate' do
+      expect(described_class::AMPLIFICATION_LABELS.find { |r, _| r.cover?(0.5) }&.last).to eq(:moderate)
+    end
+
+    it 'maps low values to :muted' do
+      expect(described_class::AMPLIFICATION_LABELS.find { |r, _| r.cover?(0.1) }&.last).to eq(:muted)
+    end
+  end
+
+  describe '.label_for' do
+    it 'returns the correct label for a value in range' do
+      label = described_class.label_for(described_class::RESONANCE_LABELS, 0.9)
+      expect(label).to eq(:thunderous)
+    end
+
+    it 'returns label for boundary value' do
+      label = described_class.label_for(described_class::RESONANCE_LABELS, 0.8)
+      expect(label).to eq(:thunderous)
+    end
+
+    it 'returns :silent for very low values' do
+      label = described_class.label_for(described_class::RESONANCE_LABELS, 0.1)
+      expect(label).to eq(:silent)
+    end
+
+    it 'returns nil for no match' do
+      label = described_class.label_for({}, 0.5)
+      expect(label).to be_nil
+    end
+
+    it 'works with AMPLIFICATION_LABELS' do
+      label = described_class.label_for(described_class::AMPLIFICATION_LABELS, 0.75)
+      expect(label).to eq(:loud)
+    end
+  end
+end