lex-agentic-memory 0.1.0

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

@@ -0,0 +1,213 @@
+# frozen_string_literal: true
+
+RSpec.describe Legion::Extensions::Agentic::Memory::Hologram::Helpers::HolographicFragment do
+  let(:parent_id) { SecureRandom.uuid }
+  let(:content)   { 'the cat sat on the mat' }
+
+  subject(:fragment) do
+    described_class.new(content: content, parent_hologram_id: parent_id)
+  end
+
+  describe '#initialize' do
+    it 'generates a UUID id' do
+      expect(fragment.id).to match(/\A[0-9a-f-]{36}\z/)
+    end
+
+    it 'stores content' do
+      expect(fragment.content).to eq(content)
+    end
+
+    it 'stores parent_hologram_id' do
+      expect(fragment.parent_hologram_id).to eq(parent_id)
+    end
+
+    it 'defaults completeness to 1.0' do
+      expect(fragment.completeness).to eq(1.0)
+    end
+
+    it 'defaults fidelity to 1.0' do
+      expect(fragment.fidelity).to eq(1.0)
+    end
+
+    it 'clamps completeness above 1.0' do
+      f = described_class.new(content: content, parent_hologram_id: parent_id, completeness: 1.5)
+      expect(f.completeness).to eq(1.0)
+    end
+
+    it 'clamps completeness below 0.0' do
+      f = described_class.new(content: content, parent_hologram_id: parent_id, completeness: -0.5)
+      expect(f.completeness).to eq(0.0)
+    end
+
+    it 'clamps fidelity above 1.0' do
+      f = described_class.new(content: content, parent_hologram_id: parent_id, fidelity: 2.0)
+      expect(f.fidelity).to eq(1.0)
+    end
+
+    it 'clamps fidelity below 0.0' do
+      f = described_class.new(content: content, parent_hologram_id: parent_id, fidelity: -1.0)
+      expect(f.fidelity).to eq(0.0)
+    end
+
+    it 'sets created_at to a Time object' do
+      expect(fragment.created_at).to be_a(Time)
+    end
+  end
+
+  describe '#degrade!' do
+    it 'reduces completeness by INTERFERENCE_DECAY' do
+      original = fragment.completeness
+      fragment.degrade!
+      expect(fragment.completeness).to be < original
+    end
+
+    it 'reduces fidelity by INTERFERENCE_DECAY' do
+      original = fragment.fidelity
+      fragment.degrade!
+      expect(fragment.fidelity).to be < original
+    end
+
+    it 'uses default decay rate when no argument given' do
+      original = fragment.completeness
+      fragment.degrade!
+      expected = (original - Legion::Extensions::Agentic::Memory::Hologram::Helpers::Constants::INTERFERENCE_DECAY).round(10)
+      expect(fragment.completeness).to be_within(0.0001).of(expected)
+    end
+
+    it 'accepts a custom decay rate' do
+      original = fragment.completeness
+      fragment.degrade!(0.1)
+      expect(fragment.completeness).to be_within(0.0001).of(original - 0.1)
+    end
+
+    it 'does not go below 0.0' do
+      10.times { fragment.degrade!(0.2) }
+      expect(fragment.completeness).to eq(0.0)
+    end
+
+    it 'returns self for chaining' do
+      expect(fragment.degrade!).to eq(fragment)
+    end
+  end
+
+  describe '#enhance!' do
+    let(:low_fragment) do
+      described_class.new(content: content, parent_hologram_id: parent_id, completeness: 0.5, fidelity: 0.5)
+    end
+
+    it 'increases completeness' do
+      original = low_fragment.completeness
+      low_fragment.enhance!
+      expect(low_fragment.completeness).to be > original
+    end
+
+    it 'increases fidelity' do
+      original = low_fragment.fidelity
+      low_fragment.enhance!
+      expect(low_fragment.fidelity).to be > original
+    end
+
+    it 'accepts a custom boost' do
+      original = low_fragment.completeness
+      low_fragment.enhance!(0.2)
+      expect(low_fragment.completeness).to be_within(0.0001).of(original + 0.2)
+    end
+
+    it 'does not exceed 1.0' do
+      3.times { fragment.enhance!(0.5) }
+      expect(fragment.completeness).to eq(1.0)
+    end
+
+    it 'returns self for chaining' do
+      expect(low_fragment.enhance!).to eq(low_fragment)
+    end
+  end
+
+  describe '#sufficient?' do
+    it 'returns true when completeness exceeds RECONSTRUCTION_THRESHOLD' do
+      f = described_class.new(content: content, parent_hologram_id: parent_id, completeness: 0.5)
+      expect(f.sufficient?).to be true
+    end
+
+    it 'returns false when completeness is at threshold' do
+      threshold = Legion::Extensions::Agentic::Memory::Hologram::Helpers::Constants::RECONSTRUCTION_THRESHOLD
+      f = described_class.new(content: content, parent_hologram_id: parent_id, completeness: threshold)
+      expect(f.sufficient?).to be false
+    end
+
+    it 'returns false when completeness is below threshold' do
+      f = described_class.new(content: content, parent_hologram_id: parent_id, completeness: 0.1)
+      expect(f.sufficient?).to be false
+    end
+  end
+
+  describe '#completeness_label' do
+    it 'returns a symbol' do
+      expect(fragment.completeness_label).to be_a(Symbol)
+    end
+
+    it 'returns :intact for completeness 1.0' do
+      expect(fragment.completeness_label).to eq(:intact)
+    end
+
+    it 'returns :fragmentary for very low completeness' do
+      f = described_class.new(content: content, parent_hologram_id: parent_id, completeness: 0.1)
+      expect(f.completeness_label).to eq(:fragmentary)
+    end
+  end
+
+  describe '#fidelity_label' do
+    it 'returns a symbol' do
+      expect(fragment.fidelity_label).to be_a(Symbol)
+    end
+
+    it 'returns :pristine for fidelity 1.0' do
+      expect(fragment.fidelity_label).to eq(:pristine)
+    end
+
+    it 'returns :corrupted for very low fidelity' do
+      f = described_class.new(content: content, parent_hologram_id: parent_id, fidelity: 0.1)
+      expect(f.fidelity_label).to eq(:corrupted)
+    end
+  end
+
+  describe '#to_h' do
+    subject(:hash) { fragment.to_h }
+
+    it 'includes :id' do
+      expect(hash[:id]).to eq(fragment.id)
+    end
+
+    it 'includes :parent_hologram_id' do
+      expect(hash[:parent_hologram_id]).to eq(parent_id)
+    end
+
+    it 'includes :content' do
+      expect(hash[:content]).to eq(content)
+    end
+
+    it 'includes :completeness' do
+      expect(hash[:completeness]).to eq(fragment.completeness)
+    end
+
+    it 'includes :fidelity' do
+      expect(hash[:fidelity]).to eq(fragment.fidelity)
+    end
+
+    it 'includes :completeness_label as symbol' do
+      expect(hash[:completeness_label]).to be_a(Symbol)
+    end
+
+    it 'includes :fidelity_label as symbol' do
+      expect(hash[:fidelity_label]).to be_a(Symbol)
+    end
+
+    it 'includes :sufficient as boolean' do
+      expect(hash[:sufficient]).to be(true).or be(false)
+    end
+
+    it 'includes :created_at as ISO8601 string' do
+      expect(hash[:created_at]).to match(/\d{4}-\d{2}-\d{2}T/)
+    end
+  end
+end

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

@@ -0,0 +1,239 @@
+# frozen_string_literal: true
+
+RSpec.describe Legion::Extensions::Agentic::Memory::Hologram::Runners::CognitiveHologram do
+  subject(:runner) do
+    obj = Object.new
+    obj.extend(described_class)
+    obj
+  end
+
+  let(:engine) { Legion::Extensions::Agentic::Memory::Hologram::Helpers::HologramEngine.new }
+
+  describe '#create' do
+    it 'returns success: true for valid input' do
+      result = runner.create(domain: :memory, content: 'test content here', engine: engine)
+      expect(result[:success]).to be true
+    end
+
+    it 'returns the hologram hash' do
+      result = runner.create(domain: :memory, content: 'test content', engine: engine)
+      expect(result[:hologram]).to be_a(Hash)
+    end
+
+    it 'includes the hologram id in the result' do
+      result = runner.create(domain: :memory, content: 'test content', engine: engine)
+      expect(result[:hologram][:id]).to match(/\A[0-9a-f-]{36}\z/)
+    end
+
+    it 'uses the provided domain' do
+      result = runner.create(domain: :emotion, content: 'emotion content', engine: engine)
+      expect(result[:hologram][:domain]).to eq(:emotion)
+    end
+
+    it 'returns success: false for empty content' do
+      result = runner.create(domain: :memory, content: '', engine: engine)
+      expect(result[:success]).to be false
+    end
+
+    it 'returns success: false for whitespace-only content' do
+      result = runner.create(domain: :memory, content: '   ', engine: engine)
+      expect(result[:success]).to be false
+    end
+
+    it 'includes error message on failure' do
+      result = runner.create(domain: :memory, content: '', engine: engine)
+      expect(result[:error]).to be_a(String)
+    end
+
+    it 'accepts extra keyword arguments via ** splat' do
+      expect do
+        runner.create(domain: :memory, content: 'valid', engine: engine, extra: :ignored)
+      end.not_to raise_error
+    end
+  end
+
+  describe '#fragment' do
+    let(:hologram_id) do
+      runner.create(domain: :memory, content: 'fragment test content', engine: engine)[:hologram][:id]
+    end
+
+    it 'returns success: true for existing hologram' do
+      result = runner.fragment(hologram_id: hologram_id, count: 3, engine: engine)
+      expect(result[:success]).to be true
+    end
+
+    it 'returns fragment_count matching request' do
+      result = runner.fragment(hologram_id: hologram_id, count: 3, engine: engine)
+      expect(result[:fragment_count]).to eq(3)
+    end
+
+    it 'returns fragments as array of hashes' do
+      result = runner.fragment(hologram_id: hologram_id, count: 2, engine: engine)
+      expect(result[:fragments]).to be_an(Array)
+      expect(result[:fragments].first).to be_a(Hash)
+    end
+
+    it 'returns success: false for unknown hologram_id' do
+      result = runner.fragment(hologram_id: SecureRandom.uuid, count: 2, engine: engine)
+      expect(result[:success]).to be false
+      expect(result[:reason]).to eq(:hologram_not_found)
+    end
+
+    it 'accepts extra keyword arguments' do
+      expect do
+        runner.fragment(hologram_id: hologram_id, count: 2, engine: engine, extra: :ignored)
+      end.not_to raise_error
+    end
+  end
+
+  describe '#reconstruct' do
+    let(:hologram_id) do
+      runner.create(domain: :memory, content: 'reconstruction test content', engine: engine)[:hologram][:id]
+    end
+    let(:fragment_ids) do
+      result = runner.fragment(hologram_id: hologram_id, count: 4, engine: engine)
+      result[:fragments].select { |f| f[:sufficient] }.map { |f| f[:id] }
+    end
+
+    it 'returns success true when sufficient fragments provided' do
+      result = runner.reconstruct(hologram_id: hologram_id, fragment_ids: fragment_ids, engine: engine)
+      expect(result[:success]).to be(true).or be(false)
+    end
+
+    it 'returns a resolution value on successful reconstruction' do
+      result = runner.reconstruct(hologram_id: hologram_id, fragment_ids: fragment_ids, engine: engine)
+      expect(result[:resolution]).to be_a(Float) if result[:success]
+    end
+
+    it 'returns success: false for unknown hologram_id' do
+      result = runner.reconstruct(
+        hologram_id:  SecureRandom.uuid,
+        fragment_ids: [],
+        engine:       engine
+      )
+      expect(result[:success]).to be false
+    end
+
+    it 'accepts extra keyword arguments' do
+      expect do
+        runner.reconstruct(hologram_id: hologram_id, fragment_ids: [], engine: engine, extra: :ok)
+      end.not_to raise_error
+    end
+  end
+
+  describe '#list_holograms' do
+    before do
+      3.times { |i| runner.create(domain: :memory, content: "hologram number #{i}", engine: engine) }
+    end
+
+    it 'returns success: true' do
+      result = runner.list_holograms(engine: engine)
+      expect(result[:success]).to be true
+    end
+
+    it 'returns holograms as array' do
+      result = runner.list_holograms(engine: engine)
+      expect(result[:holograms]).to be_an(Array)
+    end
+
+    it 'returns count matching holograms array size' do
+      result = runner.list_holograms(engine: engine)
+      expect(result[:count]).to eq(result[:holograms].size)
+    end
+
+    it 'respects the limit parameter' do
+      result = runner.list_holograms(limit: 2, engine: engine)
+      expect(result[:holograms].size).to be <= 2
+    end
+
+    it 'returns 3 holograms with default limit' do
+      result = runner.list_holograms(engine: engine)
+      expect(result[:count]).to eq(3)
+    end
+
+    it 'accepts extra keyword arguments' do
+      expect do
+        runner.list_holograms(engine: engine, extra: :ignored)
+      end.not_to raise_error
+    end
+  end
+
+  describe '#interference_check' do
+    let(:id_a) do
+      runner.create(domain: :memory, content: 'the quick brown fox', engine: engine)[:hologram][:id]
+    end
+    let(:id_b) do
+      runner.create(domain: :memory, content: 'the quick brown fox', engine: engine)[:hologram][:id]
+    end
+
+    it 'returns success: true for known holograms' do
+      result = runner.interference_check(hologram_id_a: id_a, hologram_id_b: id_b, engine: engine)
+      expect(result[:success]).to be true
+    end
+
+    it 'returns interference score as float' do
+      result = runner.interference_check(hologram_id_a: id_a, hologram_id_b: id_b, engine: engine)
+      expect(result[:interference]).to be_a(Float)
+    end
+
+    it 'returns a label' do
+      result = runner.interference_check(hologram_id_a: id_a, hologram_id_b: id_b, engine: engine)
+      expect(result[:label]).to be_a(Symbol)
+    end
+
+    it 'includes success key even on missing hologram' do
+      result = runner.interference_check(
+        hologram_id_a: SecureRandom.uuid,
+        hologram_id_b: id_b,
+        engine:        engine
+      )
+      expect(result).to have_key(:success)
+    end
+
+    it 'accepts extra keyword arguments' do
+      expect do
+        runner.interference_check(hologram_id_a: id_a, hologram_id_b: id_b, engine: engine, extra: :ok)
+      end.not_to raise_error
+    end
+  end
+
+  describe '#hologram_status' do
+    before do
+      2.times do |i|
+        h_result = runner.create(domain: :memory, content: "status test hologram #{i}", engine: engine)
+        runner.fragment(hologram_id: h_result[:hologram][:id], count: 2, engine: engine)
+      end
+    end
+
+    it 'returns success: true' do
+      result = runner.hologram_status(engine: engine)
+      expect(result[:success]).to be true
+    end
+
+    it 'returns a report hash' do
+      result = runner.hologram_status(engine: engine)
+      expect(result[:report]).to be_a(Hash)
+    end
+
+    it 'report includes total_holograms' do
+      result = runner.hologram_status(engine: engine)
+      expect(result[:report][:total_holograms]).to eq(2)
+    end
+
+    it 'report includes average_resolution' do
+      result = runner.hologram_status(engine: engine)
+      expect(result[:report][:average_resolution]).to be_a(Float)
+    end
+
+    it 'report includes resolution_label' do
+      result = runner.hologram_status(engine: engine)
+      expect(result[:report][:resolution_label]).to be_a(Symbol)
+    end
+
+    it 'accepts extra keyword arguments' do
+      expect do
+        runner.hologram_status(engine: engine, extra: :ignored)
+      end.not_to raise_error
+    end
+  end
+end

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

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+RSpec.describe Legion::Extensions::Agentic::Memory::ImmuneMemory::Client do
+  subject(:client) { described_class.new }
+
+  it 'responds to runner methods' do
+    expect(client).to respond_to(:create_memory_cell, :vaccinate, :encounter_threat, :immune_status)
+  end
+
+  it 'runs a full immune lifecycle' do
+    client.vaccinate(threat_type: :prompt_injection, signature: 'known-threat')
+    result = client.encounter_threat(threat_type: :prompt_injection, threat_signature: 'known-threat')
+    expect(result[:encounter][:response_type]).to eq(:secondary)
+
+    status = client.immune_status
+    expect(status[:total_cells]).to be >= 1
+  end
+end

data/spec/legion/extensions/agentic/memory/immune_memory/cognitive_immune_memory_spec.rb

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

data/spec/legion/extensions/agentic/memory/immune_memory/helpers/encounter_spec.rb

@@ -0,0 +1,85 @@
+# frozen_string_literal: true
+
+RSpec.describe Legion::Extensions::Agentic::Memory::ImmuneMemory::Helpers::Encounter do
+  subject(:encounter) do
+    described_class.new(threat_type: :prompt_injection, threat_signature: 'sig-001', severity: 0.7)
+  end
+
+  describe '#initialize' do
+    it 'assigns a UUID id' do
+      expect(encounter.id).to match(/\A[0-9a-f-]{36}\z/)
+    end
+
+    it 'stores threat_type' do
+      expect(encounter.threat_type).to eq(:prompt_injection)
+    end
+
+    it 'stores threat_signature' do
+      expect(encounter.threat_signature).to eq('sig-001')
+    end
+
+    it 'stores severity' do
+      expect(encounter.severity).to eq(0.7)
+    end
+
+    it 'defaults response_type to primary' do
+      expect(encounter.response_type).to eq(:primary)
+    end
+
+    it 'defaults outcome to neutralized' do
+      expect(encounter.outcome).to eq(:neutralized)
+    end
+  end
+
+  describe '#secondary?' do
+    it 'is false for primary' do
+      expect(encounter.secondary?).to be false
+    end
+
+    it 'is true for secondary' do
+      sec = described_class.new(threat_type: :logic_manipulation, threat_signature: 's',
+                                response_type: :secondary)
+      expect(sec.secondary?).to be true
+    end
+  end
+
+  describe '#primary?' do
+    it 'is true for primary' do
+      expect(encounter.primary?).to be true
+    end
+  end
+
+  describe '#neutralized?' do
+    it 'is true when neutralized' do
+      expect(encounter.neutralized?).to be true
+    end
+  end
+
+  describe '#evaded?' do
+    it 'is true when evaded' do
+      evaded = described_class.new(threat_type: :data_poisoning, threat_signature: 's', outcome: :evaded)
+      expect(evaded.evaded?).to be true
+    end
+  end
+
+  describe '#critical?' do
+    it 'is false for moderate severity' do
+      expect(encounter.critical?).to be false
+    end
+
+    it 'is true for high severity' do
+      crit = described_class.new(threat_type: :resource_exhaustion, threat_signature: 's', severity: 0.9)
+      expect(crit.critical?).to be true
+    end
+  end
+
+  describe '#to_h' do
+    it 'includes all fields' do
+      hash = encounter.to_h
+      expect(hash).to include(
+        :id, :threat_type, :threat_signature, :severity,
+        :response_type, :response_speed, :outcome, :critical, :created_at
+      )
+    end
+  end
+end