lex-agentic-memory 0.1.0

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

@@ -0,0 +1,252 @@
+# frozen_string_literal: true
+
+RSpec.describe Legion::Extensions::Agentic::Memory::EchoChamber::Helpers::Echo do
+  subject(:echo) { described_class.new(content: 'everything I believe is true') }
+
+  describe '#initialize' do
+    it 'assigns a UUID id' do
+      expect(echo.id).to match(/\A[0-9a-f-]{36}\z/)
+    end
+
+    it 'stores content' do
+      expect(echo.content).to eq('everything I believe is true')
+    end
+
+    it 'defaults echo_type to :belief' do
+      expect(echo.echo_type).to eq(:belief)
+    end
+
+    it 'defaults domain to :general' do
+      expect(echo.domain).to eq(:general)
+    end
+
+    it 'defaults amplitude to 0.5' do
+      expect(echo.amplitude).to eq(0.5)
+    end
+
+    it 'preserves original_amplitude' do
+      expect(echo.original_amplitude).to eq(0.5)
+    end
+
+    it 'initializes frequency to 1' do
+      expect(echo.frequency).to eq(1)
+    end
+
+    it 'records created_at' do
+      expect(echo.created_at).to be_a(Time)
+    end
+
+    it 'clamps amplitude above 1.0' do
+      high = described_class.new(content: 'x', amplitude: 5.0)
+      expect(high.amplitude).to eq(1.0)
+    end
+
+    it 'clamps amplitude below 0.0' do
+      low = described_class.new(content: 'x', amplitude: -1.0)
+      expect(low.amplitude).to eq(0.0)
+    end
+
+    it 'validates echo_type, falls back to :belief' do
+      bad = described_class.new(content: 'x', echo_type: :nonsense)
+      expect(bad.echo_type).to eq(:belief)
+    end
+
+    it 'accepts all valid echo types' do
+      %i[belief assumption bias hypothesis conviction].each do |type|
+        e = described_class.new(content: 'x', echo_type: type)
+        expect(e.echo_type).to eq(type)
+      end
+    end
+
+    it 'stores source_agent' do
+      e = described_class.new(content: 'x', source_agent: 'agent-123')
+      expect(e.source_agent).to eq('agent-123')
+    end
+
+    it 'accepts custom domain' do
+      e = described_class.new(content: 'x', domain: :politics)
+      expect(e.domain).to eq(:politics)
+    end
+  end
+
+  describe '#amplify!' do
+    it 'increases amplitude' do
+      original = echo.amplitude
+      echo.amplify!
+      expect(echo.amplitude).to be > original
+    end
+
+    it 'increments frequency' do
+      echo.amplify!
+      expect(echo.frequency).to eq(2)
+    end
+
+    it 'clamps amplitude at 1.0' do
+      high = described_class.new(content: 'x', amplitude: 0.95)
+      5.times { high.amplify! }
+      expect(high.amplitude).to eq(1.0)
+    end
+
+    it 'accepts custom rate' do
+      original = echo.amplitude
+      echo.amplify!(0.2)
+      expect(echo.amplitude).to be_within(0.001).of(original + 0.2)
+    end
+
+    it 'returns self for chaining' do
+      expect(echo.amplify!).to eq(echo)
+    end
+  end
+
+  describe '#dampen!' do
+    it 'decreases amplitude' do
+      strong = described_class.new(content: 'x', amplitude: 0.8)
+      original = strong.amplitude
+      strong.dampen!
+      expect(strong.amplitude).to be < original
+    end
+
+    it 'clamps amplitude at 0.0' do
+      30.times { echo.dampen! }
+      expect(echo.amplitude).to eq(0.0)
+    end
+
+    it 'accepts custom rate' do
+      original = echo.amplitude
+      echo.dampen!(0.1)
+      expect(echo.amplitude).to be_within(0.001).of(original - 0.1)
+    end
+
+    it 'returns self for chaining' do
+      expect(echo.dampen!).to eq(echo)
+    end
+  end
+
+  describe '#resonate?' do
+    it 'is false at default amplitude (0.5)' do
+      expect(echo.resonate?).to be false
+    end
+
+    it 'is true when amplitude exceeds disruption threshold' do
+      strong = described_class.new(content: 'x', amplitude: 0.8)
+      expect(strong.resonate?).to be true
+    end
+  end
+
+  describe '#fading?' do
+    it 'is false at default amplitude (0.5)' do
+      expect(echo.fading?).to be false
+    end
+
+    it 'is true when amplitude is at or below porous threshold' do
+      weak = described_class.new(content: 'x', amplitude: 0.2)
+      expect(weak.fading?).to be true
+    end
+  end
+
+  describe '#silent?' do
+    it 'is false at default amplitude' do
+      expect(echo.silent?).to be false
+    end
+
+    it 'is true when amplitude is at silent threshold' do
+      faint = described_class.new(content: 'x', amplitude: 0.04)
+      expect(faint.silent?).to be true
+    end
+  end
+
+  describe '#frequency_label' do
+    it 'returns a symbol' do
+      expect(echo.frequency_label).to be_a(Symbol)
+    end
+
+    it 'returns :silent for frequency 1 (score 0.05)' do
+      expect(echo.frequency_label).to eq(:silent)
+    end
+
+    it 'returns higher label after many amplifications' do
+      20.times { echo.amplify! }
+      expect(echo.frequency_label).not_to eq(:silent)
+    end
+  end
+
+  describe '#amplitude_label' do
+    it 'returns a symbol' do
+      expect(echo.amplitude_label).to be_a(Symbol)
+    end
+
+    it 'returns :moderate for default amplitude 0.5' do
+      expect(echo.amplitude_label).to eq(:moderate)
+    end
+
+    it 'returns :deafening for high amplitude' do
+      loud = described_class.new(content: 'x', amplitude: 0.9)
+      expect(loud.amplitude_label).to eq(:deafening)
+    end
+
+    it 'returns :muted for low amplitude' do
+      quiet = described_class.new(content: 'x', amplitude: 0.1)
+      expect(quiet.amplitude_label).to eq(:muted)
+    end
+  end
+
+  describe '#to_h' do
+    let(:hash) { echo.to_h }
+
+    it 'includes :id' do
+      expect(hash).to have_key(:id)
+    end
+
+    it 'includes :content' do
+      expect(hash[:content]).to eq('everything I believe is true')
+    end
+
+    it 'includes :echo_type' do
+      expect(hash[:echo_type]).to eq(:belief)
+    end
+
+    it 'includes :domain' do
+      expect(hash[:domain]).to eq(:general)
+    end
+
+    it 'includes :amplitude' do
+      expect(hash[:amplitude]).to eq(0.5)
+    end
+
+    it 'includes :original_amplitude' do
+      expect(hash[:original_amplitude]).to eq(0.5)
+    end
+
+    it 'includes :frequency' do
+      expect(hash[:frequency]).to eq(1)
+    end
+
+    it 'includes :frequency_label' do
+      expect(hash).to have_key(:frequency_label)
+    end
+
+    it 'includes :amplitude_label' do
+      expect(hash).to have_key(:amplitude_label)
+    end
+
+    it 'includes :resonate boolean' do
+      expect(hash[:resonate]).to be(false).or be(true)
+    end
+
+    it 'includes :fading boolean' do
+      expect(hash[:fading]).to be(false).or be(true)
+    end
+
+    it 'includes :silent boolean' do
+      expect(hash[:silent]).to be(false).or be(true)
+    end
+
+    it 'includes :source_agent' do
+      expect(hash).to have_key(:source_agent)
+    end
+
+    it 'includes :created_at' do
+      expect(hash[:created_at]).to be_a(Time)
+    end
+  end
+end

data/spec/legion/extensions/agentic/memory/echo_chamber/runners/cognitive_echo_chamber_spec.rb

@@ -0,0 +1,185 @@
+# frozen_string_literal: true
+
+RSpec.describe Legion::Extensions::Agentic::Memory::EchoChamber::Runners::CognitiveEchoChamber do
+  let(:engine) { Legion::Extensions::Agentic::Memory::EchoChamber::Helpers::ChamberEngine.new }
+  let(:runner) do
+    obj = Object.new
+    obj.extend(described_class)
+    obj.instance_variable_set(:@default_engine, engine)
+    obj
+  end
+
+  describe '#create_echo' do
+    it 'returns success with echo hash' do
+      result = runner.create_echo(content: 'beliefs compound', engine: engine)
+      expect(result[:success]).to be true
+      expect(result[:echo][:content]).to eq('beliefs compound')
+    end
+
+    it 'uses default echo_type :belief' do
+      result = runner.create_echo(content: 'test', engine: engine)
+      expect(result[:echo][:echo_type]).to eq(:belief)
+    end
+
+    it 'accepts custom echo_type' do
+      result = runner.create_echo(content: 'test', echo_type: :assumption, engine: engine)
+      expect(result[:echo][:echo_type]).to eq(:assumption)
+    end
+
+    it 'accepts custom domain' do
+      result = runner.create_echo(content: 'test', domain: :politics, engine: engine)
+      expect(result[:echo][:domain]).to eq(:politics)
+    end
+
+    it 'accepts source_agent' do
+      result = runner.create_echo(content: 'test', source_agent: 'agent-x', engine: engine)
+      expect(result[:echo][:source_agent]).to eq('agent-x')
+    end
+
+    it 'returns failure for empty content' do
+      result = runner.create_echo(content: '', engine: engine)
+      expect(result[:success]).to be false
+      expect(result[:error]).not_to be_empty
+    end
+
+    it 'returns failure for blank content' do
+      result = runner.create_echo(content: '   ', engine: engine)
+      expect(result[:success]).to be false
+    end
+  end
+
+  describe '#create_chamber' do
+    it 'returns success with chamber hash' do
+      result = runner.create_chamber(label: 'ideology', engine: engine)
+      expect(result[:success]).to be true
+      expect(result[:chamber][:label]).to eq('ideology')
+    end
+
+    it 'accepts custom domain' do
+      result = runner.create_chamber(label: 'test', domain: :science, engine: engine)
+      expect(result[:chamber][:domain]).to eq(:science)
+    end
+
+    it 'accepts custom wall_thickness' do
+      result = runner.create_chamber(label: 'test', wall_thickness: 0.9, engine: engine)
+      expect(result[:chamber][:wall_thickness]).to eq(0.9)
+    end
+
+    it 'returns failure for empty label' do
+      result = runner.create_chamber(label: '', engine: engine)
+      expect(result[:success]).to be false
+    end
+
+    it 'returns failure for blank label' do
+      result = runner.create_chamber(label: '  ', engine: engine)
+      expect(result[:success]).to be false
+    end
+  end
+
+  describe '#amplify' do
+    it 'returns success for existing echo' do
+      echo   = engine.create_echo(content: 'test', amplitude: 0.5)
+      result = runner.amplify(echo_id: echo.id, engine: engine)
+      expect(result[:success]).to be true
+    end
+
+    it 'increases amplitude' do
+      echo   = engine.create_echo(content: 'test', amplitude: 0.5)
+      result = runner.amplify(echo_id: echo.id, engine: engine)
+      expect(result[:echo][:amplitude]).to be > 0.5
+    end
+
+    it 'returns failure for missing echo' do
+      result = runner.amplify(echo_id: 'nonexistent', engine: engine)
+      expect(result[:success]).to be false
+      expect(result[:error]).to eq('echo not found')
+    end
+
+    it 'accepts custom rate' do
+      echo   = engine.create_echo(content: 'test', amplitude: 0.5)
+      result = runner.amplify(echo_id: echo.id, rate: 0.2, engine: engine)
+      expect(result[:echo][:amplitude]).to be_within(0.001).of(0.7)
+    end
+  end
+
+  describe '#disrupt' do
+    it 'returns result from engine' do
+      chamber = engine.create_chamber(label: 'test', wall_thickness: 0.3)
+      result  = runner.disrupt(chamber_id: chamber.id, force: 0.8, engine: engine)
+      expect(result).to have_key(:success)
+    end
+
+    it 'succeeds with sufficient force' do
+      chamber = engine.create_chamber(label: 'test', wall_thickness: 0.3)
+      result  = runner.disrupt(chamber_id: chamber.id, force: 0.8, engine: engine)
+      expect(result[:success]).to be true
+    end
+
+    it 'fails with insufficient force' do
+      chamber = engine.create_chamber(label: 'test', wall_thickness: 0.8)
+      result  = runner.disrupt(chamber_id: chamber.id, force: 0.2, engine: engine)
+      expect(result[:success]).to be false
+    end
+  end
+
+  describe '#list_echoes' do
+    before do
+      engine.create_echo(content: 'bias 1', echo_type: :bias, domain: :science)
+      engine.create_echo(content: 'belief 1', echo_type: :belief, domain: :politics)
+      engine.create_echo(content: 'belief 2', echo_type: :belief, domain: :science)
+    end
+
+    it 'returns all active echoes with no filter' do
+      result = runner.list_echoes(engine: engine)
+      expect(result[:success]).to be true
+      expect(result[:count]).to eq(3)
+    end
+
+    it 'filters by echo_type' do
+      result = runner.list_echoes(echo_type: :belief, engine: engine)
+      expect(result[:count]).to eq(2)
+    end
+
+    it 'filters by domain' do
+      result = runner.list_echoes(domain: :science, engine: engine)
+      expect(result[:count]).to eq(2)
+    end
+
+    it 'filters by both echo_type and domain' do
+      result = runner.list_echoes(echo_type: :belief, domain: :science, engine: engine)
+      expect(result[:count]).to eq(1)
+    end
+
+    it 'returns echo hashes in result' do
+      result = runner.list_echoes(engine: engine)
+      expect(result[:echoes].first).to have_key(:id)
+    end
+  end
+
+  describe '#chamber_status' do
+    it 'returns success' do
+      result = runner.chamber_status(engine: engine)
+      expect(result[:success]).to be true
+    end
+
+    it 'includes echo report fields' do
+      result = runner.chamber_status(engine: engine)
+      expect(result).to include(
+        :total_echoes, :active_echoes, :resonating_echoes,
+        :total_chambers, :sealed_chambers, :porous_chambers
+      )
+    end
+
+    it 'reflects created echoes' do
+      engine.create_echo(content: 'test')
+      result = runner.chamber_status(engine: engine)
+      expect(result[:total_echoes]).to eq(1)
+    end
+
+    it 'reflects created chambers' do
+      engine.create_chamber(label: 'test')
+      result = runner.chamber_status(engine: engine)
+      expect(result[:total_chambers]).to eq(1)
+    end
+  end
+end

data/spec/legion/extensions/agentic/memory/episodic/client_spec.rb

@@ -0,0 +1,80 @@
+# frozen_string_literal: true
+
+require 'legion/extensions/agentic/memory/episodic/client'
+
+RSpec.describe Legion::Extensions::Agentic::Memory::Episodic::Client do
+  let(:client) { described_class.new }
+
+  it 'responds to create_episode' do
+    expect(client).to respond_to(:create_episode)
+  end
+
+  it 'responds to add_binding' do
+    expect(client).to respond_to(:add_binding)
+  end
+
+  it 'responds to attend_episode' do
+    expect(client).to respond_to(:attend_episode)
+  end
+
+  it 'responds to rehearse_episode' do
+    expect(client).to respond_to(:rehearse_episode)
+  end
+
+  it 'responds to check_integration' do
+    expect(client).to respond_to(:check_integration)
+  end
+
+  it 'responds to retrieve_by_modality' do
+    expect(client).to respond_to(:retrieve_by_modality)
+  end
+
+  it 'responds to retrieve_multimodal' do
+    expect(client).to respond_to(:retrieve_multimodal)
+  end
+
+  it 'responds to most_coherent' do
+    expect(client).to respond_to(:most_coherent)
+  end
+
+  it 'responds to update_episodic_buffer' do
+    expect(client).to respond_to(:update_episodic_buffer)
+  end
+
+  it 'responds to episodic_buffer_stats' do
+    expect(client).to respond_to(:episodic_buffer_stats)
+  end
+
+  it 'uses provided store' do
+    store = Legion::Extensions::Agentic::Memory::Episodic::Helpers::EpisodicStore.new
+    c = described_class.new(store: store)
+    c.create_episode
+    expect(store.count).to eq(1)
+  end
+
+  it 'round-trips a full episode lifecycle' do
+    ep = client.create_episode
+    expect(ep[:success]).to be true
+
+    add_result = client.add_binding(
+      episode_id: ep[:episode_id], modality: :verbal, content: 'hello', source: :phonological_loop
+    )
+    expect(add_result[:success]).to be true
+
+    client.add_binding(
+      episode_id: ep[:episode_id], modality: :visual, content: 'image', source: :visuospatial, strength: 0.9
+    )
+
+    attend_result = client.attend_episode(episode_id: ep[:episode_id])
+    expect(attend_result[:success]).to be true
+
+    integration = client.check_integration(episode_id: ep[:episode_id])
+    expect(integration[:success]).to be true
+
+    multimodal = client.retrieve_multimodal
+    expect(multimodal[:count]).to eq(1)
+
+    stats = client.episodic_buffer_stats
+    expect(stats[:episode_count]).to eq(1)
+  end
+end

data/spec/legion/extensions/agentic/memory/episodic/episodic_buffer_spec.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+RSpec.describe Legion::Extensions::Agentic::Memory::Episodic do
+  it 'has a version number' do
+    expect(Legion::Extensions::Agentic::Memory::Episodic::VERSION).not_to be_nil
+  end
+
+  it 'has a version that is a string' do
+    expect(Legion::Extensions::Agentic::Memory::Episodic::VERSION).to be_a(String)
+  end
+
+  it 'version is 0.1.0' do
+    expect(Legion::Extensions::Agentic::Memory::Episodic::VERSION).to eq('0.1.0')
+  end
+end

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

@@ -0,0 +1,86 @@
+# frozen_string_literal: true
+
+RSpec.describe Legion::Extensions::Agentic::Memory::Episodic::Helpers::Constants do
+  describe 'capacity constants' do
+    it 'defines MAX_EPISODES as 30' do
+      expect(described_class::MAX_EPISODES).to eq(30)
+    end
+
+    it 'defines MAX_BINDINGS_PER_EPISODE as 10' do
+      expect(described_class::MAX_BINDINGS_PER_EPISODE).to eq(10)
+    end
+
+    it 'defines MAX_HISTORY as 200' do
+      expect(described_class::MAX_HISTORY).to eq(200)
+    end
+  end
+
+  describe 'timing constants' do
+    it 'defines EPISODE_TTL as 120' do
+      expect(described_class::EPISODE_TTL).to eq(120)
+    end
+
+    it 'defines RECENTLY_ACCESSED_WINDOW as 30' do
+      expect(described_class::RECENTLY_ACCESSED_WINDOW).to eq(30)
+    end
+  end
+
+  describe 'strength constants' do
+    it 'defines BINDING_STRENGTH_FLOOR as 0.05' do
+      expect(described_class::BINDING_STRENGTH_FLOOR).to eq(0.05)
+    end
+
+    it 'defines BINDING_DECAY as 0.015' do
+      expect(described_class::BINDING_DECAY).to eq(0.015)
+    end
+
+    it 'defines DEFAULT_BINDING_STRENGTH as 0.5' do
+      expect(described_class::DEFAULT_BINDING_STRENGTH).to eq(0.5)
+    end
+
+    it 'defines ATTENTION_BOOST as 0.2' do
+      expect(described_class::ATTENTION_BOOST).to eq(0.2)
+    end
+
+    it 'defines REHEARSAL_BOOST as 0.15' do
+      expect(described_class::REHEARSAL_BOOST).to eq(0.15)
+    end
+
+    it 'defines INTEGRATION_THRESHOLD as 0.4' do
+      expect(described_class::INTEGRATION_THRESHOLD).to eq(0.4)
+    end
+  end
+
+  describe 'MODALITIES' do
+    it 'includes all 7 expected modalities' do
+      expected = %i[verbal visual spatial semantic emotional procedural temporal]
+      expect(described_class::MODALITIES).to eq(expected)
+    end
+
+    it 'is frozen' do
+      expect(described_class::MODALITIES).to be_frozen
+    end
+  end
+
+  describe 'COHERENCE_LABELS' do
+    it 'maps low scores to :fragmented' do
+      label = described_class::COHERENCE_LABELS.find { |range, _| range.cover?(0.1) }&.last
+      expect(label).to eq(:fragmented)
+    end
+
+    it 'maps mid scores to :partial' do
+      label = described_class::COHERENCE_LABELS.find { |range, _| range.cover?(0.45) }&.last
+      expect(label).to eq(:partial)
+    end
+
+    it 'maps high scores to :coherent' do
+      label = described_class::COHERENCE_LABELS.find { |range, _| range.cover?(0.7) }&.last
+      expect(label).to eq(:coherent)
+    end
+
+    it 'maps very high scores to :vivid' do
+      label = described_class::COHERENCE_LABELS.find { |range, _| range.cover?(0.9) }&.last
+      expect(label).to eq(:vivid)
+    end
+  end
+end