lex-agentic-defense 0.1.0

data/spec/legion/extensions/agentic/defense/immunology/helpers/constants_spec.rb

@@ -0,0 +1,86 @@
+# frozen_string_literal: true
+
+RSpec.describe Legion::Extensions::Agentic::Defense::Immunology::Helpers::Constants do
+  describe 'DEFAULT_RESISTANCE' do
+    it 'is 0.5' do
+      expect(described_class::DEFAULT_RESISTANCE).to eq(0.5)
+    end
+  end
+
+  describe 'RESISTANCE_BOOST' do
+    it 'is 0.1' do
+      expect(described_class::RESISTANCE_BOOST).to eq(0.1)
+    end
+  end
+
+  describe 'RESISTANCE_DECAY' do
+    it 'is 0.02' do
+      expect(described_class::RESISTANCE_DECAY).to eq(0.02)
+    end
+  end
+
+  describe 'MAX_THREATS' do
+    it 'is 500' do
+      expect(described_class::MAX_THREATS).to eq(500)
+    end
+  end
+
+  describe 'MAX_ANTIBODIES' do
+    it 'is 200' do
+      expect(described_class::MAX_ANTIBODIES).to eq(200)
+    end
+  end
+
+  describe 'THREAT_LABELS' do
+    it 'labels 0.9 as critical' do
+      label = described_class::THREAT_LABELS.find { |r, _| r.cover?(0.9) }&.last
+      expect(label).to eq(:critical)
+    end
+
+    it 'labels 0.7 as severe' do
+      label = described_class::THREAT_LABELS.find { |r, _| r.cover?(0.7) }&.last
+      expect(label).to eq(:severe)
+    end
+
+    it 'labels 0.5 as moderate' do
+      label = described_class::THREAT_LABELS.find { |r, _| r.cover?(0.5) }&.last
+      expect(label).to eq(:moderate)
+    end
+
+    it 'labels 0.3 as low' do
+      label = described_class::THREAT_LABELS.find { |r, _| r.cover?(0.3) }&.last
+      expect(label).to eq(:low)
+    end
+
+    it 'labels 0.1 as negligible' do
+      label = described_class::THREAT_LABELS.find { |r, _| r.cover?(0.1) }&.last
+      expect(label).to eq(:negligible)
+    end
+  end
+
+  describe 'IMMUNITY_LABELS' do
+    it 'labels 0.9 as immune' do
+      label = described_class::IMMUNITY_LABELS.find { |r, _| r.cover?(0.9) }&.last
+      expect(label).to eq(:immune)
+    end
+
+    it 'labels 0.1 as compromised' do
+      label = described_class::IMMUNITY_LABELS.find { |r, _| r.cover?(0.1) }&.last
+      expect(label).to eq(:compromised)
+    end
+  end
+
+  describe 'MANIPULATION_TACTICS' do
+    it 'has 10 tactics' do
+      expect(described_class::MANIPULATION_TACTICS.size).to eq(10)
+    end
+
+    it 'includes authority_appeal' do
+      expect(described_class::MANIPULATION_TACTICS).to include(:authority_appeal)
+    end
+
+    it 'includes gaslighting' do
+      expect(described_class::MANIPULATION_TACTICS).to include(:gaslighting)
+    end
+  end
+end

data/spec/legion/extensions/agentic/defense/immunology/helpers/immune_engine_spec.rb

@@ -0,0 +1,275 @@
+# frozen_string_literal: true
+
+RSpec.describe Legion::Extensions::Agentic::Defense::Immunology::Helpers::ImmuneEngine do
+  subject(:engine) { described_class.new }
+
+  describe '#initialize' do
+    it 'starts with DEFAULT_RESISTANCE' do
+      expect(engine.resistance).to eq(Legion::Extensions::Agentic::Defense::Immunology::Helpers::Constants::DEFAULT_RESISTANCE)
+    end
+
+    it 'starts with inflammatory false' do
+      expect(engine.inflammatory).to be false
+    end
+  end
+
+  describe '#detect_threat' do
+    it 'returns a Threat object' do
+      threat = engine.detect_threat(source: 'user', tactic: :gaslighting, content_hash: 'h1')
+      expect(threat).to be_a(Legion::Extensions::Agentic::Defense::Immunology::Helpers::Threat)
+    end
+
+    it 'stores the threat' do
+      threat = engine.detect_threat(source: 'user', tactic: :strawman, content_hash: 'h2')
+      expect(engine.to_h[:threat_count]).to eq(1)
+      expect(threat.id).not_to be_nil
+    end
+
+    it 'applies antibody resistance to threat_level' do
+      engine.create_antibody(tactic: :authority_appeal, pattern: 'expert claim', strength: 0.8)
+      threat = engine.detect_threat(source: 'src', tactic: :authority_appeal, content_hash: 'h3', threat_level: 0.8)
+      expect(threat.threat_level).to be < 0.8
+    end
+
+    it 'tracks multiple threats' do
+      engine.detect_threat(source: 's1', tactic: :gaslighting, content_hash: 'a')
+      engine.detect_threat(source: 's2', tactic: :strawman, content_hash: 'b')
+      expect(engine.to_h[:threat_count]).to eq(2)
+    end
+  end
+
+  describe '#quarantine_threat' do
+    let(:threat) { engine.detect_threat(source: 'src', tactic: :gaslighting, content_hash: 'h1') }
+
+    it 'quarantines an existing threat' do
+      result = engine.quarantine_threat(threat_id: threat.id)
+      expect(result[:success]).to be true
+      expect(threat.quarantined).to be true
+    end
+
+    it 'returns failure for unknown threat_id' do
+      result = engine.quarantine_threat(threat_id: 'nonexistent')
+      expect(result[:success]).to be false
+    end
+
+    it 'increments quarantined_count' do
+      engine.quarantine_threat(threat_id: threat.id)
+      expect(engine.to_h[:quarantined_count]).to eq(1)
+    end
+  end
+
+  describe '#release_threat' do
+    let(:threat) { engine.detect_threat(source: 'src', tactic: :gaslighting, content_hash: 'h1') }
+
+    it 'releases a quarantined threat' do
+      engine.quarantine_threat(threat_id: threat.id)
+      result = engine.release_threat(threat_id: threat.id)
+      expect(result[:success]).to be true
+      expect(threat.quarantined).to be false
+    end
+
+    it 'returns failure for unknown threat_id' do
+      result = engine.release_threat(threat_id: 'nonexistent')
+      expect(result[:success]).to be false
+    end
+  end
+
+  describe '#inoculate' do
+    let(:threat) { engine.detect_threat(source: 'src', tactic: :gaslighting, content_hash: 'h1') }
+
+    it 'returns success for existing threat' do
+      result = engine.inoculate(threat_id: threat.id)
+      expect(result[:success]).to be true
+    end
+
+    it 'increments exposure_count on the threat' do
+      engine.inoculate(threat_id: threat.id)
+      expect(threat.exposure_count).to eq(1)
+    end
+
+    it 'boosts overall resistance' do
+      original = engine.resistance
+      engine.inoculate(threat_id: threat.id)
+      expect(engine.resistance).to be > original
+    end
+
+    it 'returns failure for unknown threat_id' do
+      result = engine.inoculate(threat_id: 'nonexistent')
+      expect(result[:success]).to be false
+    end
+  end
+
+  describe '#create_antibody' do
+    it 'returns an Antibody object' do
+      ab = engine.create_antibody(tactic: :gaslighting, pattern: 'reality questioning')
+      expect(ab).to be_a(Legion::Extensions::Agentic::Defense::Immunology::Helpers::Antibody)
+    end
+
+    it 'stores the antibody' do
+      engine.create_antibody(tactic: :strawman, pattern: 'misrepresentation')
+      expect(engine.to_h[:antibody_count]).to eq(1)
+    end
+
+    it 'accepts custom strength' do
+      ab = engine.create_antibody(tactic: :gaslighting, pattern: 'test', strength: 0.8)
+      expect(ab.strength).to eq(0.8)
+    end
+  end
+
+  describe '#scan_for_tactic' do
+    before do
+      engine.detect_threat(source: 's1', tactic: :gaslighting, content_hash: 'h1')
+      engine.detect_threat(source: 's2', tactic: :gaslighting, content_hash: 'h2')
+      engine.detect_threat(source: 's3', tactic: :strawman, content_hash: 'h3')
+    end
+
+    it 'returns threats matching the tactic' do
+      threats = engine.scan_for_tactic(tactic: :gaslighting)
+      expect(threats.size).to eq(2)
+      expect(threats.all? { |t| t.tactic == :gaslighting }).to be true
+    end
+
+    it 'returns empty array for unknown tactic' do
+      threats = engine.scan_for_tactic(tactic: :bandwagon)
+      expect(threats).to be_empty
+    end
+  end
+
+  describe '#trigger_inflammatory_response' do
+    it 'sets inflammatory to true' do
+      engine.trigger_inflammatory_response
+      expect(engine.inflammatory).to be true
+    end
+
+    it 'returns inflammatory: true' do
+      result = engine.trigger_inflammatory_response
+      expect(result[:inflammatory]).to be true
+    end
+  end
+
+  describe '#resolve_inflammation' do
+    before { engine.trigger_inflammatory_response }
+
+    it 'sets inflammatory to false' do
+      engine.resolve_inflammation
+      expect(engine.inflammatory).to be false
+    end
+
+    it 'returns inflammatory: false' do
+      result = engine.resolve_inflammation
+      expect(result[:inflammatory]).to be false
+    end
+  end
+
+  describe '#overall_immunity' do
+    it 'returns a float between 0.0 and 1.0' do
+      score = engine.overall_immunity
+      expect(score).to be_between(0.0, 1.0)
+    end
+
+    it 'increases with more effective antibodies' do
+      base = engine.overall_immunity
+      engine.create_antibody(tactic: :gaslighting, pattern: 'test', strength: 0.9)
+      engine.create_antibody(tactic: :strawman, pattern: 'test2', strength: 0.9)
+      expect(engine.overall_immunity).to be > base
+    end
+  end
+
+  describe '#immunity_label' do
+    it 'returns a symbol' do
+      expect(engine.immunity_label).to be_a(Symbol)
+    end
+
+    it 'returns :normal at default resistance with no antibodies' do
+      label = engine.immunity_label
+      expect(%i[normal vulnerable]).to include(label)
+    end
+  end
+
+  describe '#vulnerability_report' do
+    it 'returns covered, uncovered, and coverage' do
+      report = engine.vulnerability_report
+      expect(report).to include(:covered, :uncovered, :coverage)
+    end
+
+    it 'starts fully uncovered' do
+      report = engine.vulnerability_report
+      expect(report[:uncovered].size).to eq(Legion::Extensions::Agentic::Defense::Immunology::Helpers::Constants::MANIPULATION_TACTICS.size)
+    end
+
+    it 'reduces uncovered after creating an antibody' do
+      engine.create_antibody(tactic: :gaslighting, pattern: 'test')
+      report = engine.vulnerability_report
+      expect(report[:uncovered]).not_to include(:gaslighting)
+    end
+  end
+
+  describe '#threat_history' do
+    before do
+      5.times { |i| engine.detect_threat(source: "s#{i}", tactic: :gaslighting, content_hash: "h#{i}") }
+    end
+
+    it 'returns up to limit threats' do
+      history = engine.threat_history(limit: 3)
+      expect(history.size).to eq(3)
+    end
+
+    it 'returns hashes' do
+      history = engine.threat_history
+      expect(history.first).to be_a(Hash)
+    end
+
+    it 'defaults to limit 10' do
+      history = engine.threat_history
+      expect(history.size).to be <= 10
+    end
+  end
+
+  describe '#decay_all' do
+    it 'decays antibodies' do
+      ab = engine.create_antibody(tactic: :gaslighting, pattern: 'test', strength: 0.5)
+      original_strength = ab.strength
+      engine.decay_all
+      expect(ab.strength).to be < original_strength
+    end
+
+    it 'decays overall resistance' do
+      original = engine.resistance
+      engine.decay_all
+      expect(engine.resistance).to be < original
+    end
+
+    it 'returns resistance and antibodies_decayed' do
+      engine.create_antibody(tactic: :gaslighting, pattern: 'test')
+      result = engine.decay_all
+      expect(result).to include(:resistance, :antibodies_decayed)
+    end
+  end
+
+  describe '#prune_ineffective' do
+    it 'removes antibodies below effective threshold' do
+      engine.create_antibody(tactic: :gaslighting, pattern: 'strong', strength: 0.8)
+      engine.create_antibody(tactic: :strawman, pattern: 'weak', strength: 0.1)
+      result = engine.prune_ineffective
+      expect(result[:pruned]).to eq(1)
+      expect(result[:remaining]).to eq(1)
+    end
+
+    it 'returns 0 pruned when all are effective' do
+      engine.create_antibody(tactic: :gaslighting, pattern: 'strong', strength: 0.8)
+      result = engine.prune_ineffective
+      expect(result[:pruned]).to eq(0)
+    end
+  end
+
+  describe '#to_h' do
+    it 'returns engine stats as hash' do
+      h = engine.to_h
+      expect(h).to include(
+        :threat_count, :quarantined_count, :antibody_count,
+        :effective_antibody_count, :resistance, :inflammatory,
+        :overall_immunity, :immunity_label
+      )
+    end
+  end
+end

data/spec/legion/extensions/agentic/defense/immunology/helpers/threat_spec.rb

@@ -0,0 +1,133 @@
+# frozen_string_literal: true
+
+RSpec.describe Legion::Extensions::Agentic::Defense::Immunology::Helpers::Threat do
+  subject(:threat) { described_class.new(source: 'test', tactic: :gaslighting, content_hash: 'abc123') }
+
+  describe '#initialize' do
+    it 'assigns a uuid id' do
+      expect(threat.id).to match(/\A[0-9a-f-]{36}\z/)
+    end
+
+    it 'stores source' do
+      expect(threat.source).to eq('test')
+    end
+
+    it 'stores tactic' do
+      expect(threat.tactic).to eq(:gaslighting)
+    end
+
+    it 'stores content_hash' do
+      expect(threat.content_hash).to eq('abc123')
+    end
+
+    it 'defaults threat_level to 0.5' do
+      expect(threat.threat_level).to eq(0.5)
+    end
+
+    it 'defaults quarantined to false' do
+      expect(threat.quarantined).to be false
+    end
+
+    it 'defaults exposure_count to 0' do
+      expect(threat.exposure_count).to eq(0)
+    end
+
+    it 'clamps threat_level above 1.0' do
+      t = described_class.new(source: 's', tactic: :strawman, content_hash: 'x', threat_level: 1.5)
+      expect(t.threat_level).to eq(1.0)
+    end
+
+    it 'clamps threat_level below 0.0' do
+      t = described_class.new(source: 's', tactic: :strawman, content_hash: 'x', threat_level: -0.5)
+      expect(t.threat_level).to eq(0.0)
+    end
+  end
+
+  describe '#threat_label' do
+    it 'returns :critical for 0.9' do
+      t = described_class.new(source: 's', tactic: :gaslighting, content_hash: 'x', threat_level: 0.9)
+      expect(t.threat_label).to eq(:critical)
+    end
+
+    it 'returns :moderate for 0.5' do
+      expect(threat.threat_label).to eq(:moderate)
+    end
+
+    it 'returns :negligible for 0.1' do
+      t = described_class.new(source: 's', tactic: :gaslighting, content_hash: 'x', threat_level: 0.1)
+      expect(t.threat_label).to eq(:negligible)
+    end
+  end
+
+  describe '#quarantine!' do
+    it 'sets quarantined to true' do
+      threat.quarantine!
+      expect(threat.quarantined).to be true
+    end
+  end
+
+  describe '#release!' do
+    it 'sets quarantined back to false' do
+      threat.quarantine!
+      threat.release!
+      expect(threat.quarantined).to be false
+    end
+  end
+
+  describe '#expose!' do
+    it 'increments exposure_count' do
+      threat.expose!
+      expect(threat.exposure_count).to eq(1)
+    end
+
+    it 'reduces threat_level (inoculation effect)' do
+      original = threat.threat_level
+      threat.expose!
+      expect(threat.threat_level).to be < original
+    end
+
+    it 'does not drop threat_level below 0.0' do
+      t = described_class.new(source: 's', tactic: :gaslighting, content_hash: 'x', threat_level: 0.0)
+      t.expose!
+      expect(t.threat_level).to eq(0.0)
+    end
+
+    it 'diminishing reduction on repeated exposure' do
+      first_level = threat.threat_level
+      threat.expose!
+      reduction1 = first_level - threat.threat_level
+
+      second_level = threat.threat_level
+      threat.expose!
+      reduction2 = second_level - threat.threat_level
+
+      expect(reduction2).to be <= reduction1
+    end
+  end
+
+  describe '#escalate!' do
+    it 'increases threat_level by default 0.1' do
+      original = threat.threat_level
+      threat.escalate!
+      expect(threat.threat_level).to be_within(0.001).of(original + 0.1)
+    end
+
+    it 'respects custom amount' do
+      threat.escalate!(amount: 0.2)
+      expect(threat.threat_level).to be_within(0.001).of(0.7)
+    end
+
+    it 'does not exceed 1.0' do
+      t = described_class.new(source: 's', tactic: :gaslighting, content_hash: 'x', threat_level: 0.95)
+      t.escalate!(amount: 0.5)
+      expect(t.threat_level).to eq(1.0)
+    end
+  end
+
+  describe '#to_h' do
+    it 'returns a hash with all fields' do
+      h = threat.to_h
+      expect(h).to include(:id, :source, :tactic, :content_hash, :threat_level, :threat_label, :quarantined, :exposure_count, :created_at)
+    end
+  end
+end

data/spec/legion/extensions/agentic/defense/immunology/runners/cognitive_immunology_spec.rb

@@ -0,0 +1,177 @@
+# frozen_string_literal: true
+
+RSpec.describe Legion::Extensions::Agentic::Defense::Immunology::Runners::CognitiveImmunology do
+  let(:client) { Legion::Extensions::Agentic::Defense::Immunology::Client.new }
+
+  describe '#detect_threat' do
+    it 'returns success true with threat data' do
+      result = client.detect_threat(source: 'test', tactic: :gaslighting, content_hash: 'h1')
+      expect(result[:success]).to be true
+      expect(result[:threat]).to include(:id, :tactic, :threat_level)
+    end
+
+    it 'uses custom threat_level' do
+      result = client.detect_threat(source: 'src', tactic: :strawman, content_hash: 'h2', threat_level: 0.9)
+      expect(result[:threat][:threat_level]).to be_within(0.01).of(0.9)
+    end
+  end
+
+  describe '#quarantine_threat' do
+    let(:threat_id) do
+      client.detect_threat(source: 'src', tactic: :gaslighting, content_hash: 'h1')[:threat][:id]
+    end
+
+    it 'quarantines an existing threat' do
+      result = client.quarantine_threat(threat_id: threat_id)
+      expect(result[:success]).to be true
+    end
+
+    it 'fails for unknown id' do
+      result = client.quarantine_threat(threat_id: 'unknown')
+      expect(result[:success]).to be false
+    end
+  end
+
+  describe '#release_threat' do
+    let(:threat_id) do
+      id = client.detect_threat(source: 'src', tactic: :gaslighting, content_hash: 'h1')[:threat][:id]
+      client.quarantine_threat(threat_id: id)
+      id
+    end
+
+    it 'releases a quarantined threat' do
+      result = client.release_threat(threat_id: threat_id)
+      expect(result[:success]).to be true
+    end
+  end
+
+  describe '#inoculate' do
+    let(:threat_id) do
+      client.detect_threat(source: 'src', tactic: :gaslighting, content_hash: 'h1')[:threat][:id]
+    end
+
+    it 'returns success and exposure_count' do
+      result = client.inoculate(threat_id: threat_id)
+      expect(result[:success]).to be true
+      expect(result[:exposure_count]).to eq(1)
+    end
+
+    it 'boosts resistance' do
+      before_status = client.immune_status
+      client.inoculate(threat_id: threat_id)
+      after_status = client.immune_status
+      expect(after_status[:resistance]).to be >= before_status[:resistance]
+    end
+
+    it 'fails for unknown threat' do
+      result = client.inoculate(threat_id: 'nope')
+      expect(result[:success]).to be false
+    end
+  end
+
+  describe '#create_antibody' do
+    it 'returns success with antibody data' do
+      result = client.create_antibody(tactic: :authority_appeal, pattern: 'expert claim')
+      expect(result[:success]).to be true
+      expect(result[:antibody]).to include(:id, :tactic, :strength)
+    end
+
+    it 'accepts custom strength' do
+      result = client.create_antibody(tactic: :gaslighting, pattern: 'test', strength: 0.7)
+      expect(result[:antibody][:strength]).to eq(0.7)
+    end
+  end
+
+  describe '#scan_for_tactic' do
+    before do
+      client.detect_threat(source: 's1', tactic: :strawman, content_hash: 'h1')
+      client.detect_threat(source: 's2', tactic: :strawman, content_hash: 'h2')
+    end
+
+    it 'returns threats for matching tactic' do
+      result = client.scan_for_tactic(tactic: :strawman)
+      expect(result[:success]).to be true
+      expect(result[:count]).to eq(2)
+    end
+
+    it 'returns empty for unmatched tactic' do
+      result = client.scan_for_tactic(tactic: :bandwagon)
+      expect(result[:count]).to eq(0)
+    end
+  end
+
+  describe '#trigger_inflammatory_response' do
+    it 'activates inflammatory mode' do
+      result = client.trigger_inflammatory_response
+      expect(result[:success]).to be true
+      expect(result[:inflammatory]).to be true
+    end
+  end
+
+  describe '#resolve_inflammation' do
+    before { client.trigger_inflammatory_response }
+
+    it 'deactivates inflammatory mode' do
+      result = client.resolve_inflammation
+      expect(result[:success]).to be true
+      expect(result[:inflammatory]).to be false
+    end
+  end
+
+  describe '#overall_immunity' do
+    it 'returns score and label' do
+      result = client.overall_immunity
+      expect(result[:success]).to be true
+      expect(result[:score]).to be_between(0.0, 1.0)
+      expect(result[:label]).to be_a(Symbol)
+    end
+  end
+
+  describe '#vulnerability_report' do
+    it 'returns coverage info' do
+      result = client.vulnerability_report
+      expect(result[:success]).to be true
+      expect(result).to include(:covered, :uncovered, :coverage)
+    end
+  end
+
+  describe '#threat_history' do
+    before { 3.times { |i| client.detect_threat(source: "s#{i}", tactic: :gaslighting, content_hash: "h#{i}") } }
+
+    it 'returns threats list' do
+      result = client.threat_history
+      expect(result[:success]).to be true
+      expect(result[:count]).to eq(3)
+    end
+
+    it 'respects limit' do
+      result = client.threat_history(limit: 2)
+      expect(result[:count]).to eq(2)
+    end
+  end
+
+  describe '#decay_all' do
+    it 'returns success with resistance' do
+      result = client.decay_all
+      expect(result[:success]).to be true
+      expect(result).to include(:resistance)
+    end
+  end
+
+  describe '#prune_ineffective' do
+    it 'returns pruned and remaining counts' do
+      client.create_antibody(tactic: :gaslighting, pattern: 'weak', strength: 0.1)
+      result = client.prune_ineffective
+      expect(result[:success]).to be true
+      expect(result[:pruned]).to eq(1)
+    end
+  end
+
+  describe '#immune_status' do
+    it 'returns full engine stats' do
+      result = client.immune_status
+      expect(result[:success]).to be true
+      expect(result).to include(:threat_count, :antibody_count, :resistance, :inflammatory)
+    end
+  end
+end