lex-agentic-memory 0.1.0

data/lib/legion/extensions/agentic/memory/immune_memory/client.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module Agentic
+      module Memory
+        module ImmuneMemory
+          class Client
+            include Runners::CognitiveImmuneMemory
+
+            def initialize
+              @default_engine = Helpers::ImmuneMemoryEngine.new
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/legion/extensions/agentic/memory/immune_memory/helpers/constants.rb

@@ -0,0 +1,84 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module Agentic
+      module Memory
+        module ImmuneMemory
+          module Helpers
+            module Constants
+              MAX_MEMORY_CELLS = 500
+              MAX_ENCOUNTERS = 1000
+              MAX_ANTIBODY_LIBRARY = 300
+
+              # T-cell parameters (cell-mediated: direct threat neutralization)
+              T_CELL_ACTIVATION_THRESHOLD = 0.4
+              T_CELL_BOOST = 0.12
+              T_CELL_DECAY = 0.01
+              T_CELL_LIFESPAN = 100 # decay cycles before expiry check
+
+              # B-cell parameters (humoral: antibody production)
+              B_CELL_ACTIVATION_THRESHOLD = 0.3
+              B_CELL_BOOST = 0.1
+              B_CELL_DECAY = 0.008
+              B_CELL_ANTIBODY_PRODUCTION = 0.15
+
+              # Secondary response amplification
+              PRIMARY_RESPONSE_SPEED = 1.0
+              SECONDARY_RESPONSE_SPEED = 3.0
+              MEMORY_RECOGNITION_THRESHOLD = 0.6
+
+              # Vaccination (pre-exposure)
+              VACCINATION_STRENGTH = 0.5
+
+              THREAT_TYPES = %i[
+                prompt_injection data_poisoning social_engineering
+                resource_exhaustion privilege_escalation information_leak
+                logic_manipulation identity_spoofing
+              ].freeze
+
+              CELL_TYPES = %i[t_helper t_killer b_memory b_plasma].freeze
+
+              IMMUNITY_LABELS = {
+                (0.8..)     => :immune,
+                (0.6...0.8) => :resistant,
+                (0.4...0.6) => :partial,
+                (0.2...0.4) => :vulnerable,
+                (..0.2)     => :naive
+              }.freeze
+
+              RESPONSE_SPEED_LABELS = {
+                (2.5..)     => :lightning,
+                (1.8...2.5) => :rapid,
+                (1.0...1.8) => :normal,
+                (0.5...1.0) => :slow,
+                (..0.5)     => :impaired
+              }.freeze
+
+              HEALTH_LABELS = {
+                (0.8..)     => :robust,
+                (0.6...0.8) => :healthy,
+                (0.4...0.6) => :adequate,
+                (0.2...0.4) => :weakened,
+                (..0.2)     => :compromised
+              }.freeze
+
+              MATURITY_LABELS = {
+                (0.8..)     => :veteran,
+                (0.6...0.8) => :experienced,
+                (0.4...0.6) => :developing,
+                (0.2...0.4) => :immature,
+                (..0.2)     => :naive
+              }.freeze
+
+              def self.label_for(labels, value)
+                labels.each { |range, label| return label if range.cover?(value) }
+                :unknown
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/legion/extensions/agentic/memory/immune_memory/helpers/encounter.rb

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+require 'securerandom'
+
+module Legion
+  module Extensions
+    module Agentic
+      module Memory
+        module ImmuneMemory
+          module Helpers
+            class Encounter
+              include Constants
+
+              attr_reader :id, :threat_type, :threat_signature, :severity,
+                          :response_type, :response_speed, :outcome, :created_at
+
+              def initialize(threat_type:, threat_signature:, severity: 0.5, response_type: :primary,
+                             response_speed: PRIMARY_RESPONSE_SPEED, outcome: :neutralized)
+                @id = SecureRandom.uuid
+                @threat_type = threat_type.to_sym
+                @threat_signature = threat_signature.to_s
+                @severity = severity.to_f.clamp(0.0, 1.0)
+                @response_type = response_type.to_sym
+                @response_speed = response_speed.to_f.round(10)
+                @outcome = outcome.to_sym
+                @created_at = Time.now
+              end
+
+              def secondary? = @response_type == :secondary
+              def primary? = @response_type == :primary
+              def neutralized? = @outcome == :neutralized
+              def evaded? = @outcome == :evaded
+              def critical? = @severity >= 0.8
+
+              def to_h
+                {
+                  id:               @id,
+                  threat_type:      @threat_type,
+                  threat_signature: @threat_signature,
+                  severity:         @severity,
+                  response_type:    @response_type,
+                  response_speed:   @response_speed,
+                  outcome:          @outcome,
+                  critical:         critical?,
+                  created_at:       @created_at.iso8601
+                }
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/legion/extensions/agentic/memory/immune_memory/helpers/immune_memory_engine.rb

@@ -0,0 +1,171 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module Agentic
+      module Memory
+        module ImmuneMemory
+          module Helpers
+            class ImmuneMemoryEngine
+              include Constants
+
+              def initialize
+                @memory_cells = {}
+                @encounters = []
+              end
+
+              def create_memory_cell(threat_type:, signature:, cell_type: :b_memory, strength: VACCINATION_STRENGTH)
+                prune_expired
+                cell = MemoryCell.new(threat_type: threat_type, signature: signature,
+                                      cell_type: cell_type, strength: strength)
+                @memory_cells[cell.id] = cell
+                cell
+              end
+
+              def vaccinate(threat_type:, signature:, strength: VACCINATION_STRENGTH)
+                existing = find_by_signature(signature)
+                return existing.activate! if existing
+
+                create_memory_cell(threat_type: threat_type, signature: signature,
+                                   cell_type: :b_memory, strength: strength)
+              end
+
+              def encounter_threat(threat_type:, threat_signature:, severity: 0.5)
+                matching = find_by_signature(threat_signature)
+                response_type = matching ? :secondary : :primary
+                speed = matching ? matching.response_speed : PRIMARY_RESPONSE_SPEED
+                outcome = determine_outcome(matching, severity)
+
+                matching&.activate!
+
+                record = Encounter.new(
+                  threat_type: threat_type, threat_signature: threat_signature,
+                  severity: severity, response_type: response_type,
+                  response_speed: speed, outcome: outcome
+                )
+                @encounters << record
+                prune_encounters
+
+                unless matching
+                  create_memory_cell(threat_type: threat_type, signature: threat_signature,
+                                     cell_type: :b_memory, strength: B_CELL_ACTIVATION_THRESHOLD)
+                end
+
+                record
+              end
+
+              def decay_all!
+                @memory_cells.each_value(&:decay!)
+                prune_expired
+                { cells_remaining: @memory_cells.size }
+              end
+
+              def find_by_signature(signature)
+                @memory_cells.values.find { |c| c.signature == signature.to_s && !c.expired? }
+              end
+
+              def cells_for_threat(threat_type:)
+                @memory_cells.values.select { |c| c.threat_type == threat_type.to_sym && !c.expired? }
+              end
+
+              def immunity_for(threat_type:)
+                cells = cells_for_threat(threat_type: threat_type)
+                return 0.0 if cells.empty?
+
+                cells.max_by(&:strength).strength
+              end
+
+              def active_cells = @memory_cells.values.reject(&:expired?)
+              def t_cells = @memory_cells.values.select(&:t_cell?)
+              def b_cells = @memory_cells.values.select(&:b_cell?)
+              def veteran_cells = @memory_cells.values.select(&:veteran?)
+              def naive_cells = @memory_cells.values.select(&:naive?)
+
+              def encounters_for(threat_type:)
+                @encounters.select { |e| e.threat_type == threat_type.to_sym }
+              end
+
+              def secondary_response_rate
+                return 0.0 if @encounters.empty?
+
+                secondary = @encounters.count(&:secondary?)
+                (secondary.to_f / @encounters.size).round(10)
+              end
+
+              def neutralization_rate
+                return 0.0 if @encounters.empty?
+
+                neutralized = @encounters.count(&:neutralized?)
+                (neutralized.to_f / @encounters.size).round(10)
+              end
+
+              def average_response_speed
+                return PRIMARY_RESPONSE_SPEED if @encounters.empty?
+
+                (@encounters.sum(&:response_speed) / @encounters.size).round(10)
+              end
+
+              def threat_coverage
+                known_types = @memory_cells.values.map(&:threat_type).uniq
+                (known_types.size.to_f / THREAT_TYPES.size).clamp(0.0, 1.0).round(10)
+              end
+
+              def overall_health
+                return 0.0 if @memory_cells.empty?
+
+                avg_strength = (@memory_cells.values.sum(&:strength) / @memory_cells.size).round(10)
+                coverage_factor = threat_coverage
+                ((avg_strength * 0.6) + (coverage_factor * 0.4)).clamp(0.0, 1.0).round(10)
+              end
+
+              def health_label = Constants.label_for(HEALTH_LABELS, overall_health)
+
+              def immune_report
+                {
+                  total_cells:             @memory_cells.size,
+                  active_cells:            active_cells.size,
+                  t_cells:                 t_cells.size,
+                  b_cells:                 b_cells.size,
+                  veteran_cells:           veteran_cells.size,
+                  total_encounters:        @encounters.size,
+                  secondary_response_rate: secondary_response_rate,
+                  neutralization_rate:     neutralization_rate,
+                  average_response_speed:  average_response_speed,
+                  threat_coverage:         threat_coverage,
+                  overall_health:          overall_health,
+                  health_label:            health_label
+                }
+              end
+
+              def to_h
+                {
+                  total_cells:     @memory_cells.size,
+                  active:          active_cells.size,
+                  encounters:      @encounters.size,
+                  health:          overall_health,
+                  threat_coverage: threat_coverage
+                }
+              end
+
+              private
+
+              def determine_outcome(matching_cell, severity)
+                return :neutralized if matching_cell && matching_cell.strength >= severity
+
+                severity < 0.5 ? :neutralized : :evaded
+              end
+
+              def prune_expired
+                @memory_cells.reject! { |_, c| c.expired? } if @memory_cells.size >= MAX_MEMORY_CELLS
+              end
+
+              def prune_encounters
+                @encounters.shift while @encounters.size > MAX_ENCOUNTERS
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/legion/extensions/agentic/memory/immune_memory/helpers/memory_cell.rb

@@ -0,0 +1,97 @@
+# frozen_string_literal: true
+
+require 'securerandom'
+
+module Legion
+  module Extensions
+    module Agentic
+      module Memory
+        module ImmuneMemory
+          module Helpers
+            class MemoryCell
+              include Constants
+
+              attr_reader :id, :threat_type, :signature, :cell_type, :created_at,
+                          :encounter_count, :decay_cycles
+              attr_accessor :strength
+
+              def initialize(threat_type:, signature:, cell_type: :b_memory, strength: VACCINATION_STRENGTH)
+                @id = SecureRandom.uuid
+                @threat_type = threat_type.to_sym
+                @signature = signature.to_s
+                @cell_type = valid_cell_type(cell_type)
+                @strength = strength.to_f.clamp(0.0, 1.0)
+                @encounter_count = 0
+                @decay_cycles = 0
+                @created_at = Time.now
+              end
+
+              def activate!
+                @encounter_count += 1
+                boost = t_cell? ? T_CELL_BOOST : B_CELL_BOOST
+                @strength = (@strength + boost).clamp(0.0, 1.0).round(10)
+                @decay_cycles = 0
+                self
+              end
+
+              def decay!
+                @decay_cycles += 1
+                rate = t_cell? ? T_CELL_DECAY : B_CELL_DECAY
+                @strength = (@strength - rate).clamp(0.0, 1.0).round(10)
+                self
+              end
+
+              def recognizes?(threat_signature)
+                @signature == threat_signature.to_s && @strength >= MEMORY_RECOGNITION_THRESHOLD
+              end
+
+              def t_cell? = %i[t_helper t_killer].include?(@cell_type)
+              def b_cell? = %i[b_memory b_plasma].include?(@cell_type)
+              def expired? = @strength <= 0.0
+              def veteran? = @encounter_count >= 5
+              def naive? = @encounter_count.zero?
+              def active? = @strength > T_CELL_ACTIVATION_THRESHOLD
+
+              def response_speed
+                return PRIMARY_RESPONSE_SPEED if naive?
+
+                (PRIMARY_RESPONSE_SPEED + (@encounter_count * 0.4)).clamp(1.0, SECONDARY_RESPONSE_SPEED).round(10)
+              end
+
+              def maturity = (@encounter_count / 10.0).clamp(0.0, 1.0).round(10)
+              def maturity_label = Constants.label_for(MATURITY_LABELS, maturity)
+              def immunity_label = Constants.label_for(IMMUNITY_LABELS, @strength)
+              def speed_label = Constants.label_for(RESPONSE_SPEED_LABELS, response_speed)
+
+              def to_h
+                {
+                  id:              @id,
+                  threat_type:     @threat_type,
+                  signature:       @signature,
+                  cell_type:       @cell_type,
+                  strength:        @strength,
+                  encounter_count: @encounter_count,
+                  decay_cycles:    @decay_cycles,
+                  response_speed:  response_speed,
+                  immunity_label:  immunity_label,
+                  maturity_label:  maturity_label,
+                  t_cell:          t_cell?,
+                  b_cell:          b_cell?,
+                  expired:         expired?,
+                  created_at:      @created_at.iso8601
+                }
+              end
+
+              private
+
+              def valid_cell_type(type)
+                sym = type.to_sym
+                CELL_TYPES.include?(sym) ? sym : :b_memory
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/legion/extensions/agentic/memory/immune_memory/runners/cognitive_immune_memory.rb

@@ -0,0 +1,76 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module Agentic
+      module Memory
+        module ImmuneMemory
+          module Runners
+            module CognitiveImmuneMemory
+              include Legion::Extensions::Helpers::Lex if defined?(Legion::Extensions::Helpers::Lex)
+
+              def create_memory_cell(threat_type:, signature:, cell_type: :b_memory, strength: nil, engine: nil, **)
+                eng = engine || @default_engine
+                cell = eng.create_memory_cell(threat_type: threat_type, signature: signature,
+                                              cell_type: cell_type,
+                                              strength: strength || Helpers::Constants::VACCINATION_STRENGTH)
+                { success: true, cell: cell.to_h }
+              end
+
+              def vaccinate(threat_type:, signature:, strength: nil, engine: nil, **)
+                eng = engine || @default_engine
+                cell = eng.vaccinate(threat_type: threat_type, signature: signature,
+                                     strength: strength || Helpers::Constants::VACCINATION_STRENGTH)
+                { success: true, cell: cell.to_h }
+              end
+
+              def encounter_threat(threat_type:, threat_signature:, severity: 0.5, engine: nil, **)
+                eng = engine || @default_engine
+                record = eng.encounter_threat(threat_type: threat_type, threat_signature: threat_signature,
+                                              severity: severity)
+                { success: true, encounter: record.to_h }
+              end
+
+              def decay_all(engine: nil, **)
+                eng = engine || @default_engine
+                result = eng.decay_all!
+                { success: true, **result }
+              end
+
+              def immunity_for(threat_type:, engine: nil, **)
+                eng = engine || @default_engine
+                immunity = eng.immunity_for(threat_type: threat_type)
+                label = Helpers::Constants.label_for(Helpers::Constants::IMMUNITY_LABELS, immunity)
+                { success: true, threat_type: threat_type, immunity: immunity, label: label }
+              end
+
+              def active_cells(engine: nil, **)
+                eng = engine || @default_engine
+                cells = eng.active_cells
+                { success: true, count: cells.size, cells: cells.map(&:to_h) }
+              end
+
+              def veteran_cells(engine: nil, **)
+                eng = engine || @default_engine
+                cells = eng.veteran_cells
+                { success: true, count: cells.size, cells: cells.map(&:to_h) }
+              end
+
+              def threat_coverage(engine: nil, **)
+                eng = engine || @default_engine
+                coverage = eng.threat_coverage
+                { success: true, coverage: coverage }
+              end
+
+              def immune_status(engine: nil, **)
+                eng = engine || @default_engine
+                report = eng.immune_report
+                { success: true, **report }
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/legion/extensions/agentic/memory/immune_memory/version.rb

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

data/lib/legion/extensions/agentic/memory/immune_memory.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+require_relative 'immune_memory/version'
+require_relative 'immune_memory/helpers/constants'
+require_relative 'immune_memory/helpers/memory_cell'
+require_relative 'immune_memory/helpers/encounter'
+require_relative 'immune_memory/helpers/immune_memory_engine'
+require_relative 'immune_memory/runners/cognitive_immune_memory'
+require_relative 'immune_memory/client'
+
+module Legion
+  module Extensions
+    module Agentic
+      module Memory
+        module ImmuneMemory
+        end
+      end
+    end
+  end
+end

data/lib/legion/extensions/agentic/memory/nostalgia/client.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+require 'legion/extensions/agentic/memory/nostalgia/helpers/constants'
+require 'legion/extensions/agentic/memory/nostalgia/helpers/nostalgic_memory'
+require 'legion/extensions/agentic/memory/nostalgia/helpers/nostalgia_event'
+require 'legion/extensions/agentic/memory/nostalgia/helpers/nostalgia_engine'
+require 'legion/extensions/agentic/memory/nostalgia/runners/recall'
+require 'legion/extensions/agentic/memory/nostalgia/runners/analysis'
+
+module Legion
+  module Extensions
+    module Agentic
+      module Memory
+        module Nostalgia
+          class Client
+            include Runners::Recall
+            include Runners::Analysis
+
+            def initialize(engine: nil)
+              @nostalgia_engine = engine || Helpers::NostalgiaEngine.new
+            end
+
+            private
+
+            attr_reader :nostalgia_engine
+          end
+        end
+      end
+    end
+  end
+end

data/lib/legion/extensions/agentic/memory/nostalgia/helpers/constants.rb

@@ -0,0 +1,68 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module Agentic
+      module Memory
+        module Nostalgia
+          module Helpers
+            module Constants
+              MAX_MEMORIES       = 300
+              MAX_EVENTS         = 500
+              DEFAULT_WARMTH     = 0.3
+              WARMTH_GROWTH      = 0.02
+              WARMTH_CEILING     = 0.95
+              WARMTH_DECAY       = 0.01
+              TRIGGER_SENSITIVITY = 0.3
+              ROSY_THRESHOLD = 0.6
+              BITTERSWEET_THRESHOLD = 0.5
+
+              MEMORY_DOMAINS = %i[
+                relationship
+                place
+                achievement
+                routine
+                season
+                collaboration
+                challenge
+                unknown
+              ].freeze
+
+              WARMTH_LABELS = {
+                0.0..0.2 => :faint,
+                0.2..0.4 => :mild,
+                0.4..0.6 => :warm,
+                0.6..0.8 => :tender,
+                0.8..1.0 => :glowing
+              }.freeze
+
+              NOSTALGIA_LABELS = {
+                0.0..0.2 => :absent,
+                0.2..0.4 => :latent,
+                0.4..0.6 => :stirring,
+                0.6..0.8 => :vivid,
+                0.8..1.0 => :overwhelming
+              }.freeze
+
+              RETROSPECTION_LABELS = {
+                0.0..0.2 => :accurate,
+                0.2..0.4 => :slightly_rose_tinted,
+                0.4..0.6 => :moderately_rose_tinted,
+                0.6..0.8 => :strongly_rose_tinted,
+                0.8..1.0 => :heavily_idealized
+              }.freeze
+
+              def self.label_for(labels_hash, value)
+                clamped = value.clamp(0.0, 1.0)
+                labels_hash.each do |range, label|
+                  return label if range.cover?(clamped)
+                end
+                labels_hash.values.last
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end