lex-agentic-learning 0.1.0

data/lib/legion/extensions/agentic/learning/meta_learning.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+require 'legion/extensions/agentic/learning/meta_learning/version'
+require 'legion/extensions/agentic/learning/meta_learning/helpers/constants'
+require 'legion/extensions/agentic/learning/meta_learning/helpers/learning_domain'
+require 'legion/extensions/agentic/learning/meta_learning/helpers/strategy'
+require 'legion/extensions/agentic/learning/meta_learning/helpers/meta_learning_engine'
+require 'legion/extensions/agentic/learning/meta_learning/runners/meta_learning'
+require 'legion/extensions/agentic/learning/meta_learning/client'
+
+module Legion
+  module Extensions
+    module Agentic
+      module Learning
+        module MetaLearning
+        end
+      end
+    end
+  end
+end

data/lib/legion/extensions/agentic/learning/plasticity/client.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module Agentic
+      module Learning
+        module Plasticity
+          class Client
+            include Runners::CognitivePlasticity
+          end
+        end
+      end
+    end
+  end
+end

data/lib/legion/extensions/agentic/learning/plasticity/helpers/constants.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module Agentic
+      module Learning
+        module Plasticity
+          module Helpers
+            module Constants
+              MAX_PATHWAYS = 300
+              MAX_EVENTS = 500
+
+              DEFAULT_LEARNING_RATE = 0.5
+              STRENGTHENING_RATE = 0.08
+              PRUNING_THRESHOLD = 0.15
+              CRITICAL_PERIOD_MULTIPLIER = 2.5
+              MATURATION_RATE = 0.01
+
+              PLASTICITY_LABELS = {
+                (0.8..)     => :highly_plastic,
+                (0.6...0.8) => :plastic,
+                (0.4...0.6) => :moderate,
+                (0.2...0.4) => :rigid,
+                (..0.2)     => :crystallized
+              }.freeze
+
+              STRENGTH_LABELS = {
+                (0.8..)     => :robust,
+                (0.6...0.8) => :strong,
+                (0.4...0.6) => :moderate,
+                (0.2...0.4) => :weak,
+                (..0.2)     => :nascent
+              }.freeze
+
+              PATHWAY_TYPES = %i[
+                synaptic structural functional
+                homeostatic metaplastic
+              ].freeze
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/legion/extensions/agentic/learning/plasticity/helpers/neural_pathway.rb

@@ -0,0 +1,85 @@
+# frozen_string_literal: true
+
+require 'securerandom'
+
+module Legion
+  module Extensions
+    module Agentic
+      module Learning
+        module Plasticity
+          module Helpers
+            class NeuralPathway
+              include Constants
+
+              attr_reader :id, :label, :pathway_type, :strength, :plasticity,
+                          :activation_count, :created_at
+
+              def initialize(label:, pathway_type: :synaptic, initial_strength: 0.3)
+                @id               = SecureRandom.uuid
+                @label            = label
+                @pathway_type     = pathway_type.to_sym
+                @strength         = initial_strength.to_f.clamp(0.0, 1.0)
+                @plasticity       = DEFAULT_LEARNING_RATE
+                @activation_count = 0
+                @created_at       = Time.now.utc
+              end
+
+              def strengthen!(amount: STRENGTHENING_RATE, critical_period: false)
+                multiplier = critical_period ? CRITICAL_PERIOD_MULTIPLIER : 1.0
+                effective = (amount * multiplier * @plasticity).round(10)
+                @strength = (@strength + effective).clamp(0.0, 1.0).round(10)
+                @activation_count += 1
+                mature!
+                self
+              end
+
+              def weaken!(amount: STRENGTHENING_RATE)
+                effective = (amount * @plasticity).round(10)
+                @strength = (@strength - effective).clamp(0.0, 1.0).round(10)
+                self
+              end
+
+              def prune_candidate?
+                @strength < PRUNING_THRESHOLD
+              end
+
+              def mature!
+                @plasticity = (@plasticity - MATURATION_RATE).clamp(0.1, 1.0).round(10)
+              end
+
+              def rejuvenate!(amount: 0.1)
+                @plasticity = (@plasticity + amount).clamp(0.1, 1.0).round(10)
+                self
+              end
+
+              def strength_label
+                match = STRENGTH_LABELS.find { |range, _| range.cover?(@strength) }
+                match ? match.last : :nascent
+              end
+
+              def plasticity_label
+                match = PLASTICITY_LABELS.find { |range, _| range.cover?(@plasticity) }
+                match ? match.last : :crystallized
+              end
+
+              def to_h
+                {
+                  id:               @id,
+                  label:            @label,
+                  pathway_type:     @pathway_type,
+                  strength:         @strength,
+                  strength_label:   strength_label,
+                  plasticity:       @plasticity,
+                  plasticity_label: plasticity_label,
+                  activation_count: @activation_count,
+                  prune_candidate:  prune_candidate?,
+                  created_at:       @created_at
+                }
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/legion/extensions/agentic/learning/plasticity/helpers/plasticity_engine.rb

@@ -0,0 +1,130 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module Agentic
+      module Learning
+        module Plasticity
+          module Helpers
+            class PlasticityEngine
+              include Constants
+
+              def initialize
+                @pathways        = {}
+                @critical_period = false
+              end
+
+              def create_pathway(label:, pathway_type: :synaptic, initial_strength: 0.3)
+                prune_if_needed
+                pathway = NeuralPathway.new(label: label, pathway_type: pathway_type,
+                                            initial_strength: initial_strength)
+                @pathways[pathway.id] = pathway
+                pathway
+              end
+
+              def strengthen_pathway(pathway_id:, amount: STRENGTHENING_RATE)
+                pathway = @pathways[pathway_id]
+                return nil unless pathway
+
+                pathway.strengthen!(amount: amount, critical_period: @critical_period)
+              end
+
+              def weaken_pathway(pathway_id:, amount: STRENGTHENING_RATE)
+                pathway = @pathways[pathway_id]
+                return nil unless pathway
+
+                pathway.weaken!(amount: amount)
+              end
+
+              def rejuvenate_pathway(pathway_id:, amount: 0.1)
+                pathway = @pathways[pathway_id]
+                return nil unless pathway
+
+                pathway.rejuvenate!(amount: amount)
+              end
+
+              def enter_critical_period!
+                @critical_period = true
+              end
+
+              def exit_critical_period!
+                @critical_period = false
+              end
+
+              def critical_period?
+                @critical_period
+              end
+
+              def prune_weak_pathways!
+                candidates = @pathways.values.select(&:prune_candidate?)
+                candidates.each { |p| @pathways.delete(p.id) }
+                candidates.size
+              end
+
+              def pathways_by_type(pathway_type:)
+                pt = pathway_type.to_sym
+                @pathways.values.select { |p| p.pathway_type == pt }
+              end
+
+              def strongest_pathways(limit: 5)
+                @pathways.values.sort_by { |p| -p.strength }.first(limit)
+              end
+
+              def weakest_pathways(limit: 5)
+                @pathways.values.sort_by(&:strength).first(limit)
+              end
+
+              def average_strength
+                return 0.0 if @pathways.empty?
+
+                strengths = @pathways.values.map(&:strength)
+                (strengths.sum / strengths.size).round(10)
+              end
+
+              def average_plasticity
+                return DEFAULT_LEARNING_RATE if @pathways.empty?
+
+                plasticities = @pathways.values.map(&:plasticity)
+                (plasticities.sum / plasticities.size).round(10)
+              end
+
+              def prune_candidates_count
+                @pathways.values.count(&:prune_candidate?)
+              end
+
+              def plasticity_report
+                {
+                  total_pathways:     @pathways.size,
+                  critical_period:    @critical_period,
+                  average_strength:   average_strength,
+                  average_plasticity: average_plasticity,
+                  prune_candidates:   prune_candidates_count,
+                  strongest:          strongest_pathways(limit: 3).map(&:to_h)
+                }
+              end
+
+              def to_h
+                {
+                  total_pathways:     @pathways.size,
+                  critical_period:    @critical_period,
+                  average_strength:   average_strength,
+                  average_plasticity: average_plasticity,
+                  prune_candidates:   prune_candidates_count
+                }
+              end
+
+              private
+
+              def prune_if_needed
+                return if @pathways.size < MAX_PATHWAYS
+
+                weakest = @pathways.values.min_by(&:strength)
+                @pathways.delete(weakest.id) if weakest
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/legion/extensions/agentic/learning/plasticity/runners/cognitive_plasticity.rb

@@ -0,0 +1,85 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module Agentic
+      module Learning
+        module Plasticity
+          module Runners
+            module CognitivePlasticity
+              include Helpers::Constants
+
+              include Legion::Extensions::Helpers::Lex if defined?(Legion::Extensions::Helpers::Lex)
+
+              def create_pathway(label:, engine: nil, pathway_type: :synaptic, initial_strength: 0.3, **)
+                eng = engine || default_engine
+                pathway = eng.create_pathway(label: label, pathway_type: pathway_type,
+                                             initial_strength: initial_strength)
+                { success: true, pathway: pathway.to_h }
+              end
+
+              def strengthen_pathway(pathway_id:, engine: nil, amount: STRENGTHENING_RATE, **)
+                eng = engine || default_engine
+                result = eng.strengthen_pathway(pathway_id: pathway_id, amount: amount)
+                return { success: false, error: 'pathway not found' } unless result
+
+                { success: true, pathway: result.to_h }
+              end
+
+              def weaken_pathway(pathway_id:, engine: nil, amount: STRENGTHENING_RATE, **)
+                eng = engine || default_engine
+                result = eng.weaken_pathway(pathway_id: pathway_id, amount: amount)
+                return { success: false, error: 'pathway not found' } unless result
+
+                { success: true, pathway: result.to_h }
+              end
+
+              def rejuvenate_pathway(pathway_id:, engine: nil, amount: 0.1, **)
+                eng = engine || default_engine
+                result = eng.rejuvenate_pathway(pathway_id: pathway_id, amount: amount)
+                return { success: false, error: 'pathway not found' } unless result
+
+                { success: true, pathway: result.to_h }
+              end
+
+              def enter_critical_period(engine: nil, **)
+                eng = engine || default_engine
+                eng.enter_critical_period!
+                { success: true, critical_period: true }
+              end
+
+              def exit_critical_period(engine: nil, **)
+                eng = engine || default_engine
+                eng.exit_critical_period!
+                { success: true, critical_period: false }
+              end
+
+              def prune_weak_pathways(engine: nil, **)
+                eng = engine || default_engine
+                pruned = eng.prune_weak_pathways!
+                { success: true, pruned_count: pruned }
+              end
+
+              def strongest_pathways(engine: nil, limit: 5, **)
+                eng = engine || default_engine
+                pathways = eng.strongest_pathways(limit: limit).map(&:to_h)
+                { success: true, pathways: pathways, count: pathways.size }
+              end
+
+              def plasticity_report(engine: nil, **)
+                eng = engine || default_engine
+                { success: true, report: eng.plasticity_report }
+              end
+
+              private
+
+              def default_engine
+                @default_engine ||= Helpers::PlasticityEngine.new
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/legion/extensions/agentic/learning/plasticity/version.rb

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

data/lib/legion/extensions/agentic/learning/plasticity.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+require_relative 'plasticity/version'
+require_relative 'plasticity/helpers/constants'
+require_relative 'plasticity/helpers/neural_pathway'
+require_relative 'plasticity/helpers/plasticity_engine'
+require_relative 'plasticity/runners/cognitive_plasticity'
+require_relative 'plasticity/client'
+
+module Legion
+  module Extensions
+    module Agentic
+      module Learning
+        module Plasticity
+        end
+      end
+    end
+  end
+end

data/lib/legion/extensions/agentic/learning/preference_learning/actors/decay.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+require 'legion/extensions/actors/every'
+
+module Legion
+  module Extensions
+    module Agentic
+      module Learning
+        module PreferenceLearning
+          module Actor
+            class Decay < Legion::Extensions::Actors::Every
+              def runner_class
+                Legion::Extensions::Agentic::Learning::PreferenceLearning::Runners::PreferenceLearning
+              end
+
+              def runner_function
+                'update_preference_learning'
+              end
+
+              def time
+                300
+              end
+
+              def run_now?
+                false
+              end
+
+              def use_runner?
+                false
+              end
+
+              def check_subtask?
+                false
+              end
+
+              def generate_task?
+                false
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/legion/extensions/agentic/learning/preference_learning/client.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+require 'legion/extensions/agentic/learning/preference_learning/helpers/constants'
+require 'legion/extensions/agentic/learning/preference_learning/helpers/option'
+require 'legion/extensions/agentic/learning/preference_learning/helpers/preference_engine'
+require 'legion/extensions/agentic/learning/preference_learning/runners/preference_learning'
+
+module Legion
+  module Extensions
+    module Agentic
+      module Learning
+        module PreferenceLearning
+          class Client
+            include Runners::PreferenceLearning
+
+            def initialize(**)
+              @preference_engine = Helpers::PreferenceEngine.new
+            end
+
+            private
+
+            attr_reader :preference_engine
+          end
+        end
+      end
+    end
+  end
+end

data/lib/legion/extensions/agentic/learning/preference_learning/helpers/constants.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module Agentic
+      module Learning
+        module PreferenceLearning
+          module Helpers
+            module Constants
+              PREFERENCE_LABELS = {
+                (0.8..)     => :strongly_preferred,
+                (0.6...0.8) => :preferred,
+                (0.4...0.6) => :neutral,
+                (0.2...0.4) => :disliked,
+                (..0.2)     => :strongly_disliked
+              }.freeze
+
+              MAX_OPTIONS     = 200
+              MAX_COMPARISONS = 1000
+              MAX_HISTORY     = 500
+
+              DEFAULT_PREFERENCE  = 0.5
+              PREFERENCE_FLOOR    = 0.0
+              PREFERENCE_CEILING  = 1.0
+
+              WIN_BOOST     = 0.08
+              LOSS_PENALTY  = 0.06
+              DECAY_RATE    = 0.01
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/legion/extensions/agentic/learning/preference_learning/helpers/option.rb

@@ -0,0 +1,78 @@
+# frozen_string_literal: true
+
+require 'securerandom'
+
+module Legion
+  module Extensions
+    module Agentic
+      module Learning
+        module PreferenceLearning
+          module Helpers
+            class Option
+              attr_reader :id, :label, :domain, :created_at
+              attr_accessor :preference_score, :wins, :losses, :times_seen
+
+              def initialize(label:, domain: :general)
+                @id               = SecureRandom.uuid
+                @label            = label
+                @domain           = domain
+                @preference_score = Constants::DEFAULT_PREFERENCE
+                @wins             = 0
+                @losses           = 0
+                @times_seen       = 0
+                @created_at       = Time.now.utc
+              end
+
+              def win!
+                @wins         += 1
+                @times_seen   += 1
+                @preference_score = clamp(@preference_score + Constants::WIN_BOOST)
+              end
+
+              def lose!
+                @losses       += 1
+                @times_seen   += 1
+                @preference_score = clamp(@preference_score - Constants::LOSS_PENALTY)
+              end
+
+              def win_rate
+                total = @wins + @losses
+                return 0.0 if total.zero?
+
+                @wins.to_f / (total + 1)
+              end
+
+              def preference_label
+                Constants::PREFERENCE_LABELS.each do |range, label|
+                  return label if range.cover?(@preference_score)
+                end
+                :neutral
+              end
+
+              def to_h
+                {
+                  id:               @id,
+                  label:            @label,
+                  domain:           @domain,
+                  preference_score: @preference_score,
+                  wins:             @wins,
+                  losses:           @losses,
+                  times_seen:       @times_seen,
+                  win_rate:         win_rate,
+                  preference_label: preference_label,
+                  created_at:       @created_at
+                }
+              end
+
+              private
+
+              def clamp(value)
+                value.clamp(Constants::PREFERENCE_FLOOR, Constants::PREFERENCE_CEILING)
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end