lex-agentic-memory 0.1.0

data/spec/legion/extensions/agentic/memory/compression/helpers/information_chunk_spec.rb

@@ -0,0 +1,123 @@
+# frozen_string_literal: true
+
+RSpec.describe Legion::Extensions::Agentic::Memory::Compression::Helpers::InformationChunk do
+  subject(:chunk) { described_class.new(label: 'test_data') }
+
+  describe '#initialize' do
+    it 'assigns a UUID id' do
+      expect(chunk.id).to match(/\A[0-9a-f-]{36}\z/)
+    end
+
+    it 'sets label' do
+      expect(chunk.label).to eq('test_data')
+    end
+
+    it 'defaults to semantic type' do
+      expect(chunk.chunk_type).to eq(:semantic)
+    end
+
+    it 'starts with fidelity 1.0' do
+      expect(chunk.fidelity).to eq(1.0)
+    end
+
+    it 'starts with 0 compressions' do
+      expect(chunk.compression_count).to eq(0)
+    end
+
+    it 'original and compressed sizes start equal' do
+      expect(chunk.compressed_size).to eq(chunk.original_size)
+    end
+  end
+
+  describe '#compression_ratio' do
+    it 'starts at 0.0 (no compression)' do
+      expect(chunk.compression_ratio).to eq(0.0)
+    end
+
+    it 'increases after compression' do
+      chunk.compress!
+      expect(chunk.compression_ratio).to be > 0.0
+    end
+  end
+
+  describe '#compress!' do
+    it 'reduces compressed_size' do
+      original = chunk.compressed_size
+      chunk.compress!
+      expect(chunk.compressed_size).to be < original
+    end
+
+    it 'reduces fidelity' do
+      chunk.compress!
+      expect(chunk.fidelity).to be < 1.0
+    end
+
+    it 'increments compression_count' do
+      chunk.compress!
+      expect(chunk.compression_count).to eq(1)
+    end
+
+    it 'fidelity floors at MIN_FIDELITY' do
+      50.times { chunk.compress! }
+      min = Legion::Extensions::Agentic::Memory::Compression::Helpers::Constants::MIN_FIDELITY
+      expect(chunk.fidelity).to be >= min
+    end
+
+    it 'returns self' do
+      expect(chunk.compress!).to eq(chunk)
+    end
+  end
+
+  describe '#decompress!' do
+    it 'increases compressed_size' do
+      chunk.compress!
+      small = chunk.compressed_size
+      chunk.decompress!
+      expect(chunk.compressed_size).to be > small
+    end
+
+    it 'does not exceed original_size' do
+      chunk.decompress!
+      expect(chunk.compressed_size).to be <= chunk.original_size
+    end
+  end
+
+  describe '#highly_compressed?' do
+    it 'is false at start' do
+      expect(chunk.highly_compressed?).to be false
+    end
+
+    it 'is true after many compressions' do
+      20.times { chunk.compress! }
+      expect(chunk.highly_compressed?).to be true
+    end
+  end
+
+  describe '#compression_label' do
+    it 'returns :raw at start' do
+      expect(chunk.compression_label).to eq(:raw)
+    end
+
+    it 'changes after compression' do
+      10.times { chunk.compress! }
+      expect(chunk.compression_label).not_to eq(:raw)
+    end
+  end
+
+  describe '#fidelity_label' do
+    it 'returns :pristine at start' do
+      expect(chunk.fidelity_label).to eq(:pristine)
+    end
+  end
+
+  describe '#to_h' do
+    it 'includes all fields' do
+      hash = chunk.to_h
+      expect(hash).to include(
+        :id, :label, :chunk_type, :original_size, :compressed_size,
+        :compression_ratio, :compression_label, :fidelity, :fidelity_label,
+        :compression_count, :created_at
+      )
+    end
+  end
+end

data/spec/legion/extensions/agentic/memory/compression/runners/cognitive_compression_spec.rb

@@ -0,0 +1,80 @@
+# frozen_string_literal: true
+
+RSpec.describe Legion::Extensions::Agentic::Memory::Compression::Runners::CognitiveCompression do
+  let(:client) { Legion::Extensions::Agentic::Memory::Compression::Client.new }
+
+  describe '#store_chunk' do
+    it 'returns success with chunk hash' do
+      result = client.store_chunk(label: 'test')
+      expect(result[:success]).to be true
+      expect(result[:chunk]).to include(:id, :label, :compression_ratio)
+    end
+  end
+
+  describe '#compress_chunk' do
+    it 'compresses a stored chunk' do
+      c = client.store_chunk(label: 'data')
+      result = client.compress_chunk(chunk_id: c[:chunk][:id])
+      expect(result[:success]).to be true
+      expect(result[:chunk][:compression_ratio]).to be > 0.0
+    end
+
+    it 'returns failure for unknown id' do
+      result = client.compress_chunk(chunk_id: 'fake')
+      expect(result[:success]).to be false
+    end
+  end
+
+  describe '#decompress_chunk' do
+    it 'decompresses a chunk' do
+      c = client.store_chunk(label: 'data')
+      client.compress_chunk(chunk_id: c[:chunk][:id])
+      result = client.decompress_chunk(chunk_id: c[:chunk][:id])
+      expect(result[:success]).to be true
+    end
+  end
+
+  describe '#abstract_chunks' do
+    it 'creates an abstraction' do
+      c1 = client.store_chunk(label: 'a')
+      c2 = client.store_chunk(label: 'b')
+      result = client.abstract_chunks(chunk_ids:         [c1[:chunk][:id], c2[:chunk][:id]],
+                                      abstraction_label: 'ab')
+      expect(result[:success]).to be true
+      expect(result[:abstraction][:chunk_type]).to eq(:abstract)
+    end
+  end
+
+  describe '#compress_all' do
+    it 'returns compressed count' do
+      client.store_chunk(label: 'a')
+      client.store_chunk(label: 'b')
+      result = client.compress_all
+      expect(result[:success]).to be true
+      expect(result[:compressed_count]).to eq(2)
+    end
+  end
+
+  describe '#average_fidelity' do
+    it 'returns fidelity score' do
+      result = client.average_fidelity
+      expect(result[:success]).to be true
+      expect(result[:fidelity]).to be_a(Numeric)
+    end
+  end
+
+  describe '#overall_compression_ratio' do
+    it 'returns ratio' do
+      result = client.overall_compression_ratio
+      expect(result[:success]).to be true
+    end
+  end
+
+  describe '#compression_report' do
+    it 'returns a full report' do
+      result = client.compression_report
+      expect(result[:success]).to be true
+      expect(result[:report]).to include(:total_chunks, :average_fidelity)
+    end
+  end
+end

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

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+RSpec.describe Legion::Extensions::Agentic::Memory::Echo::Client do
+  subject(:client) { described_class.new }
+
+  it 'responds to runner methods' do
+    expect(client).to respond_to(:create_echo, :decay_all, :echo_status)
+  end
+
+  it 'runs a full echo lifecycle' do
+    result = client.create_echo(content: 'security analysis', domain: :security, echo_type: :thought)
+    echo_id = result[:echo][:id]
+
+    client.decay_all
+    client.reinforce_echo(echo_id: echo_id)
+
+    status = client.echo_status
+    expect(status[:total_echoes]).to eq(1)
+  end
+end

data/spec/legion/extensions/agentic/memory/echo/cognitive_echo_spec.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+RSpec.describe Legion::Extensions::Agentic::Memory::Echo do
+  it 'has a version number' do
+    expect(Legion::Extensions::Agentic::Memory::Echo::VERSION).to eq('0.1.0')
+  end
+end

data/spec/legion/extensions/agentic/memory/echo/helpers/echo_engine_spec.rb

@@ -0,0 +1,152 @@
+# frozen_string_literal: true
+
+RSpec.describe Legion::Extensions::Agentic::Memory::Echo::Helpers::EchoEngine do
+  subject(:engine) { described_class.new }
+
+  describe '#create_echo' do
+    it 'creates and stores an echo' do
+      echo = engine.create_echo(content: 'test thought')
+      expect(echo.content).to eq('test thought')
+    end
+  end
+
+  describe '#reinforce_echo' do
+    it 'increases echo intensity' do
+      echo = engine.create_echo(content: 'test', intensity: 0.5)
+      engine.reinforce_echo(echo_id: echo.id)
+      expect(echo.intensity).to be > 0.5
+    end
+
+    it 'returns nil for unknown echo' do
+      expect(engine.reinforce_echo(echo_id: 'bad')).to be_nil
+    end
+  end
+
+  describe '#decay_all!' do
+    it 'decays all echoes' do
+      echo = engine.create_echo(content: 'test')
+      original = echo.intensity
+      engine.decay_all!
+      expect(echo.intensity).to be < original
+    end
+  end
+
+  describe '#active_echoes' do
+    it 'returns non-silent echoes' do
+      engine.create_echo(content: 'active', intensity: 0.5)
+      engine.create_echo(content: 'silent', intensity: 0.01)
+      expect(engine.active_echoes.size).to eq(1)
+    end
+  end
+
+  describe '#priming_echoes' do
+    it 'returns echoes above priming threshold' do
+      engine.create_echo(content: 'strong', intensity: 0.5)
+      engine.create_echo(content: 'weak', intensity: 0.1)
+      expect(engine.priming_echoes.size).to eq(1)
+    end
+  end
+
+  describe '#interfering_echoes' do
+    it 'returns echoes above interference threshold' do
+      engine.create_echo(content: 'loud', intensity: 0.6)
+      engine.create_echo(content: 'quiet', intensity: 0.2)
+      expect(engine.interfering_echoes.size).to eq(1)
+    end
+  end
+
+  describe '#echoes_by_domain' do
+    it 'filters by domain' do
+      engine.create_echo(content: 'a', domain: :security)
+      engine.create_echo(content: 'b', domain: :memory)
+      expect(engine.echoes_by_domain(domain: :security).size).to eq(1)
+    end
+  end
+
+  describe '#echoes_by_type' do
+    it 'filters by type' do
+      engine.create_echo(content: 'a', echo_type: :emotion)
+      engine.create_echo(content: 'b', echo_type: :decision)
+      expect(engine.echoes_by_type(echo_type: :emotion).size).to eq(1)
+    end
+  end
+
+  describe '#strongest_echoes' do
+    it 'returns sorted by intensity descending' do
+      engine.create_echo(content: 'weak', intensity: 0.3)
+      strong = engine.create_echo(content: 'strong', intensity: 0.9)
+      expect(engine.strongest_echoes(limit: 1).first.id).to eq(strong.id)
+    end
+  end
+
+  describe '#echo_chamber_score' do
+    it 'returns 0.0 with no echoes' do
+      expect(engine.echo_chamber_score).to eq(0.0)
+    end
+
+    it 'returns 1.0 when all echoes in one domain' do
+      engine.create_echo(content: 'a', domain: :security)
+      engine.create_echo(content: 'b', domain: :security)
+      expect(engine.echo_chamber_score).to eq(1.0)
+    end
+
+    it 'returns lower score with diverse domains' do
+      engine.create_echo(content: 'a', domain: :security, intensity: 0.5)
+      engine.create_echo(content: 'b', domain: :memory, intensity: 0.5)
+      expect(engine.echo_chamber_score).to eq(0.5)
+    end
+  end
+
+  describe '#priming_effect_for' do
+    it 'returns 0.0 for domain with no priming echoes' do
+      expect(engine.priming_effect_for(domain: :security)).to eq(0.0)
+    end
+
+    it 'returns accumulated priming from matching domain' do
+      engine.create_echo(content: 'sec1', domain: :security, intensity: 0.5)
+      expect(engine.priming_effect_for(domain: :security)).to be > 0.0
+    end
+  end
+
+  describe '#interference_level' do
+    it 'returns 0.0 with no interfering echoes' do
+      engine.create_echo(content: 'x', intensity: 0.2)
+      expect(engine.interference_level).to eq(0.0)
+    end
+
+    it 'returns positive when strong echoes exist' do
+      engine.create_echo(content: 'x', intensity: 0.8)
+      expect(engine.interference_level).to be > 0.0
+    end
+  end
+
+  describe '#average_intensity' do
+    it 'returns 0.0 with no echoes' do
+      expect(engine.average_intensity).to eq(0.0)
+    end
+
+    it 'computes average' do
+      engine.create_echo(content: 'a', intensity: 0.4)
+      engine.create_echo(content: 'b', intensity: 0.6)
+      expect(engine.average_intensity).to eq(0.5)
+    end
+  end
+
+  describe '#echo_report' do
+    it 'includes key report fields' do
+      report = engine.echo_report
+      expect(report).to include(
+        :total_echoes, :active_count, :priming_count, :interfering_count,
+        :average_intensity, :echo_chamber_score, :chamber_label,
+        :interference_level, :strongest
+      )
+    end
+  end
+
+  describe '#to_h' do
+    it 'includes summary' do
+      hash = engine.to_h
+      expect(hash).to include(:total_echoes, :active, :average_intensity, :chamber_score)
+    end
+  end
+end

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

@@ -0,0 +1,128 @@
+# frozen_string_literal: true
+
+RSpec.describe Legion::Extensions::Agentic::Memory::Echo::Helpers::Echo do
+  subject(:echo) { described_class.new(content: 'previous thought about security') }
+
+  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('previous thought about security')
+    end
+
+    it 'defaults echo_type to :thought' do
+      expect(echo.echo_type).to eq(:thought)
+    end
+
+    it 'defaults domain to :general' do
+      expect(echo.domain).to eq(:general)
+    end
+
+    it 'defaults intensity to 0.8' do
+      expect(echo.intensity).to eq(0.8)
+    end
+
+    it 'preserves original_intensity' do
+      expect(echo.original_intensity).to eq(0.8)
+    end
+
+    it 'clamps intensity' do
+      high = described_class.new(content: 'x', intensity: 5.0)
+      expect(high.intensity).to eq(1.0)
+    end
+
+    it 'validates echo_type' do
+      bad = described_class.new(content: 'x', echo_type: :nonexistent)
+      expect(bad.echo_type).to eq(:thought)
+    end
+  end
+
+  describe '#decay!' do
+    it 'reduces intensity' do
+      original = echo.intensity
+      echo.decay!
+      expect(echo.intensity).to be < original
+    end
+
+    it 'increments decay_count' do
+      echo.decay!
+      expect(echo.decay_count).to eq(1)
+    end
+
+    it 'clamps at 0.0' do
+      15.times { echo.decay! }
+      expect(echo.intensity).to eq(0.0)
+    end
+  end
+
+  describe '#reinforce!' do
+    it 'increases intensity' do
+      echo.decay!
+      original = echo.intensity
+      echo.reinforce!
+      expect(echo.intensity).to be > original
+    end
+
+    it 'clamps at 1.0' do
+      5.times { echo.reinforce! }
+      expect(echo.intensity).to eq(1.0)
+    end
+  end
+
+  describe '#silent?' do
+    it 'is false when active' do
+      expect(echo.silent?).to be false
+    end
+
+    it 'is true when fully decayed' do
+      10.times { echo.decay! }
+      expect(echo.silent?).to be true
+    end
+  end
+
+  describe '#priming?' do
+    it 'is true at default intensity' do
+      expect(echo.priming?).to be true
+    end
+
+    it 'is false when very faint' do
+      faint = described_class.new(content: 'x', intensity: 0.1)
+      expect(faint.priming?).to be false
+    end
+  end
+
+  describe '#interfering?' do
+    it 'is true at default intensity' do
+      expect(echo.interfering?).to be true
+    end
+
+    it 'is false when below threshold' do
+      weak = described_class.new(content: 'x', intensity: 0.2)
+      expect(weak.interfering?).to be false
+    end
+  end
+
+  describe '#persistence' do
+    it 'is 1.0 when not decayed' do
+      expect(echo.persistence).to eq(1.0)
+    end
+
+    it 'decreases after decay' do
+      echo.decay!
+      expect(echo.persistence).to be < 1.0
+    end
+  end
+
+  describe '#to_h' do
+    it 'includes all fields' do
+      hash = echo.to_h
+      expect(hash).to include(
+        :id, :content, :echo_type, :domain, :intensity, :original_intensity,
+        :intensity_label, :effect_label, :priming, :interfering, :silent,
+        :persistence, :decay_count, :created_at
+      )
+    end
+  end
+end

data/spec/legion/extensions/agentic/memory/echo/runners_spec.rb

@@ -0,0 +1,80 @@
+# frozen_string_literal: true
+
+RSpec.describe Legion::Extensions::Agentic::Memory::Echo::Runners::CognitiveEcho do
+  let(:engine) { Legion::Extensions::Agentic::Memory::Echo::Helpers::EchoEngine.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: 'test', engine: engine)
+      expect(result[:success]).to be true
+      expect(result[:echo][:content]).to eq('test')
+    end
+  end
+
+  describe '#reinforce_echo' do
+    it 'returns success for known echo' do
+      echo = engine.create_echo(content: 'test', intensity: 0.5)
+      result = runner.reinforce_echo(echo_id: echo.id, engine: engine)
+      expect(result[:success]).to be true
+    end
+
+    it 'returns failure for unknown echo' do
+      result = runner.reinforce_echo(echo_id: 'bad', engine: engine)
+      expect(result[:success]).to be false
+    end
+  end
+
+  describe '#decay_all' do
+    it 'returns success' do
+      result = runner.decay_all(engine: engine)
+      expect(result[:success]).to be true
+    end
+  end
+
+  describe '#active_echoes' do
+    it 'returns active list' do
+      engine.create_echo(content: 'test')
+      result = runner.active_echoes(engine: engine)
+      expect(result[:count]).to eq(1)
+    end
+  end
+
+  describe '#priming_echoes' do
+    it 'returns priming list' do
+      engine.create_echo(content: 'test', intensity: 0.5)
+      result = runner.priming_echoes(engine: engine)
+      expect(result[:count]).to eq(1)
+    end
+  end
+
+  describe '#echoes_by_domain' do
+    it 'filters by domain' do
+      engine.create_echo(content: 'a', domain: :security)
+      result = runner.echoes_by_domain(domain: :security, engine: engine)
+      expect(result[:count]).to eq(1)
+    end
+  end
+
+  describe '#priming_effect' do
+    it 'returns effect and label' do
+      engine.create_echo(content: 'test', domain: :security, intensity: 0.5)
+      result = runner.priming_effect(domain: :security, engine: engine)
+      expect(result[:success]).to be true
+      expect(result[:priming_effect]).to be > 0.0
+    end
+  end
+
+  describe '#echo_status' do
+    it 'returns comprehensive status' do
+      result = runner.echo_status(engine: engine)
+      expect(result[:success]).to be true
+      expect(result).to include(:total_echoes, :echo_chamber_score)
+    end
+  end
+end

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

@@ -0,0 +1,84 @@
+# frozen_string_literal: true
+
+RSpec.describe Legion::Extensions::Agentic::Memory::EchoChamber::Client do
+  subject(:client) { described_class.new }
+
+  describe '#initialize' do
+    it 'creates a client with a default engine' do
+      expect(client).to respond_to(:create_echo)
+    end
+
+    it 'accepts an injected engine' do
+      engine = Legion::Extensions::Agentic::Memory::EchoChamber::Helpers::ChamberEngine.new
+      custom = described_class.new(engine: engine)
+      expect(custom).to respond_to(:chamber_status)
+    end
+  end
+
+  describe 'runner method delegation' do
+    it 'responds to create_echo' do
+      expect(client).to respond_to(:create_echo)
+    end
+
+    it 'responds to create_chamber' do
+      expect(client).to respond_to(:create_chamber)
+    end
+
+    it 'responds to amplify' do
+      expect(client).to respond_to(:amplify)
+    end
+
+    it 'responds to disrupt' do
+      expect(client).to respond_to(:disrupt)
+    end
+
+    it 'responds to list_echoes' do
+      expect(client).to respond_to(:list_echoes)
+    end
+
+    it 'responds to chamber_status' do
+      expect(client).to respond_to(:chamber_status)
+    end
+  end
+
+  describe 'full echo lifecycle' do
+    it 'creates, amplifies, and lists echoes' do
+      result = client.create_echo(content: 'confirmation bias', domain: :cognition, echo_type: :bias)
+      expect(result[:success]).to be true
+      echo_id = result[:echo][:id]
+
+      amplify_result = client.amplify(echo_id: echo_id)
+      expect(amplify_result[:success]).to be true
+      expect(amplify_result[:echo][:amplitude]).to be > 0.5
+
+      list_result = client.list_echoes(echo_type: :bias)
+      expect(list_result[:count]).to eq(1)
+    end
+
+    it 'creates a chamber and disrupts it' do
+      chamber_result = client.create_chamber(label: 'echo chamber', wall_thickness: 0.4)
+      expect(chamber_result[:success]).to be true
+      chamber_id = chamber_result[:chamber][:id]
+
+      disrupt_result = client.disrupt(chamber_id: chamber_id, force: 0.9)
+      expect(disrupt_result[:success]).to be true
+    end
+
+    it 'reports status with echoes and chambers' do
+      client.create_echo(content: 'belief 1')
+      client.create_chamber(label: 'chamber 1')
+
+      status = client.chamber_status
+      expect(status[:total_echoes]).to eq(1)
+      expect(status[:total_chambers]).to eq(1)
+    end
+
+    it 'handles disruption failure gracefully' do
+      chamber_result = client.create_chamber(label: 'fortified', wall_thickness: 0.9)
+      chamber_id     = chamber_result[:chamber][:id]
+
+      result = client.disrupt(chamber_id: chamber_id, force: 0.1)
+      expect(result[:success]).to be false
+    end
+  end
+end