lex-agentic-memory 0.1.0

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

@@ -0,0 +1,208 @@
+# frozen_string_literal: true
+
+RSpec.describe Legion::Extensions::Agentic::Memory::Episodic::Runners::EpisodicBuffer do
+  let(:store) { Legion::Extensions::Agentic::Memory::Episodic::Helpers::EpisodicStore.new }
+
+  let(:runner) do
+    obj = Object.new
+    obj.extend(described_module)
+    obj.instance_variable_set(:@default_store, store)
+    obj
+  end
+
+  let(:described_module) { described_class }
+
+  subject(:runner_instance) { runner }
+
+  describe '#create_episode' do
+    it 'returns success true' do
+      result = runner_instance.create_episode
+      expect(result[:success]).to be true
+    end
+
+    it 'returns an episode_id' do
+      result = runner_instance.create_episode
+      expect(result[:episode_id]).not_to be_nil
+    end
+
+    it 'returns created_at' do
+      result = runner_instance.create_episode
+      expect(result[:created_at]).to be_a(Time)
+    end
+  end
+
+  describe '#add_binding' do
+    let(:episode_id) { runner_instance.create_episode[:episode_id] }
+
+    it 'returns success true for valid binding' do
+      result = runner_instance.add_binding(
+        episode_id: episode_id, modality: :verbal, content: 'hello', source: :phonological_loop
+      )
+      expect(result[:success]).to be true
+    end
+
+    it 'returns a binding_id' do
+      result = runner_instance.add_binding(
+        episode_id: episode_id, modality: :visual, content: 'image', source: :visuospatial
+      )
+      expect(result[:binding_id]).not_to be_nil
+    end
+
+    it 'returns success false for nonexistent episode' do
+      result = runner_instance.add_binding(
+        episode_id: 'missing', modality: :verbal, content: 'x', source: :test
+      )
+      expect(result[:success]).to be false
+    end
+
+    it 'raises ArgumentError for invalid modality' do
+      expect do
+        runner_instance.add_binding(episode_id: episode_id, modality: :invalid, content: 'x', source: :test)
+      end.to raise_error(ArgumentError, /invalid modality/)
+    end
+  end
+
+  describe '#attend_episode' do
+    let(:episode_id) { runner_instance.create_episode[:episode_id] }
+
+    it 'returns success true for existing episode' do
+      result = runner_instance.attend_episode(episode_id: episode_id)
+      expect(result[:success]).to be true
+    end
+
+    it 'returns success false for missing episode' do
+      result = runner_instance.attend_episode(episode_id: 'missing')
+      expect(result[:success]).to be false
+    end
+  end
+
+  describe '#rehearse_episode' do
+    let(:episode_id) { runner_instance.create_episode[:episode_id] }
+
+    it 'returns success true for existing episode' do
+      result = runner_instance.rehearse_episode(episode_id: episode_id)
+      expect(result[:success]).to be true
+    end
+
+    it 'returns success false for missing episode' do
+      result = runner_instance.rehearse_episode(episode_id: 'missing')
+      expect(result[:success]).to be false
+    end
+  end
+
+  describe '#check_integration' do
+    let(:episode_id) { runner_instance.create_episode[:episode_id] }
+
+    it 'returns success true always' do
+      result = runner_instance.check_integration(episode_id: episode_id)
+      expect(result[:success]).to be true
+    end
+
+    it 'includes integrated boolean' do
+      result = runner_instance.check_integration(episode_id: episode_id)
+      expect(result).to have_key(:integrated)
+    end
+
+    it 'reports not integrated for empty episode' do
+      result = runner_instance.check_integration(episode_id: episode_id)
+      expect(result[:integrated]).to be false
+    end
+
+    it 'reports integrated for high-strength bindings' do
+      runner_instance.add_binding(episode_id: episode_id, modality: :verbal, content: 'a', source: :test, strength: 0.9)
+      runner_instance.add_binding(episode_id: episode_id, modality: :visual, content: 'b', source: :test, strength: 0.9)
+      result = runner_instance.check_integration(episode_id: episode_id)
+      expect(result[:integrated]).to be true
+    end
+  end
+
+  describe '#retrieve_by_modality' do
+    before do
+      id = runner_instance.create_episode[:episode_id]
+      runner_instance.add_binding(episode_id: id, modality: :verbal, content: 'word', source: :test)
+    end
+
+    it 'returns success true' do
+      result = runner_instance.retrieve_by_modality(modality: :verbal)
+      expect(result[:success]).to be true
+    end
+
+    it 'returns matching episodes' do
+      result = runner_instance.retrieve_by_modality(modality: :verbal)
+      expect(result[:count]).to eq(1)
+    end
+
+    it 'returns empty for non-matching modality' do
+      result = runner_instance.retrieve_by_modality(modality: :temporal)
+      expect(result[:count]).to eq(0)
+    end
+  end
+
+  describe '#retrieve_multimodal' do
+    it 'returns success true' do
+      result = runner_instance.retrieve_multimodal
+      expect(result[:success]).to be true
+    end
+
+    it 'returns only multimodal episodes' do
+      id = runner_instance.create_episode[:episode_id]
+      runner_instance.add_binding(episode_id: id, modality: :verbal, content: 'a', source: :test)
+      runner_instance.add_binding(episode_id: id, modality: :visual, content: 'b', source: :test)
+
+      unimodal_id = runner_instance.create_episode[:episode_id]
+      runner_instance.add_binding(episode_id: unimodal_id, modality: :verbal, content: 'c', source: :test)
+
+      result = runner_instance.retrieve_multimodal
+      expect(result[:count]).to eq(1)
+    end
+  end
+
+  describe '#most_coherent' do
+    it 'returns success true' do
+      result = runner_instance.most_coherent
+      expect(result[:success]).to be true
+    end
+
+    it 'returns up to limit episodes' do
+      3.times { runner_instance.create_episode }
+      result = runner_instance.most_coherent(limit: 2)
+      expect(result[:count]).to be <= 2
+    end
+
+    it 'defaults limit to 5' do
+      result = runner_instance.most_coherent
+      expect(result[:count]).to be <= 5
+    end
+  end
+
+  describe '#update_episodic_buffer' do
+    it 'returns success true' do
+      result = runner_instance.update_episodic_buffer
+      expect(result[:success]).to be true
+    end
+
+    it 'returns decayed and expired counts' do
+      runner_instance.create_episode
+      result = runner_instance.update_episodic_buffer
+      expect(result).to include(:decayed, :expired)
+    end
+  end
+
+  describe '#episodic_buffer_stats' do
+    it 'returns success true' do
+      result = runner_instance.episodic_buffer_stats
+      expect(result[:success]).to be true
+    end
+
+    it 'includes episode_count' do
+      result = runner_instance.episodic_buffer_stats
+      expect(result).to have_key(:episode_count)
+    end
+
+    it 'reflects current state' do
+      runner_instance.create_episode
+      result = runner_instance.episodic_buffer_stats
+      expect(result[:episode_count]).to eq(1)
+    end
+  end
+end

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

@@ -0,0 +1,89 @@
+# frozen_string_literal: true
+
+RSpec.describe Legion::Extensions::Agentic::Memory::Hologram::Client do
+  subject(:client) { described_class.new }
+
+  it 'can be instantiated' do
+    expect(client).to be_a(described_class)
+  end
+
+  it 'includes Runners::CognitiveHologram' do
+    expect(client).to respond_to(:create)
+    expect(client).to respond_to(:fragment)
+    expect(client).to respond_to(:reconstruct)
+    expect(client).to respond_to(:list_holograms)
+    expect(client).to respond_to(:interference_check)
+    expect(client).to respond_to(:hologram_status)
+  end
+
+  it 'accepts an injected engine' do
+    engine = Legion::Extensions::Agentic::Memory::Hologram::Helpers::HologramEngine.new
+    c = described_class.new(engine: engine)
+    result = c.create(domain: :memory, content: 'injected engine test')
+    expect(result[:success]).to be true
+  end
+
+  describe '#create' do
+    it 'creates a hologram and returns success' do
+      result = client.create(domain: :trust, content: 'client create test content')
+      expect(result[:success]).to be true
+    end
+
+    it 'returns hologram with uuid id' do
+      result = client.create(domain: :trust, content: 'client id test')
+      expect(result[:hologram][:id]).to match(/\A[0-9a-f-]{36}\z/)
+    end
+  end
+
+  describe '#fragment' do
+    it 'fragments an existing hologram' do
+      create_result = client.create(domain: :memory, content: 'fragment me please')
+      hologram_id   = create_result[:hologram][:id]
+      result        = client.fragment(hologram_id: hologram_id, count: 3)
+      expect(result[:success]).to be true
+      expect(result[:fragment_count]).to eq(3)
+    end
+  end
+
+  describe '#hologram_status' do
+    it 'returns a report' do
+      client.create(domain: :memory, content: 'status check content')
+      result = client.hologram_status
+      expect(result[:success]).to be true
+      expect(result[:report][:total_holograms]).to eq(1)
+    end
+  end
+
+  describe '#list_holograms' do
+    before do
+      2.times { |i| client.create(domain: :memory, content: "list test hologram #{i}") }
+    end
+
+    it 'returns all created holograms' do
+      result = client.list_holograms
+      expect(result[:count]).to eq(2)
+    end
+  end
+
+  describe '#interference_check' do
+    let(:id_a) { client.create(domain: :memory, content: 'shared words here')[:hologram][:id] }
+    let(:id_b) { client.create(domain: :memory, content: 'shared words here')[:hologram][:id] }
+
+    it 'returns interference data' do
+      result = client.interference_check(hologram_id_a: id_a, hologram_id_b: id_b)
+      expect(result[:success]).to be true
+      expect(result[:interference]).to be_a(Float)
+    end
+  end
+
+  describe '#reconstruct' do
+    let(:hologram_id) { client.create(domain: :memory, content: 'reconstruct me content')[:hologram][:id] }
+
+    it 'attempts reconstruction and returns a result hash' do
+      frag_result = client.fragment(hologram_id: hologram_id, count: 4)
+      ids = frag_result[:fragments].select { |f| f[:sufficient] }.map { |f| f[:id] }
+      result = client.reconstruct(hologram_id: hologram_id, fragment_ids: ids)
+      expect(result).to have_key(:success)
+    end
+  end
+end

data/spec/legion/extensions/agentic/memory/hologram/cognitive_hologram_spec.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+RSpec.describe Legion::Extensions::Agentic::Memory::Hologram do
+  it 'defines a VERSION constant' do
+    expect(described_class::VERSION).to eq('0.1.0')
+  end
+
+  it 'defines the Helpers module' do
+    expect(described_class).to be_const_defined(:Helpers)
+  end
+
+  it 'defines the Runners module' do
+    expect(described_class).to be_const_defined(:Runners)
+  end
+
+  it 'defines the Client class' do
+    expect(described_class).to be_const_defined(:Client)
+  end
+
+  it 'defines Helpers::Constants' do
+    expect(described_class::Helpers).to be_const_defined(:Constants)
+  end
+
+  it 'defines Helpers::HolographicFragment' do
+    expect(described_class::Helpers).to be_const_defined(:HolographicFragment)
+  end
+
+  it 'defines Helpers::Hologram' do
+    expect(described_class::Helpers).to be_const_defined(:Hologram)
+  end
+
+  it 'defines Helpers::HologramEngine' do
+    expect(described_class::Helpers).to be_const_defined(:HologramEngine)
+  end
+
+  it 'defines Runners::CognitiveHologram' do
+    expect(described_class::Runners).to be_const_defined(:CognitiveHologram)
+  end
+end

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

@@ -0,0 +1,143 @@
+# frozen_string_literal: true
+
+RSpec.describe Legion::Extensions::Agentic::Memory::Hologram::Helpers::Constants do
+  subject(:constants) { described_class }
+
+  describe 'RESOLUTION_LEVELS' do
+    it 'is a frozen array of symbols' do
+      expect(described_class::RESOLUTION_LEVELS).to be_frozen
+      expect(described_class::RESOLUTION_LEVELS).to all(be_a(Symbol))
+    end
+
+    it 'contains the expected levels in order' do
+      expect(described_class::RESOLUTION_LEVELS).to eq(%i[perfect high medium low fragmentary])
+    end
+  end
+
+  describe 'MAX_HOLOGRAMS' do
+    it 'is 100' do
+      expect(described_class::MAX_HOLOGRAMS).to eq(100)
+    end
+  end
+
+  describe 'INTERFERENCE_DECAY' do
+    it 'is 0.03' do
+      expect(described_class::INTERFERENCE_DECAY).to eq(0.03)
+    end
+  end
+
+  describe 'RECONSTRUCTION_THRESHOLD' do
+    it 'is 0.3' do
+      expect(described_class::RECONSTRUCTION_THRESHOLD).to eq(0.3)
+    end
+  end
+
+  describe 'FRAGMENT_LABELS' do
+    it 'is a frozen array' do
+      expect(described_class::FRAGMENT_LABELS).to be_frozen
+    end
+
+    it 'maps 1.0 to :intact' do
+      expect(described_class.label_for(described_class::FRAGMENT_LABELS, 1.0)).to eq(:intact)
+    end
+
+    it 'maps 0.95 to :intact' do
+      expect(described_class.label_for(described_class::FRAGMENT_LABELS, 0.95)).to eq(:intact)
+    end
+
+    it 'maps 0.75 to :substantial' do
+      expect(described_class.label_for(described_class::FRAGMENT_LABELS, 0.75)).to eq(:substantial)
+    end
+
+    it 'maps 0.55 to :partial' do
+      expect(described_class.label_for(described_class::FRAGMENT_LABELS, 0.55)).to eq(:partial)
+    end
+
+    it 'maps 0.35 to :degraded' do
+      expect(described_class.label_for(described_class::FRAGMENT_LABELS, 0.35)).to eq(:degraded)
+    end
+
+    it 'maps 0.1 to :fragmentary' do
+      expect(described_class.label_for(described_class::FRAGMENT_LABELS, 0.1)).to eq(:fragmentary)
+    end
+  end
+
+  describe 'RESOLUTION_LABELS' do
+    it 'maps 0.95 to :perfect' do
+      expect(described_class.label_for(described_class::RESOLUTION_LABELS, 0.95)).to eq(:perfect)
+    end
+
+    it 'maps 0.75 to :high' do
+      expect(described_class.label_for(described_class::RESOLUTION_LABELS, 0.75)).to eq(:high)
+    end
+
+    it 'maps 0.55 to :medium' do
+      expect(described_class.label_for(described_class::RESOLUTION_LABELS, 0.55)).to eq(:medium)
+    end
+
+    it 'maps 0.35 to :low' do
+      expect(described_class.label_for(described_class::RESOLUTION_LABELS, 0.35)).to eq(:low)
+    end
+
+    it 'maps 0.1 to :fragmentary' do
+      expect(described_class.label_for(described_class::RESOLUTION_LABELS, 0.1)).to eq(:fragmentary)
+    end
+  end
+
+  describe 'FIDELITY_LABELS' do
+    it 'maps 0.9 to :pristine' do
+      expect(described_class.label_for(described_class::FIDELITY_LABELS, 0.9)).to eq(:pristine)
+    end
+
+    it 'maps 0.65 to :clear' do
+      expect(described_class.label_for(described_class::FIDELITY_LABELS, 0.65)).to eq(:clear)
+    end
+
+    it 'maps 0.45 to :hazy' do
+      expect(described_class.label_for(described_class::FIDELITY_LABELS, 0.45)).to eq(:hazy)
+    end
+
+    it 'maps 0.25 to :clouded' do
+      expect(described_class.label_for(described_class::FIDELITY_LABELS, 0.25)).to eq(:clouded)
+    end
+
+    it 'maps 0.1 to :corrupted' do
+      expect(described_class.label_for(described_class::FIDELITY_LABELS, 0.1)).to eq(:corrupted)
+    end
+  end
+
+  describe 'INTERFERENCE_LABELS' do
+    it 'maps 0.8 to :strong' do
+      expect(described_class.label_for(described_class::INTERFERENCE_LABELS, 0.8)).to eq(:strong)
+    end
+
+    it 'maps 0.5 to :moderate' do
+      expect(described_class.label_for(described_class::INTERFERENCE_LABELS, 0.5)).to eq(:moderate)
+    end
+
+    it 'maps 0.2 to :weak' do
+      expect(described_class.label_for(described_class::INTERFERENCE_LABELS, 0.2)).to eq(:weak)
+    end
+
+    it 'maps 0.05 to :negligible' do
+      expect(described_class.label_for(described_class::INTERFERENCE_LABELS, 0.05)).to eq(:negligible)
+    end
+  end
+
+  describe '.label_for' do
+    it 'returns a symbol' do
+      label = described_class.label_for(described_class::RESOLUTION_LABELS, 0.5)
+      expect(label).to be_a(Symbol)
+    end
+
+    it 'falls back to last label for values below all ranges' do
+      label = described_class.label_for(described_class::RESOLUTION_LABELS, -0.1)
+      expect(label).to eq(:fragmentary)
+    end
+
+    it 'matches the first matching range' do
+      label = described_class.label_for(described_class::RESOLUTION_LABELS, 1.0)
+      expect(label).to eq(:perfect)
+    end
+  end
+end