lex-agentic-defense 0.1.0

data/lib/legion/extensions/agentic/defense/immune_response/client.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module Agentic
+      module Defense
+        module ImmuneResponse
+          class Client
+            include Runners::CognitiveImmuneResponse
+
+            def initialize(engine: nil)
+              @default_engine = engine || Helpers::ImmuneEngine.new
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/legion/extensions/agentic/defense/immune_response/helpers/antibody.rb

@@ -0,0 +1,72 @@
+# frozen_string_literal: true
+
+require 'securerandom'
+
+module Legion
+  module Extensions
+    module Agentic
+      module Defense
+        module ImmuneResponse
+          module Helpers
+            class Antibody
+              include Constants
+
+              attr_reader :id, :antigen_type, :signature, :immunity_level,
+                          :match_count, :created_at
+
+              def initialize(antigen_type:, signature:, immunity_level: 0.3)
+                @id             = SecureRandom.uuid
+                @antigen_type   = antigen_type.to_sym
+                @signature      = signature
+                @immunity_level = immunity_level.to_f.clamp(0.0, 1.0).round(10)
+                @match_count    = 0
+                @created_at     = Time.now.utc
+              end
+
+              def strengthen!(amount = IMMUNITY_BOOST)
+                @match_count += 1
+                @immunity_level = (@immunity_level + amount).clamp(0.0, 1.0).round(10)
+                self
+              end
+
+              def decay!
+                @immunity_level = (@immunity_level - IMMUNITY_DECAY).clamp(0.0, 1.0).round(10)
+                self
+              end
+
+              def matches?(antigen)
+                antigen.antigen_type == @antigen_type
+              end
+
+              def memory_cell?
+                @immunity_level >= MEMORY_CELL_THRESHOLD
+              end
+
+              def effective?
+                @immunity_level >= 0.5
+              end
+
+              def immunity_label
+                Constants.label_for(IMMUNITY_LABELS, @immunity_level)
+              end
+
+              def to_h
+                {
+                  id:             @id,
+                  antigen_type:   @antigen_type,
+                  signature:      @signature,
+                  immunity_level: @immunity_level,
+                  immunity_label: immunity_label,
+                  match_count:    @match_count,
+                  memory_cell:    memory_cell?,
+                  effective:      effective?,
+                  created_at:     @created_at
+                }
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/legion/extensions/agentic/defense/immune_response/helpers/antigen.rb

@@ -0,0 +1,87 @@
+# frozen_string_literal: true
+
+require 'securerandom'
+
+module Legion
+  module Extensions
+    module Agentic
+      module Defense
+        module ImmuneResponse
+          module Helpers
+            class Antigen
+              include Constants
+
+              attr_reader :id, :pattern, :antigen_type, :threat_level,
+                          :exposure_count, :first_seen, :last_seen
+
+              def initialize(pattern:, antigen_type:, threat_level: DEFAULT_THREAT_LEVEL)
+                @id             = SecureRandom.uuid
+                @pattern        = pattern
+                @antigen_type   = validate_type(antigen_type)
+                @threat_level   = threat_level.to_f.clamp(0.0, 1.0).round(10)
+                @exposure_count = 0
+                @first_seen     = Time.now.utc
+                @last_seen      = @first_seen
+              end
+
+              def expose!
+                @exposure_count += 1
+                @last_seen = Time.now.utc
+                self
+              end
+
+              def escalate!(amount = THREAT_ESCALATION)
+                @threat_level = (@threat_level + amount).clamp(0.0, 1.0).round(10)
+                self
+              end
+
+              def de_escalate!(amount = THREAT_ESCALATION)
+                @threat_level = (@threat_level - amount).clamp(0.0, 1.0).round(10)
+                self
+              end
+
+              def critical?
+                @threat_level >= REJECTION_THRESHOLD
+              end
+
+              def benign?
+                @threat_level <= TOLERANCE_THRESHOLD
+              end
+
+              def recurring?
+                @exposure_count >= 3
+              end
+
+              def threat_label
+                Constants.label_for(THREAT_LABELS, @threat_level)
+              end
+
+              def to_h
+                {
+                  id:             @id,
+                  pattern:        @pattern,
+                  antigen_type:   @antigen_type,
+                  threat_level:   @threat_level,
+                  threat_label:   threat_label,
+                  exposure_count: @exposure_count,
+                  critical:       critical?,
+                  benign:         benign?,
+                  recurring:      recurring?,
+                  first_seen:     @first_seen,
+                  last_seen:      @last_seen
+                }
+              end
+
+              private
+
+              def validate_type(type)
+                sym = type.to_sym
+                ANTIGEN_TYPES.include?(sym) ? sym : :adversarial_input
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/legion/extensions/agentic/defense/immune_response/helpers/constants.rb

@@ -0,0 +1,75 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module Agentic
+      module Defense
+        module ImmuneResponse
+          module Helpers
+            module Constants
+              MAX_ANTIGENS     = 300
+              MAX_ANTIBODIES   = 200
+              MAX_EXPOSURES    = 500
+              MAX_RESPONSES    = 500
+
+              DEFAULT_THREAT_LEVEL   = 0.5
+              IMMUNITY_BOOST         = 0.15
+              IMMUNITY_DECAY         = 0.02
+              THREAT_ESCALATION      = 0.1
+              TOLERANCE_THRESHOLD    = 0.3
+              REJECTION_THRESHOLD    = 0.8
+              MEMORY_CELL_THRESHOLD  = 0.6
+
+              ANTIGEN_TYPES = %i[
+                prompt_injection social_engineering data_poisoning
+                adversarial_input logic_manipulation context_hijack
+                authority_spoofing emotional_manipulation
+              ].freeze
+
+              RESPONSE_LEVELS = %i[
+                tolerance monitoring mild_response strong_response full_rejection
+              ].freeze
+
+              THREAT_LABELS = {
+                (0.8..)     => :critical,
+                (0.6...0.8) => :high,
+                (0.4...0.6) => :moderate,
+                (0.2...0.4) => :low,
+                (..0.2)     => :minimal
+              }.freeze
+
+              IMMUNITY_LABELS = {
+                (0.8..)     => :immune,
+                (0.6...0.8) => :resistant,
+                (0.4...0.6) => :partial,
+                (0.2...0.4) => :naive,
+                (..0.2)     => :vulnerable
+              }.freeze
+
+              RESPONSE_LABELS = {
+                (0.8..)     => :full_rejection,
+                (0.6...0.8) => :strong_response,
+                (0.4...0.6) => :mild_response,
+                (0.2...0.4) => :monitoring,
+                (..0.2)     => :tolerance
+              }.freeze
+
+              HEALTH_LABELS = {
+                (0.8..)     => :robust,
+                (0.6...0.8) => :healthy,
+                (0.4...0.6) => :compromised,
+                (0.2...0.4) => :weakened,
+                (..0.2)     => :critical
+              }.freeze
+
+              def self.label_for(labels, value)
+                match = labels.find { |range, _| range.cover?(value) }
+                match&.last
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/legion/extensions/agentic/defense/immune_response/helpers/immune_engine.rb

@@ -0,0 +1,184 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module Agentic
+      module Defense
+        module ImmuneResponse
+          module Helpers
+            class ImmuneEngine
+              include Constants
+
+              def initialize
+                @antigens   = {}
+                @antibodies = {}
+                @responses  = {}
+              end
+
+              def register_antigen(pattern:, antigen_type:, threat_level: DEFAULT_THREAT_LEVEL)
+                prune_antigens
+                antigen = Antigen.new(
+                  pattern: pattern, antigen_type: antigen_type, threat_level: threat_level
+                )
+                @antigens[antigen.id] = antigen
+                antigen
+              end
+
+              def encounter(antigen_id:)
+                antigen = @antigens[antigen_id]
+                return nil unless antigen
+
+                antigen.expose!
+                antibody = find_matching_antibody(antigen)
+                response = generate_response(antigen, antibody)
+                antibody&.strengthen!
+                @responses[response.id] = response
+                prune_responses
+                response
+              end
+
+              def create_antibody(antigen_type:, signature:, immunity_level: 0.3)
+                prune_antibodies
+                antibody = Antibody.new(
+                  antigen_type: antigen_type, signature: signature, immunity_level: immunity_level
+                )
+                @antibodies[antibody.id] = antibody
+                antibody
+              end
+
+              def vaccinate(antigen_type:, signature:)
+                create_antibody(
+                  antigen_type: antigen_type, signature: signature, immunity_level: 0.6
+                )
+              end
+
+              def decay_all!
+                @antibodies.each_value(&:decay!)
+                { antibodies_decayed: @antibodies.size }
+              end
+
+              def escalate_antigen(antigen_id:, amount: THREAT_ESCALATION)
+                antigen = @antigens[antigen_id]
+                return nil unless antigen
+
+                antigen.escalate!(amount)
+                antigen
+              end
+
+              def de_escalate_antigen(antigen_id:, amount: THREAT_ESCALATION)
+                antigen = @antigens[antigen_id]
+                return nil unless antigen
+
+                antigen.de_escalate!(amount)
+                antigen
+              end
+
+              def immunity_for(antigen_type:)
+                matching = @antibodies.values.select { |ab| ab.antigen_type == antigen_type.to_sym }
+                return 0.0 if matching.empty?
+
+                matching.map(&:immunity_level).max.round(10)
+              end
+
+              def critical_antigens = @antigens.values.select(&:critical?)
+              def benign_antigens = @antigens.values.select(&:benign?)
+              def memory_cells = @antibodies.values.select(&:memory_cell?)
+              def effective_antibodies = @antibodies.values.select(&:effective?)
+              def responses_for(antigen_id:) = @responses.values.select { |r| r.antigen_id == antigen_id }
+
+              def threat_by_type
+                ANTIGEN_TYPES.each_with_object({}) do |type, hash|
+                  matching = @antigens.values.select { |a| a.antigen_type == type }
+                  hash[type] = matching.empty? ? 0.0 : (matching.sum(&:threat_level) / matching.size).round(10)
+                end
+              end
+
+              def overall_immune_health
+                return 1.0 if @antigens.empty?
+
+                total_immunity = @antibodies.values.sum(&:immunity_level)
+                total_threat = @antigens.values.sum(&:threat_level)
+                denominator = total_immunity + total_threat
+                return 0.5 if denominator.zero?
+
+                (total_immunity / denominator).clamp(0.0, 1.0).round(10)
+              end
+
+              def immune_report
+                {
+                  total_antigens:    @antigens.size,
+                  total_antibodies:  @antibodies.size,
+                  total_responses:   @responses.size,
+                  critical_count:    critical_antigens.size,
+                  memory_cell_count: memory_cells.size,
+                  overall_health:    overall_immune_health,
+                  health_label:      Constants.label_for(HEALTH_LABELS, overall_immune_health),
+                  threat_by_type:    threat_by_type,
+                  most_exposed:      most_exposed(limit: 3).map(&:to_h)
+                }
+              end
+
+              def most_exposed(limit: 5) = @antigens.values.sort_by { |a| -a.exposure_count }.first(limit)
+              def most_threatening(limit: 5) = @antigens.values.sort_by { |a| -a.threat_level }.first(limit)
+              def strongest_antibodies(limit: 5) = @antibodies.values.sort_by { |ab| -ab.immunity_level }.first(limit)
+
+              def to_h
+                {
+                  antigens:       @antigens.size,
+                  antibodies:     @antibodies.size,
+                  responses:      @responses.size,
+                  overall_health: overall_immune_health
+                }
+              end
+
+              private
+
+              def find_matching_antibody(antigen)
+                @antibodies.values.select { |ab| ab.matches?(antigen) }.max_by(&:immunity_level)
+              end
+
+              def generate_response(antigen, antibody)
+                intensity = compute_intensity(antigen, antibody)
+                level = determine_response_level(intensity)
+                ImmuneResponse.new(
+                  antigen_id: antigen.id, antibody_id: antibody&.id,
+                  response_level: level, intensity: intensity
+                )
+              end
+
+              def compute_intensity(antigen, antibody)
+                base = antigen.threat_level
+                base *= (1.0 - (antibody.immunity_level * 0.5)) if antibody
+                base = [base, 0.8].min if antigen.recurring? && antibody&.memory_cell?
+                base.clamp(0.0, 1.0).round(10)
+              end
+
+              def determine_response_level(intensity) = Constants.label_for(RESPONSE_LABELS, intensity) || :monitoring
+
+              def prune_antigens
+                return if @antigens.size < MAX_ANTIGENS
+
+                oldest = @antigens.values.min_by(&:last_seen)
+                @antigens.delete(oldest.id) if oldest
+              end
+
+              def prune_antibodies
+                return if @antibodies.size < MAX_ANTIBODIES
+
+                weakest = @antibodies.values.reject(&:memory_cell?).min_by(&:immunity_level)
+                @antibodies.delete(weakest.id) if weakest
+              end
+
+              def prune_responses
+                return if @responses.size < MAX_RESPONSES
+
+                oldest = @responses.values.min_by(&:created_at)
+                @responses.delete(oldest.id) if oldest
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/legion/extensions/agentic/defense/immune_response/helpers/immune_response.rb

@@ -0,0 +1,76 @@
+# frozen_string_literal: true
+
+require 'securerandom'
+
+module Legion
+  module Extensions
+    module Agentic
+      module Defense
+        module ImmuneResponse
+          module Helpers
+            class ImmuneResponse
+              include Constants
+
+              attr_reader :id, :antigen_id, :antibody_id, :response_level,
+                          :intensity, :action_taken, :created_at
+
+              def initialize(antigen_id:, response_level:, antibody_id: nil, intensity: 0.5)
+                @id             = SecureRandom.uuid
+                @antigen_id     = antigen_id
+                @antibody_id    = antibody_id
+                @response_level = validate_response(response_level)
+                @intensity      = intensity.to_f.clamp(0.0, 1.0).round(10)
+                @action_taken   = nil
+                @created_at     = Time.now.utc
+              end
+
+              def record_action!(action)
+                @action_taken = action.to_s
+                self
+              end
+
+              def adaptive?
+                !@antibody_id.nil?
+              end
+
+              def innate?
+                @antibody_id.nil?
+              end
+
+              def severe?
+                @intensity >= REJECTION_THRESHOLD
+              end
+
+              def response_label
+                Constants.label_for(RESPONSE_LABELS, @intensity)
+              end
+
+              def to_h
+                {
+                  id:             @id,
+                  antigen_id:     @antigen_id,
+                  antibody_id:    @antibody_id,
+                  response_level: @response_level,
+                  intensity:      @intensity,
+                  response_label: response_label,
+                  adaptive:       adaptive?,
+                  innate:         innate?,
+                  severe:         severe?,
+                  action_taken:   @action_taken,
+                  created_at:     @created_at
+                }
+              end
+
+              private
+
+              def validate_response(level)
+                sym = level.to_sym
+                RESPONSE_LEVELS.include?(sym) ? sym : :monitoring
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/legion/extensions/agentic/defense/immune_response/runners/cognitive_immune_response.rb

@@ -0,0 +1,114 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module Agentic
+      module Defense
+        module ImmuneResponse
+          module Runners
+            module CognitiveImmuneResponse
+              include Legion::Extensions::Helpers::Lex if defined?(Legion::Extensions::Helpers::Lex)
+
+              def register_antigen(pattern:, antigen_type:, threat_level: 0.5, engine: nil, **)
+                eng = engine || default_engine
+                antigen = eng.register_antigen(
+                  pattern: pattern, antigen_type: antigen_type, threat_level: threat_level
+                )
+                { success: true, antigen: antigen.to_h }
+              end
+
+              def encounter_antigen(antigen_id:, engine: nil, **)
+                eng = engine || default_engine
+                response = eng.encounter(antigen_id: antigen_id)
+                return { success: false, error: 'antigen not found' } unless response
+
+                { success: true, response: response.to_h }
+              end
+
+              def create_antibody(antigen_type:, signature:, immunity_level: 0.3, engine: nil, **)
+                eng = engine || default_engine
+                antibody = eng.create_antibody(
+                  antigen_type: antigen_type, signature: signature, immunity_level: immunity_level
+                )
+                { success: true, antibody: antibody.to_h }
+              end
+
+              def vaccinate(antigen_type:, signature:, engine: nil, **)
+                eng = engine || default_engine
+                antibody = eng.vaccinate(antigen_type: antigen_type, signature: signature)
+                { success: true, antibody: antibody.to_h, vaccinated: true }
+              end
+
+              def escalate_threat(antigen_id:, amount: 0.1, engine: nil, **)
+                eng = engine || default_engine
+                antigen = eng.escalate_antigen(antigen_id: antigen_id, amount: amount)
+                return { success: false, error: 'antigen not found' } unless antigen
+
+                { success: true, antigen: antigen.to_h }
+              end
+
+              def de_escalate_threat(antigen_id:, amount: 0.1, engine: nil, **)
+                eng = engine || default_engine
+                antigen = eng.de_escalate_antigen(antigen_id: antigen_id, amount: amount)
+                return { success: false, error: 'antigen not found' } unless antigen
+
+                { success: true, antigen: antigen.to_h }
+              end
+
+              def immunity_for(antigen_type:, engine: nil, **)
+                eng = engine || default_engine
+                level = eng.immunity_for(antigen_type: antigen_type)
+                label = Helpers::Constants.label_for(Helpers::Constants::IMMUNITY_LABELS, level)
+                { success: true, antigen_type: antigen_type.to_sym, immunity_level: level, immunity_label: label }
+              end
+
+              def decay_all(engine: nil, **)
+                eng = engine || default_engine
+                result = eng.decay_all!
+                { success: true, **result }
+              end
+
+              def critical_antigens(engine: nil, **)
+                eng = engine || default_engine
+                { success: true, antigens: eng.critical_antigens.map(&:to_h) }
+              end
+
+              def memory_cells(engine: nil, **)
+                eng = engine || default_engine
+                { success: true, antibodies: eng.memory_cells.map(&:to_h) }
+              end
+
+              def most_threatening(limit: 5, engine: nil, **)
+                eng = engine || default_engine
+                { success: true, antigens: eng.most_threatening(limit: limit).map(&:to_h) }
+              end
+
+              def strongest_antibodies(limit: 5, engine: nil, **)
+                eng = engine || default_engine
+                { success: true, antibodies: eng.strongest_antibodies(limit: limit).map(&:to_h) }
+              end
+
+              def immune_report(engine: nil, **)
+                eng = engine || default_engine
+                { success: true, report: eng.immune_report }
+              end
+
+              def immune_status(engine: nil, **)
+                eng = engine || default_engine
+                health = eng.overall_immune_health
+                label = Helpers::Constants.label_for(Helpers::Constants::HEALTH_LABELS, health)
+                { success: true, overall_health: health, health_label: label, **eng.to_h }
+              end
+
+              private
+
+              def default_engine
+                @default_engine ||= Helpers::ImmuneEngine.new
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/legion/extensions/agentic/defense/immune_response/version.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module Agentic
+      module Defense
+        module ImmuneResponse
+          VERSION = '0.1.0'
+        end
+      end
+    end
+  end
+end

data/lib/legion/extensions/agentic/defense/immune_response.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+require_relative 'immune_response/version'
+require_relative 'immune_response/helpers/constants'
+require_relative 'immune_response/helpers/antigen'
+require_relative 'immune_response/helpers/antibody'
+require_relative 'immune_response/helpers/immune_response'
+require_relative 'immune_response/helpers/immune_engine'
+require_relative 'immune_response/runners/cognitive_immune_response'
+require_relative 'immune_response/client'
+
+module Legion
+  module Extensions
+    module Agentic
+      module Defense
+        module ImmuneResponse
+        end
+      end
+    end
+  end
+end

data/lib/legion/extensions/agentic/defense/immunology/client.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+require 'legion/extensions/agentic/defense/immunology/helpers/constants'
+require 'legion/extensions/agentic/defense/immunology/helpers/threat'
+require 'legion/extensions/agentic/defense/immunology/helpers/antibody'
+require 'legion/extensions/agentic/defense/immunology/helpers/immune_engine'
+require 'legion/extensions/agentic/defense/immunology/runners/cognitive_immunology'
+
+module Legion
+  module Extensions
+    module Agentic
+      module Defense
+        module Immunology
+          class Client
+            include Runners::CognitiveImmunology
+
+            def initialize(**)
+              @engine = Helpers::ImmuneEngine.new
+            end
+
+            private
+
+            attr_reader :engine
+          end
+        end
+      end
+    end
+  end
+end