lex-agentic-learning 0.1.0

data/lib/legion/extensions/agentic/learning/epistemic_curiosity/runners/epistemic_curiosity.rb

@@ -0,0 +1,106 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module Agentic
+      module Learning
+        module EpistemicCuriosity
+          module Runners
+            module EpistemicCuriosity
+              include Legion::Extensions::Helpers::Lex if Legion::Extensions.const_defined?(:Helpers) &&
+                                                          Legion::Extensions::Helpers.const_defined?(:Lex)
+
+              def create_gap(question:, domain:, gap_type: :factual, urgency: Helpers::Constants::DEFAULT_URGENCY, **)
+                result = engine.create_gap(question: question, domain: domain, gap_type: gap_type, urgency: urgency)
+                if result[:created]
+                  Legion::Logging.info "[epistemic_curiosity] gap created: id=#{result[:gap][:id]} domain=#{domain} type=#{gap_type}"
+                else
+                  Legion::Logging.debug "[epistemic_curiosity] gap not created: reason=#{result[:reason]}"
+                end
+                result
+              end
+
+              def explore_gap(gap_id:, **)
+                result = engine.explore_gap(gap_id: gap_id)
+                if result[:found]
+                  gap = result[:gap]
+                  Legion::Logging.debug "[epistemic_curiosity] explore: id=#{gap_id} explorations=#{gap[:explorations]} urgency=#{gap[:urgency]}"
+                else
+                  Legion::Logging.debug "[epistemic_curiosity] explore: id=#{gap_id} not found"
+                end
+                result
+              end
+
+              def satisfy_gap(gap_id:, amount: 0.3, **)
+                result = engine.satisfy_gap(gap_id: gap_id, amount: amount)
+                if result[:found]
+                  gap = result[:gap]
+                  Legion::Logging.debug "[epistemic_curiosity] satisfy: id=#{gap_id} satisfaction=#{gap[:satisfaction]} resolved=#{gap[:resolved]}"
+                else
+                  Legion::Logging.debug "[epistemic_curiosity] satisfy: id=#{gap_id} not found"
+                end
+                result
+              end
+
+              def resolve_gap(gap_id:, **)
+                result = engine.resolve_gap(gap_id: gap_id)
+                if result[:found]
+                  Legion::Logging.info "[epistemic_curiosity] resolved: id=#{gap_id}"
+                else
+                  Legion::Logging.debug "[epistemic_curiosity] resolve: id=#{gap_id} not found"
+                end
+                result
+              end
+
+              def most_urgent_gaps(limit: 5, **)
+                gaps = engine.most_urgent(limit: limit)
+                Legion::Logging.debug "[epistemic_curiosity] most_urgent: limit=#{limit} returned=#{gaps.size}"
+                { gaps: gaps.map(&:to_h), count: gaps.size }
+              end
+
+              def gaps_by_domain(domain:, **)
+                gaps = engine.by_domain(domain)
+                Legion::Logging.debug "[epistemic_curiosity] by_domain: domain=#{domain} count=#{gaps.size}"
+                { gaps: gaps.map(&:to_h), count: gaps.size, domain: domain }
+              end
+
+              def gaps_by_type(gap_type:, **)
+                gaps = engine.by_type(gap_type)
+                Legion::Logging.debug "[epistemic_curiosity] by_type: gap_type=#{gap_type} count=#{gaps.size}"
+                { gaps: gaps.map(&:to_h), count: gaps.size, gap_type: gap_type }
+              end
+
+              def decay_gaps(**)
+                count = engine.decay_all
+                Legion::Logging.debug "[epistemic_curiosity] decay cycle: gaps_updated=#{count}"
+                { decayed: count }
+              end
+
+              def curiosity_report(**)
+                report = engine.curiosity_report
+                Legion::Logging.debug "[epistemic_curiosity] report: open=#{report[:open_gaps]} debt=#{report[:information_debt]}"
+                report
+              end
+
+              def curiosity_status(**)
+                {
+                  total_gaps:             engine.open_gaps.size + engine.resolved_gaps.size,
+                  open_gaps:              engine.open_gaps.size,
+                  resolved_gaps:          engine.resolved_gaps.size,
+                  information_debt:       engine.information_debt,
+                  exploration_efficiency: engine.exploration_efficiency
+                }
+              end
+
+              private
+
+              def engine
+                @engine ||= Helpers::CuriosityEngine.new
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

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

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

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+require 'legion/extensions/agentic/learning/epistemic_curiosity/version'
+require 'legion/extensions/agentic/learning/epistemic_curiosity/helpers/constants'
+require 'legion/extensions/agentic/learning/epistemic_curiosity/helpers/knowledge_gap'
+require 'legion/extensions/agentic/learning/epistemic_curiosity/helpers/curiosity_engine'
+require 'legion/extensions/agentic/learning/epistemic_curiosity/runners/epistemic_curiosity'
+require 'legion/extensions/agentic/learning/epistemic_curiosity/client'
+
+module Legion
+  module Extensions
+    module Agentic
+      module Learning
+        module EpistemicCuriosity
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module Agentic
+      module Learning
+        module Fermentation
+          class Client
+            include Runners::CognitiveFermentation
+
+            def initialize
+              @default_engine = Helpers::FermentationEngine.new
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/legion/extensions/agentic/learning/fermentation/helpers/batch.rb

@@ -0,0 +1,75 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module Agentic
+      module Learning
+        module Fermentation
+          module Helpers
+            class Batch
+              include Constants
+
+              attr_reader :id, :domain, :substrates, :created_at
+
+              def initialize(domain:)
+                @id         = SecureRandom.uuid
+                @domain     = domain.to_sym
+                @substrates = []
+                @created_at = Time.now.utc
+              end
+
+              def add_substrate(substrate)
+                @substrates << substrate
+                substrate
+              end
+
+              def ferment_all!(rate = MATURATION_RATE)
+                @substrates.each { |s| s.ferment!(rate) }
+              end
+
+              def average_potency
+                return 0.0 if @substrates.empty?
+
+                (@substrates.sum(&:potency) / @substrates.size).round(10)
+              end
+
+              def average_maturity
+                return 0.0 if @substrates.empty?
+
+                (@substrates.sum(&:maturity) / @substrates.size).round(10)
+              end
+
+              def ripe_count = @substrates.count(&:ripe?)
+              def peak_count = @substrates.count(&:peak?)
+              def spoiled_count = @substrates.count(&:spoiled?)
+              def raw_count = @substrates.count(&:raw?)
+
+              def yield_rate
+                return 0.0 if @substrates.empty?
+
+                (ripe_count.to_f / @substrates.size).round(10)
+              end
+
+              def ready_to_harvest? = yield_rate >= 0.5
+
+              def to_h
+                {
+                  id:               @id,
+                  domain:           @domain,
+                  substrate_count:  @substrates.size,
+                  average_potency:  average_potency,
+                  average_maturity: average_maturity,
+                  ripe_count:       ripe_count,
+                  peak_count:       peak_count,
+                  spoiled_count:    spoiled_count,
+                  yield_rate:       yield_rate,
+                  ready_to_harvest: ready_to_harvest?
+                }
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,78 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module Agentic
+      module Learning
+        module Fermentation
+          module Helpers
+            module Constants
+              MAX_SUBSTRATES = 500
+              MAX_BATCHES = 50
+
+              DEFAULT_POTENCY = 0.3
+              MATURATION_RATE = 0.05
+              VOLATILITY_DECAY = 0.02
+              CATALYSIS_BOOST = 0.12
+              SPOILAGE_THRESHOLD = 0.1
+              RIPE_THRESHOLD = 0.7
+              PEAK_THRESHOLD = 0.9
+              OVER_FERMENTED_DECAY = 0.03
+
+              SUBSTRATE_TYPES = %i[
+                raw_idea unresolved_problem partial_pattern
+                dormant_association vague_intuition half_formed_belief
+                contradictory_evidence lingering_question
+              ].freeze
+
+              FERMENTATION_STAGES = %i[
+                inoculation primary_fermentation secondary_fermentation
+                conditioning maturation aging peak over_fermented
+              ].freeze
+
+              CATALYST_TYPES = %i[
+                analogy contrast juxtaposition
+                emotional_charge sleep dream_residue
+                environmental_stimulus social_interaction
+              ].freeze
+
+              DOMAINS = %i[
+                cognitive emotional procedural semantic
+                episodic social creative analytical
+              ].freeze
+
+              POTENCY_LABELS = {
+                (0.8..)     => :transcendent,
+                (0.6...0.8) => :potent,
+                (0.4...0.6) => :developing,
+                (0.2...0.4) => :mild,
+                (..0.2)     => :inert
+              }.freeze
+
+              MATURITY_LABELS = {
+                (0.8..)     => :peak,
+                (0.6...0.8) => :mature,
+                (0.4...0.6) => :developing,
+                (0.2...0.4) => :young,
+                (..0.2)     => :raw
+              }.freeze
+
+              VOLATILITY_LABELS = {
+                (0.8..)     => :explosive,
+                (0.6...0.8) => :volatile,
+                (0.4...0.6) => :active,
+                (0.2...0.4) => :stable,
+                (..0.2)     => :dormant
+              }.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/learning/fermentation/helpers/fermentation_engine.rb

@@ -0,0 +1,147 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module Agentic
+      module Learning
+        module Fermentation
+          module Helpers
+            class FermentationEngine
+              include Constants
+
+              def initialize
+                @substrates = {}
+                @batches    = {}
+              end
+
+              def create_substrate(substrate_type:, domain:, content: '', potency: nil, volatility: nil)
+                sub = Substrate.new(substrate_type: substrate_type, domain: domain, content: content,
+                                    potency: potency, volatility: volatility)
+                @substrates[sub.id] = sub
+                batch = find_or_create_batch(domain: domain)
+                batch.add_substrate(sub)
+                prune_substrates
+                sub
+              end
+
+              def ferment(substrate_id:, rate: MATURATION_RATE)
+                sub = @substrates[substrate_id]
+                return nil unless sub
+
+                sub.ferment!(rate)
+                sub
+              end
+
+              def catalyze(substrate_id:, catalyst_type:)
+                sub = @substrates[substrate_id]
+                return nil unless sub
+
+                sub.catalyze!(catalyst_type)
+                sub
+              end
+
+              def ferment_all!(rate: MATURATION_RATE)
+                @batches.each_value { |b| b.ferment_all!(rate) }
+              end
+
+              def substrates_by_domain(domain:) = @substrates.values.select { |s| s.domain == domain.to_sym }
+              def substrates_by_type(type:) = @substrates.values.select { |s| s.substrate_type == type.to_sym }
+              def substrates_by_stage(stage:) = @substrates.values.select { |s| s.stage == stage.to_sym }
+              def ripe_substrates = @substrates.values.select(&:ripe?)
+              def peak_substrates = @substrates.values.select(&:peak?)
+              def spoiled_substrates = @substrates.values.select(&:spoiled?)
+              def raw_substrates = @substrates.values.select(&:raw?)
+
+              def most_potent(limit: 5)
+                @substrates.values.sort_by { |s| -s.potency }.first(limit)
+              end
+
+              def most_mature(limit: 5)
+                @substrates.values.sort_by { |s| -s.maturity }.first(limit)
+              end
+
+              def overall_potency
+                return 0.0 if @substrates.empty?
+
+                (@substrates.values.sum(&:potency) / @substrates.size).round(10)
+              end
+
+              def overall_maturity
+                return 0.0 if @substrates.empty?
+
+                (@substrates.values.sum(&:maturity) / @substrates.size).round(10)
+              end
+
+              def overall_volatility
+                return 0.0 if @substrates.empty?
+
+                (@substrates.values.sum(&:volatility) / @substrates.size).round(10)
+              end
+
+              def yield_rate
+                return 0.0 if @substrates.empty?
+
+                (ripe_substrates.size.to_f / @substrates.size).round(10)
+              end
+
+              def stage_distribution
+                dist = Hash.new(0)
+                @substrates.each_value { |s| dist[s.stage] += 1 }
+                dist
+              end
+
+              def fermentation_report
+                {
+                  total_substrates:   @substrates.size,
+                  total_batches:      @batches.size,
+                  overall_potency:    overall_potency,
+                  potency_label:      Constants.label_for(POTENCY_LABELS, overall_potency),
+                  overall_maturity:   overall_maturity,
+                  maturity_label:     Constants.label_for(MATURITY_LABELS, overall_maturity),
+                  overall_volatility: overall_volatility,
+                  volatility_label:   Constants.label_for(VOLATILITY_LABELS, overall_volatility),
+                  yield_rate:         yield_rate,
+                  ripe_count:         ripe_substrates.size,
+                  peak_count:         peak_substrates.size,
+                  spoiled_count:      spoiled_substrates.size,
+                  stage_distribution: stage_distribution,
+                  batches:            @batches.values.map(&:to_h),
+                  most_potent:        most_potent(limit: 3).map(&:to_h)
+                }
+              end
+
+              def to_h
+                {
+                  total_substrates: @substrates.size,
+                  total_batches:    @batches.size,
+                  potency:          overall_potency,
+                  maturity:         overall_maturity,
+                  volatility:       overall_volatility
+                }
+              end
+
+              private
+
+              def find_or_create_batch(domain:)
+                key = domain.to_sym
+                @batches[key] ||= Batch.new(domain: key)
+              end
+
+              def prune_substrates
+                return if @substrates.size <= MAX_SUBSTRATES
+
+                spoiled = @substrates.values.select(&:spoiled?)
+                spoiled.each { |s| @substrates.delete(s.id) }
+                return if @substrates.size <= MAX_SUBSTRATES
+
+                sorted = @substrates.values.sort_by(&:potency)
+                to_remove = sorted.first(@substrates.size - MAX_SUBSTRATES)
+                to_remove.each { |s| @substrates.delete(s.id) }
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/legion/extensions/agentic/learning/fermentation/helpers/substrate.rb

@@ -0,0 +1,108 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module Agentic
+      module Learning
+        module Fermentation
+          module Helpers
+            class Substrate
+              include Constants
+
+              attr_reader :id, :substrate_type, :domain, :content, :potency,
+                          :maturity, :volatility, :stage, :created_at, :catalysts_applied
+
+              def initialize(substrate_type:, domain:, content: '', potency: nil, volatility: nil)
+                @id                = SecureRandom.uuid
+                @substrate_type    = substrate_type.to_sym
+                @domain            = domain.to_sym
+                @content           = content
+                @potency           = (potency || DEFAULT_POTENCY).to_f.clamp(0.0, 1.0)
+                @maturity          = 0.0
+                @volatility        = (volatility || 0.5).to_f.clamp(0.0, 1.0)
+                @stage             = :inoculation
+                @catalysts_applied = []
+                @created_at        = Time.now.utc
+              end
+
+              def ferment!(rate = MATURATION_RATE)
+                @maturity = (@maturity + rate).clamp(0.0, 1.0).round(10)
+                @volatility = (@volatility - VOLATILITY_DECAY).clamp(0.0, 1.0).round(10)
+                advance_stage!
+                @potency = compute_potency
+              end
+
+              def catalyze!(catalyst_type)
+                @catalysts_applied << catalyst_type.to_sym
+                @potency = (@potency + CATALYSIS_BOOST).clamp(0.0, 1.0).round(10)
+                @volatility = (@volatility + 0.05).clamp(0.0, 1.0).round(10)
+              end
+
+              def spoil!
+                @potency = (@potency * 0.5).round(10)
+                @stage = :over_fermented
+              end
+
+              def ripe? = @potency >= RIPE_THRESHOLD && @maturity >= 0.5
+              def peak? = @potency >= PEAK_THRESHOLD && @stage == :peak
+              def spoiled? = @potency < SPOILAGE_THRESHOLD
+              def raw? = @stage == :inoculation
+              def aging? = @stage == :aging
+              def over_fermented? = @stage == :over_fermented
+              def multi_catalyzed? = @catalysts_applied.uniq.size >= 3
+
+              STAGE_THRESHOLDS = {
+                (0.0...0.1)   => :inoculation,
+                (0.1...0.25)  => :primary_fermentation,
+                (0.25...0.4)  => :secondary_fermentation,
+                (0.4...0.55)  => :conditioning,
+                (0.55...0.7)  => :maturation,
+                (0.7...0.85)  => :aging,
+                (0.85...0.95) => :peak,
+                (0.95..)      => :over_fermented
+              }.freeze
+
+              def age
+                ((Time.now.utc - @created_at) / 60.0).round(2)
+              end
+
+              def to_h
+                {
+                  id:                @id,
+                  substrate_type:    @substrate_type,
+                  domain:            @domain,
+                  content:           @content,
+                  potency:           @potency.round(10),
+                  maturity:          @maturity.round(10),
+                  volatility:        @volatility.round(10),
+                  stage:             @stage,
+                  ripe:              ripe?,
+                  peak:              peak?,
+                  spoiled:           spoiled?,
+                  catalysts_applied: @catalysts_applied.uniq,
+                  age_minutes:       age,
+                  created_at:        @created_at.iso8601
+                }
+              end
+
+              private
+
+              def advance_stage!
+                @stage = STAGE_THRESHOLDS.each do |range, stage|
+                  break stage if range.cover?(@maturity)
+                end
+              end
+
+              def compute_potency
+                base = @potency
+                base += 0.02 if @stage == :peak
+                base -= OVER_FERMENTED_DECAY if @stage == :over_fermented
+                base.clamp(0.0, 1.0).round(10)
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/legion/extensions/agentic/learning/fermentation/runners/cognitive_fermentation.rb

@@ -0,0 +1,60 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module Agentic
+      module Learning
+        module Fermentation
+          module Runners
+            module CognitiveFermentation
+              include Legion::Extensions::Helpers::Lex if defined?(Legion::Extensions::Helpers::Lex)
+
+              def create_substrate(substrate_type:, domain:, content: '', potency: nil,
+                                   volatility: nil, engine: nil, **)
+                eng = engine || @default_engine
+                sub = eng.create_substrate(substrate_type: substrate_type, domain: domain,
+                                           content: content, potency: potency, volatility: volatility)
+                { success: true, substrate: sub.to_h }
+              end
+
+              def ferment(substrate_id:, rate: nil, engine: nil, **)
+                eng = engine || @default_engine
+                sub = eng.ferment(substrate_id: substrate_id,
+                                  rate:         rate || Helpers::Constants::MATURATION_RATE)
+                return { success: false, error: 'substrate not found' } unless sub
+
+                { success: true, substrate: sub.to_h }
+              end
+
+              def catalyze(substrate_id:, catalyst_type:, engine: nil, **)
+                eng = engine || @default_engine
+                sub = eng.catalyze(substrate_id: substrate_id, catalyst_type: catalyst_type)
+                return { success: false, error: 'substrate not found' } unless sub
+
+                { success: true, substrate: sub.to_h }
+              end
+
+              def ferment_all(rate: nil, engine: nil, **)
+                eng = engine || @default_engine
+                eng.ferment_all!(rate: rate || Helpers::Constants::MATURATION_RATE)
+                { success: true }
+              end
+
+              def list_ripe(engine: nil, **)
+                eng = engine || @default_engine
+                ripe = eng.ripe_substrates
+                { success: true, count: ripe.size, substrates: ripe.map(&:to_h) }
+              end
+
+              def fermentation_status(engine: nil, **)
+                eng = engine || @default_engine
+                report = eng.fermentation_report
+                { success: true, **report }
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

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

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

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+require 'securerandom'
+
+require_relative 'fermentation/version'
+require_relative 'fermentation/helpers/constants'
+require_relative 'fermentation/helpers/substrate'
+require_relative 'fermentation/helpers/batch'
+require_relative 'fermentation/helpers/fermentation_engine'
+require_relative 'fermentation/runners/cognitive_fermentation'
+require_relative 'fermentation/client'
+
+module Legion
+  module Extensions
+    module Agentic
+      module Learning
+        module Fermentation
+        end
+      end
+    end
+  end
+end