lex-agentic-memory 0.1.0

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

@@ -0,0 +1,203 @@
+# frozen_string_literal: true
+
+RSpec.describe Legion::Extensions::Agentic::Memory::ImmuneMemory::Helpers::ImmuneMemoryEngine do
+  subject(:engine) { described_class.new }
+
+  describe '#create_memory_cell' do
+    it 'creates and returns a cell' do
+      cell = engine.create_memory_cell(threat_type: :prompt_injection, signature: 'sig-001')
+      expect(cell.threat_type).to eq(:prompt_injection)
+    end
+  end
+
+  describe '#vaccinate' do
+    it 'creates a new cell for unknown signature' do
+      cell = engine.vaccinate(threat_type: :data_poisoning, signature: 'vax-001')
+      expect(cell.strength).to eq(0.5)
+    end
+
+    it 'activates existing cell for known signature' do
+      engine.vaccinate(threat_type: :data_poisoning, signature: 'vax-001')
+      cell = engine.vaccinate(threat_type: :data_poisoning, signature: 'vax-001')
+      expect(cell.encounter_count).to eq(1)
+    end
+  end
+
+  describe '#encounter_threat' do
+    it 'returns a primary encounter for new threat' do
+      record = engine.encounter_threat(threat_type: :prompt_injection, threat_signature: 'new-sig')
+      expect(record.response_type).to eq(:primary)
+    end
+
+    it 'returns a secondary encounter for known threat' do
+      engine.vaccinate(threat_type: :prompt_injection, signature: 'known-sig', strength: 0.7)
+      record = engine.encounter_threat(threat_type: :prompt_injection, threat_signature: 'known-sig')
+      expect(record.response_type).to eq(:secondary)
+    end
+
+    it 'creates a memory cell after first encounter' do
+      engine.encounter_threat(threat_type: :social_engineering, threat_signature: 'first-sig')
+      expect(engine.active_cells.size).to eq(1)
+    end
+
+    it 'neutralizes weak threats' do
+      record = engine.encounter_threat(threat_type: :logic_manipulation, threat_signature: 'weak', severity: 0.3)
+      expect(record.neutralized?).to be true
+    end
+
+    it 'may fail against strong threats without memory' do
+      record = engine.encounter_threat(threat_type: :privilege_escalation, threat_signature: 'strong', severity: 0.9)
+      expect(record.evaded?).to be true
+    end
+
+    it 'neutralizes strong threats with strong memory' do
+      cell = engine.vaccinate(threat_type: :privilege_escalation, signature: 'strong', strength: 0.95)
+      3.times { cell.activate! }
+      record = engine.encounter_threat(threat_type: :privilege_escalation, threat_signature: 'strong', severity: 0.9)
+      expect(record.neutralized?).to be true
+    end
+  end
+
+  describe '#decay_all!' do
+    it 'decays all cells' do
+      engine.create_memory_cell(threat_type: :prompt_injection, signature: 's1')
+      result = engine.decay_all!
+      expect(result[:cells_remaining]).to be >= 0
+    end
+  end
+
+  describe '#find_by_signature' do
+    it 'finds matching cell' do
+      engine.create_memory_cell(threat_type: :prompt_injection, signature: 'find-me')
+      expect(engine.find_by_signature('find-me')).not_to be_nil
+    end
+
+    it 'returns nil for unknown signature' do
+      expect(engine.find_by_signature('nope')).to be_nil
+    end
+  end
+
+  describe '#cells_for_threat' do
+    it 'filters by threat type' do
+      engine.create_memory_cell(threat_type: :prompt_injection, signature: 's1')
+      engine.create_memory_cell(threat_type: :data_poisoning, signature: 's2')
+      expect(engine.cells_for_threat(threat_type: :prompt_injection).size).to eq(1)
+    end
+  end
+
+  describe '#immunity_for' do
+    it 'returns 0.0 for unknown threat type' do
+      expect(engine.immunity_for(threat_type: :unknown_threat)).to eq(0.0)
+    end
+
+    it 'returns max strength for known threat' do
+      engine.create_memory_cell(threat_type: :prompt_injection, signature: 's1', strength: 0.8)
+      expect(engine.immunity_for(threat_type: :prompt_injection)).to eq(0.8)
+    end
+  end
+
+  describe '#active_cells' do
+    it 'excludes expired cells' do
+      cell = engine.create_memory_cell(threat_type: :prompt_injection, signature: 's1', strength: 0.01)
+      2.times { cell.decay! }
+      expect(engine.active_cells).to be_empty
+    end
+  end
+
+  describe '#t_cells' do
+    it 'returns only t-type cells' do
+      engine.create_memory_cell(threat_type: :prompt_injection, signature: 's1', cell_type: :t_killer)
+      engine.create_memory_cell(threat_type: :data_poisoning, signature: 's2', cell_type: :b_memory)
+      expect(engine.t_cells.size).to eq(1)
+    end
+  end
+
+  describe '#b_cells' do
+    it 'returns only b-type cells' do
+      engine.create_memory_cell(threat_type: :prompt_injection, signature: 's1', cell_type: :t_killer)
+      engine.create_memory_cell(threat_type: :data_poisoning, signature: 's2', cell_type: :b_plasma)
+      expect(engine.b_cells.size).to eq(1)
+    end
+  end
+
+  describe '#veteran_cells' do
+    it 'returns cells with 5+ encounters' do
+      cell = engine.create_memory_cell(threat_type: :prompt_injection, signature: 's1')
+      5.times { cell.activate! }
+      expect(engine.veteran_cells.size).to eq(1)
+    end
+  end
+
+  describe '#naive_cells' do
+    it 'returns cells with 0 encounters' do
+      engine.create_memory_cell(threat_type: :prompt_injection, signature: 's1')
+      expect(engine.naive_cells.size).to eq(1)
+    end
+  end
+
+  describe '#secondary_response_rate' do
+    it 'returns 0.0 with no encounters' do
+      expect(engine.secondary_response_rate).to eq(0.0)
+    end
+
+    it 'calculates rate correctly' do
+      engine.vaccinate(threat_type: :prompt_injection, signature: 'known', strength: 0.7)
+      engine.encounter_threat(threat_type: :prompt_injection, threat_signature: 'known')
+      engine.encounter_threat(threat_type: :data_poisoning, threat_signature: 'new')
+      expect(engine.secondary_response_rate).to eq(0.5)
+    end
+  end
+
+  describe '#neutralization_rate' do
+    it 'returns 0.0 with no encounters' do
+      expect(engine.neutralization_rate).to eq(0.0)
+    end
+  end
+
+  describe '#average_response_speed' do
+    it 'returns primary speed with no encounters' do
+      expect(engine.average_response_speed).to eq(1.0)
+    end
+  end
+
+  describe '#threat_coverage' do
+    it 'returns 0.0 with no cells' do
+      expect(engine.threat_coverage).to eq(0.0)
+    end
+
+    it 'increases with known threat types' do
+      engine.create_memory_cell(threat_type: :prompt_injection, signature: 's1')
+      engine.create_memory_cell(threat_type: :data_poisoning, signature: 's2')
+      expect(engine.threat_coverage).to be > 0.0
+    end
+  end
+
+  describe '#overall_health' do
+    it 'returns 0.0 with no cells' do
+      expect(engine.overall_health).to eq(0.0)
+    end
+
+    it 'returns positive with cells' do
+      engine.create_memory_cell(threat_type: :prompt_injection, signature: 's1', strength: 0.8)
+      expect(engine.overall_health).to be > 0.0
+    end
+  end
+
+  describe '#immune_report' do
+    it 'includes all report fields' do
+      report = engine.immune_report
+      expect(report).to include(
+        :total_cells, :active_cells, :t_cells, :b_cells, :veteran_cells,
+        :total_encounters, :secondary_response_rate, :neutralization_rate,
+        :average_response_speed, :threat_coverage, :overall_health, :health_label
+      )
+    end
+  end
+
+  describe '#to_h' do
+    it 'includes summary fields' do
+      hash = engine.to_h
+      expect(hash).to include(:total_cells, :active, :encounters, :health, :threat_coverage)
+    end
+  end
+end

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

@@ -0,0 +1,190 @@
+# frozen_string_literal: true
+
+RSpec.describe Legion::Extensions::Agentic::Memory::ImmuneMemory::Helpers::MemoryCell do
+  subject(:cell) { described_class.new(threat_type: :prompt_injection, signature: 'sig-001') }
+
+  describe '#initialize' do
+    it 'assigns a UUID id' do
+      expect(cell.id).to match(/\A[0-9a-f-]{36}\z/)
+    end
+
+    it 'stores threat_type' do
+      expect(cell.threat_type).to eq(:prompt_injection)
+    end
+
+    it 'stores signature' do
+      expect(cell.signature).to eq('sig-001')
+    end
+
+    it 'defaults cell_type to :b_memory' do
+      expect(cell.cell_type).to eq(:b_memory)
+    end
+
+    it 'defaults strength to VACCINATION_STRENGTH' do
+      expect(cell.strength).to eq(0.5)
+    end
+
+    it 'clamps strength' do
+      high = described_class.new(threat_type: :logic_manipulation, signature: 's', strength: 5.0)
+      expect(high.strength).to eq(1.0)
+    end
+
+    it 'validates cell_type' do
+      bad = described_class.new(threat_type: :logic_manipulation, signature: 's', cell_type: :invalid)
+      expect(bad.cell_type).to eq(:b_memory)
+    end
+
+    it 'starts with 0 encounters' do
+      expect(cell.encounter_count).to eq(0)
+    end
+  end
+
+  describe '#activate!' do
+    it 'increases strength' do
+      original = cell.strength
+      cell.activate!
+      expect(cell.strength).to be > original
+    end
+
+    it 'increments encounter_count' do
+      cell.activate!
+      expect(cell.encounter_count).to eq(1)
+    end
+
+    it 'resets decay_cycles' do
+      cell.decay!
+      cell.activate!
+      expect(cell.decay_cycles).to eq(0)
+    end
+  end
+
+  describe '#decay!' do
+    it 'decreases strength' do
+      original = cell.strength
+      cell.decay!
+      expect(cell.strength).to be < original
+    end
+
+    it 'increments decay_cycles' do
+      cell.decay!
+      expect(cell.decay_cycles).to eq(1)
+    end
+
+    it 'clamps at 0.0' do
+      200.times { cell.decay! }
+      expect(cell.strength).to eq(0.0)
+    end
+  end
+
+  describe '#recognizes?' do
+    it 'recognizes matching signature when strong enough' do
+      cell.activate!
+      cell.activate!
+      expect(cell.recognizes?('sig-001')).to be true
+    end
+
+    it 'does not recognize different signature' do
+      cell.activate!
+      cell.activate!
+      expect(cell.recognizes?('sig-999')).to be false
+    end
+
+    it 'does not recognize when strength is too low' do
+      80.times { cell.decay! }
+      expect(cell.recognizes?('sig-001')).to be false
+    end
+  end
+
+  describe '#t_cell?' do
+    it 'is true for t_helper' do
+      t = described_class.new(threat_type: :data_poisoning, signature: 's', cell_type: :t_helper)
+      expect(t.t_cell?).to be true
+    end
+
+    it 'is false for b_memory' do
+      expect(cell.t_cell?).to be false
+    end
+  end
+
+  describe '#b_cell?' do
+    it 'is true for b_memory' do
+      expect(cell.b_cell?).to be true
+    end
+
+    it 'is true for b_plasma' do
+      bp = described_class.new(threat_type: :data_poisoning, signature: 's', cell_type: :b_plasma)
+      expect(bp.b_cell?).to be true
+    end
+  end
+
+  describe '#expired?' do
+    it 'is false at default strength' do
+      expect(cell.expired?).to be false
+    end
+
+    it 'is true when fully decayed' do
+      200.times { cell.decay! }
+      expect(cell.expired?).to be true
+    end
+  end
+
+  describe '#veteran?' do
+    it 'is false initially' do
+      expect(cell.veteran?).to be false
+    end
+
+    it 'is true after 5 encounters' do
+      5.times { cell.activate! }
+      expect(cell.veteran?).to be true
+    end
+  end
+
+  describe '#naive?' do
+    it 'is true initially' do
+      expect(cell.naive?).to be true
+    end
+
+    it 'is false after activation' do
+      cell.activate!
+      expect(cell.naive?).to be false
+    end
+  end
+
+  describe '#response_speed' do
+    it 'returns primary speed when naive' do
+      expect(cell.response_speed).to eq(1.0)
+    end
+
+    it 'returns faster speed after encounters' do
+      3.times { cell.activate! }
+      expect(cell.response_speed).to be > 1.0
+    end
+
+    it 'caps at secondary response speed' do
+      10.times { cell.activate! }
+      expect(cell.response_speed).to eq(3.0)
+    end
+  end
+
+  describe '#maturity' do
+    it 'is 0.0 when naive' do
+      expect(cell.maturity).to eq(0.0)
+    end
+
+    it 'increases with encounters' do
+      5.times { cell.activate! }
+      expect(cell.maturity).to eq(0.5)
+    end
+  end
+
+  describe '#to_h' do
+    it 'includes all fields' do
+      hash = cell.to_h
+      expect(hash).to include(
+        :id, :threat_type, :signature, :cell_type, :strength,
+        :encounter_count, :decay_cycles, :response_speed,
+        :immunity_label, :maturity_label, :t_cell, :b_cell, :expired, :created_at
+      )
+    end
+  end
+end

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

@@ -0,0 +1,83 @@
+# frozen_string_literal: true
+
+RSpec.describe Legion::Extensions::Agentic::Memory::ImmuneMemory::Runners::CognitiveImmuneMemory do
+  let(:engine) { Legion::Extensions::Agentic::Memory::ImmuneMemory::Helpers::ImmuneMemoryEngine.new }
+  let(:runner) do
+    obj = Object.new
+    obj.extend(described_class)
+    obj.instance_variable_set(:@default_engine, engine)
+    obj
+  end
+
+  describe '#create_memory_cell' do
+    it 'returns success with cell hash' do
+      result = runner.create_memory_cell(threat_type: :prompt_injection, signature: 'sig-001', engine: engine)
+      expect(result[:success]).to be true
+      expect(result[:cell][:threat_type]).to eq(:prompt_injection)
+    end
+  end
+
+  describe '#vaccinate' do
+    it 'returns success' do
+      result = runner.vaccinate(threat_type: :data_poisoning, signature: 'vax-001', engine: engine)
+      expect(result[:success]).to be true
+    end
+  end
+
+  describe '#encounter_threat' do
+    it 'returns success with encounter hash' do
+      result = runner.encounter_threat(threat_type: :prompt_injection, threat_signature: 'new', engine: engine)
+      expect(result[:success]).to be true
+      expect(result[:encounter][:response_type]).to eq(:primary)
+    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 '#immunity_for' do
+    it 'returns immunity level' do
+      engine.create_memory_cell(threat_type: :prompt_injection, signature: 's1', strength: 0.8)
+      result = runner.immunity_for(threat_type: :prompt_injection, engine: engine)
+      expect(result[:success]).to be true
+      expect(result[:immunity]).to eq(0.8)
+    end
+  end
+
+  describe '#active_cells' do
+    it 'returns cell list' do
+      engine.create_memory_cell(threat_type: :prompt_injection, signature: 's1')
+      result = runner.active_cells(engine: engine)
+      expect(result[:success]).to be true
+      expect(result[:count]).to eq(1)
+    end
+  end
+
+  describe '#veteran_cells' do
+    it 'returns veteran list' do
+      result = runner.veteran_cells(engine: engine)
+      expect(result[:success]).to be true
+      expect(result[:count]).to eq(0)
+    end
+  end
+
+  describe '#threat_coverage' do
+    it 'returns coverage' do
+      result = runner.threat_coverage(engine: engine)
+      expect(result[:success]).to be true
+      expect(result[:coverage]).to eq(0.0)
+    end
+  end
+
+  describe '#immune_status' do
+    it 'returns comprehensive status' do
+      result = runner.immune_status(engine: engine)
+      expect(result[:success]).to be true
+      expect(result).to include(:total_cells, :overall_health)
+    end
+  end
+end

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

@@ -0,0 +1,71 @@
+# frozen_string_literal: true
+
+RSpec.describe Legion::Extensions::Agentic::Memory::Nostalgia::Client do
+  subject(:client) { described_class.new }
+
+  describe '#initialize' do
+    it 'creates a client with a nostalgia engine' do
+      expect(client).to respond_to(:store_memory)
+    end
+
+    it 'accepts an injected engine' do
+      engine = Legion::Extensions::Agentic::Memory::Nostalgia::Helpers::NostalgiaEngine.new
+      c = described_class.new(engine: engine)
+      c.store_memory(content: 'shared memory')
+      expect(engine.memories.size).to eq(1)
+    end
+  end
+
+  describe 'runner methods' do
+    it 'responds to recall runner methods' do
+      expect(client).to respond_to(:store_memory)
+      expect(client).to respond_to(:trigger_nostalgia)
+      expect(client).to respond_to(:age_memories)
+      expect(client).to respond_to(:nostalgia_report)
+    end
+
+    it 'responds to analysis runner methods' do
+      expect(client).to respond_to(:warmth_by_domain)
+      expect(client).to respond_to(:rosy_retrospection_index)
+      expect(client).to respond_to(:nostalgia_proneness)
+      expect(client).to respond_to(:most_nostalgic_domains)
+      expect(client).to respond_to(:bittersweet_memories)
+    end
+  end
+
+  describe 'full cycle integration' do
+    it 'stores memories, triggers nostalgia, and produces a report' do
+      client.store_memory(content: 'first day of school', domain: :achievement, original_valence: 0.5)
+      client.store_memory(content: 'childhood friend', domain: :relationship, original_valence: 0.6)
+      client.store_memory(content: 'old neighborhood', domain: :place, original_valence: 0.3)
+
+      client.age_memories
+      result = client.trigger_nostalgia(trigger: 'childhood')
+      expect(result[:success]).to be true
+
+      report = client.nostalgia_report
+      expect(report[:total_memories]).to eq(3)
+      expect(report[:retrospection_label]).to be_a(Symbol)
+      expect(report[:nostalgia_label]).to be_a(Symbol)
+    end
+
+    it 'identifies rosy and bittersweet memories correctly' do
+      client.store_memory(content: 'rough but cherished time', domain: :challenge,
+                          warmth: 0.75, original_valence: 0.2)
+
+      bs = client.bittersweet_memories
+      expect(bs[:memories].first[:content]).to eq('rough but cherished time')
+
+      ri = client.rosy_retrospection_index
+      expect(ri[:index]).to be > 0.0
+    end
+
+    it 'warmth grows over age cycles' do
+      client.store_memory(content: 'fading memory', domain: :routine, warmth: 0.3)
+      initial_report = client.nostalgia_report
+      5.times { client.age_memories }
+      later_report = client.nostalgia_report
+      expect(later_report[:nostalgia_proneness]).to be >= initial_report[:nostalgia_proneness]
+    end
+  end
+end

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

@@ -0,0 +1,65 @@
+# frozen_string_literal: true
+
+RSpec.describe Legion::Extensions::Agentic::Memory::Nostalgia::Helpers::Constants do
+  describe 'constants' do
+    it 'defines MAX_MEMORIES' do
+      expect(described_class::MAX_MEMORIES).to eq(300)
+    end
+
+    it 'defines MAX_EVENTS' do
+      expect(described_class::MAX_EVENTS).to eq(500)
+    end
+
+    it 'defines DEFAULT_WARMTH' do
+      expect(described_class::DEFAULT_WARMTH).to eq(0.3)
+    end
+
+    it 'defines WARMTH_GROWTH' do
+      expect(described_class::WARMTH_GROWTH).to eq(0.02)
+    end
+
+    it 'defines WARMTH_CEILING' do
+      expect(described_class::WARMTH_CEILING).to eq(0.95)
+    end
+
+    it 'defines WARMTH_DECAY' do
+      expect(described_class::WARMTH_DECAY).to eq(0.01)
+    end
+
+    it 'defines TRIGGER_SENSITIVITY' do
+      expect(described_class::TRIGGER_SENSITIVITY).to eq(0.3)
+    end
+
+    it 'defines 8 MEMORY_DOMAINS' do
+      expect(described_class::MEMORY_DOMAINS.size).to eq(8)
+      expect(described_class::MEMORY_DOMAINS).to include(:relationship, :place, :achievement, :unknown)
+    end
+  end
+
+  describe '.label_for' do
+    it 'returns warmth label for low value' do
+      expect(described_class.label_for(described_class::WARMTH_LABELS, 0.1)).to eq(:faint)
+    end
+
+    it 'returns warmth label for mid value' do
+      expect(described_class.label_for(described_class::WARMTH_LABELS, 0.5)).to eq(:warm)
+    end
+
+    it 'returns warmth label for high value' do
+      expect(described_class.label_for(described_class::WARMTH_LABELS, 0.9)).to eq(:glowing)
+    end
+
+    it 'returns nostalgia label' do
+      expect(described_class.label_for(described_class::NOSTALGIA_LABELS, 0.7)).to eq(:vivid)
+    end
+
+    it 'returns retrospection label' do
+      expect(described_class.label_for(described_class::RETROSPECTION_LABELS, 0.0)).to eq(:accurate)
+    end
+
+    it 'clamps values outside [0, 1]' do
+      expect(described_class.label_for(described_class::WARMTH_LABELS, 1.5)).to eq(:glowing)
+      expect(described_class.label_for(described_class::WARMTH_LABELS, -0.5)).to eq(:faint)
+    end
+  end
+end