lex-agentic-inference 0.1.0

data/lib/legion/extensions/agentic/inference/gravity/helpers/gravity_engine.rb

@@ -0,0 +1,164 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module Agentic
+      module Inference
+        module Gravity
+          module Helpers
+            class GravityEngine
+              attr_reader :attractors, :orbiting_thoughts, :capture_events, :escape_events
+
+              def initialize
+                @attractors = {}
+                @orbiting_thoughts = {}
+                @capture_events   = []
+                @escape_events    = []
+              end
+
+              def add_attractor(content:, domain: :unknown, mass: Constants::DEFAULT_MASS,
+                                pull_radius: 1.0, decay_rate: 0.01)
+                return { error: :capacity_exceeded, max: Constants::MAX_ATTRACTORS } if at_attractor_capacity?
+
+                attractor = Attractor.new(
+                  content:     content,
+                  domain:      domain,
+                  mass:        mass,
+                  pull_radius: pull_radius,
+                  decay_rate:  decay_rate
+                )
+                @attractors[attractor.id] = attractor
+                attractor
+              end
+
+              def add_orbiting_thought(content:, attractor_id:, orbital_distance: 1.0, velocity: 0.0)
+                return { error: :attractor_not_found } unless @attractors.key?(attractor_id)
+                return { error: :capacity_exceeded, max: Constants::MAX_ORBITING } if at_orbiting_capacity?
+
+                thought = OrbitingThought.new(
+                  content:          content,
+                  attractor_id:     attractor_id,
+                  orbital_distance: orbital_distance,
+                  velocity:         velocity
+                )
+                @orbiting_thoughts[thought.id] = thought
+                thought
+              end
+
+              def simulate_tick
+                captures = []
+                escapes  = []
+
+                @attractors.each_value do |attractor|
+                  next if attractor.collapsed?
+
+                  thoughts_for(attractor.id).each do |thought|
+                    pull = attractor.pull_strength_at(distance: thought.orbital_distance)
+                    next unless pull.positive?
+
+                    was_captured = thought.captured?
+                    was_escaped  = thought.escaped?
+
+                    thought.approach!(pull)
+
+                    if !was_captured && thought.captured?
+                      event = build_event(:capture, attractor, thought)
+                      captures << event
+                      @capture_events << event
+                    end
+
+                    next unless !was_escaped && thought.escaped?
+
+                    event = build_event(:escape, attractor, thought)
+                    escapes << event
+                    @escape_events << event
+                  end
+                end
+
+                { captures: captures, escapes: escapes, tick_processed: true }
+              end
+
+              def accrete_attractor(attractor_id, amount: Constants::MASS_ACCRETION)
+                attractor = @attractors[attractor_id]
+                return { error: :not_found } unless attractor
+
+                attractor.accrete!(amount)
+                { accreted: true, id: attractor_id, mass: attractor.mass }
+              end
+
+              def erode_attractor(attractor_id, amount: Constants::MASS_EROSION)
+                attractor = @attractors[attractor_id]
+                return { error: :not_found } unless attractor
+
+                attractor.erode!(amount)
+                { eroded: true, id: attractor_id, mass: attractor.mass, collapsed: attractor.collapsed? }
+              end
+
+              def strongest_attractors(limit: 5)
+                @attractors.values
+                           .reject(&:collapsed?)
+                           .sort_by { |a| -a.mass }
+                           .first(limit)
+              end
+
+              def thought_distribution
+                @attractors.transform_values { |a| thoughts_for(a.id).size }
+              end
+
+              def cognitive_density_map
+                thought_distribution.transform_values do |count|
+                  Constants.label_for(Constants::DENSITY_LABELS, count)
+                end
+              end
+
+              def gravity_report
+                collapsed, active = @attractors.values.partition(&:collapsed?)
+                supermass = @attractors.values.select(&:supermassive?)
+                captured  = @orbiting_thoughts.values.select(&:captured?)
+                escaped   = @orbiting_thoughts.values.select(&:escaped?)
+
+                {
+                  total_attractors:     @attractors.size,
+                  active_attractors:    active.size,
+                  collapsed_attractors: collapsed.size,
+                  supermassive_count:   supermass.size,
+                  total_orbiting:       @orbiting_thoughts.size,
+                  captured_count:       captured.size,
+                  escaped_count:        escaped.size,
+                  total_captures:       @capture_events.size,
+                  total_escapes:        @escape_events.size,
+                  strongest:            strongest_attractors(limit: 3).map(&:to_h)
+                }
+              end
+
+              private
+
+              def thoughts_for(attractor_id)
+                @orbiting_thoughts.values.select { |t| t.attractor_id == attractor_id }
+              end
+
+              def at_attractor_capacity?
+                @attractors.size >= Constants::MAX_ATTRACTORS
+              end
+
+              def at_orbiting_capacity?
+                @orbiting_thoughts.size >= Constants::MAX_ORBITING
+              end
+
+              def build_event(type, attractor, thought)
+                {
+                  type:         type,
+                  attractor_id: attractor.id,
+                  thought_id:   thought.id,
+                  mass:         attractor.mass,
+                  distance:     thought.orbital_distance,
+                  at:           Time.now.utc
+                }
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/legion/extensions/agentic/inference/gravity/helpers/orbiting_thought.rb

@@ -0,0 +1,64 @@
+# frozen_string_literal: true
+
+require 'securerandom'
+
+module Legion
+  module Extensions
+    module Agentic
+      module Inference
+        module Gravity
+          module Helpers
+            class OrbitingThought
+              attr_reader :id, :content, :attractor_id, :orbital_distance, :velocity, :created_at
+
+              def initialize(content:, attractor_id:, orbital_distance: 1.0, velocity: 0.0)
+                @id               = SecureRandom.uuid
+                @content          = content
+                @attractor_id     = attractor_id
+                @orbital_distance = orbital_distance.clamp(0.0, Float::INFINITY).round(10)
+                @velocity         = velocity.to_f.round(10)
+                @created_at       = Time.now.utc
+              end
+
+              def approach!(delta)
+                @orbital_distance = [(@orbital_distance - delta.abs).round(10), 0.0].max
+                self
+              end
+
+              def escape!(delta)
+                @orbital_distance = (@orbital_distance + delta.abs).round(10)
+                self
+              end
+
+              def captured?
+                @orbital_distance < Constants::CAPTURE_RADIUS
+              end
+
+              def escaped?
+                @orbital_distance > Constants::ESCAPE_RADIUS
+              end
+
+              def orbit_label
+                Constants.label_for(Constants::ORBIT_LABELS, @orbital_distance)
+              end
+
+              def to_h
+                {
+                  id:               @id,
+                  content:          @content,
+                  attractor_id:     @attractor_id,
+                  orbital_distance: @orbital_distance,
+                  velocity:         @velocity,
+                  captured:         captured?,
+                  escaped:          escaped?,
+                  orbit_label:      orbit_label,
+                  created_at:       @created_at
+                }
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/legion/extensions/agentic/inference/gravity/runners/gravity.rb

@@ -0,0 +1,132 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module Agentic
+      module Inference
+        module Gravity
+          module Runners
+            module Gravity
+              include Legion::Extensions::Helpers::Lex if Legion::Extensions.const_defined?(:Helpers) &&
+                                                          Legion::Extensions::Helpers.const_defined?(:Lex)
+
+              def create_attractor(content:, domain: :unknown, mass: Helpers::Constants::DEFAULT_MASS,
+                                   pull_radius: 1.0, decay_rate: 0.01, engine: nil, **)
+                eng = engine || gravity_engine
+                unless Helpers::Constants.valid_domain?(domain)
+                  return { success: false, error: :invalid_domain,
+                           valid_domains: Helpers::Constants::ATTRACTOR_DOMAINS }
+                end
+
+                result = eng.add_attractor(
+                  content:     content,
+                  domain:      domain,
+                  mass:        mass,
+                  pull_radius: pull_radius,
+                  decay_rate:  decay_rate
+                )
+
+                if result.is_a?(Hash) && result[:error]
+                  Legion::Logging.warn "[cognitive_gravity] create_attractor failed: #{result[:error]}"
+                  return { success: false, **result }
+                end
+
+                Legion::Logging.debug "[cognitive_gravity] attractor created id=#{result.id[0..7]} " \
+                                      "domain=#{domain} mass=#{mass}"
+                { success: true, attractor: result.to_h }
+              end
+
+              def add_thought(content:, attractor_id:, orbital_distance: 1.0, velocity: 0.0,
+                              engine: nil, **)
+                eng = engine || gravity_engine
+                result = eng.add_orbiting_thought(
+                  content:          content,
+                  attractor_id:     attractor_id,
+                  orbital_distance: orbital_distance,
+                  velocity:         velocity
+                )
+
+                if result.is_a?(Hash) && result[:error]
+                  Legion::Logging.warn "[cognitive_gravity] add_thought failed: #{result[:error]}"
+                  return { success: false, **result }
+                end
+
+                Legion::Logging.debug "[cognitive_gravity] thought added id=#{result.id[0..7]} " \
+                                      "attractor=#{attractor_id[0..7]} distance=#{orbital_distance}"
+                { success: true, thought: result.to_h }
+              end
+
+              def tick_gravity(engine: nil, **)
+                eng = engine || gravity_engine
+                result = eng.simulate_tick
+                Legion::Logging.debug "[cognitive_gravity] tick: captures=#{result[:captures].size} " \
+                                      "escapes=#{result[:escapes].size}"
+                { success: true, **result }
+              end
+
+              def accrete(attractor_id:, amount: Helpers::Constants::MASS_ACCRETION, engine: nil, **)
+                eng = engine || gravity_engine
+                result = eng.accrete_attractor(attractor_id, amount: amount)
+
+                if result[:error]
+                  Legion::Logging.warn "[cognitive_gravity] accrete failed: #{result[:error]}"
+                  return { success: false, **result }
+                end
+
+                Legion::Logging.debug "[cognitive_gravity] accreted id=#{attractor_id[0..7]} mass=#{result[:mass]}"
+                { success: true, **result }
+              end
+
+              def erode(attractor_id:, amount: Helpers::Constants::MASS_EROSION, engine: nil, **)
+                eng = engine || gravity_engine
+                result = eng.erode_attractor(attractor_id, amount: amount)
+
+                if result[:error]
+                  Legion::Logging.warn "[cognitive_gravity] erode failed: #{result[:error]}"
+                  return { success: false, **result }
+                end
+
+                Legion::Logging.debug "[cognitive_gravity] eroded id=#{attractor_id[0..7]} " \
+                                      "mass=#{result[:mass]} collapsed=#{result[:collapsed]}"
+                { success: true, **result }
+              end
+
+              def strongest_attractors(limit: 5, engine: nil, **)
+                eng = engine || gravity_engine
+                attractors = eng.strongest_attractors(limit: limit)
+                Legion::Logging.debug "[cognitive_gravity] strongest_attractors count=#{attractors.size}"
+                { success: true, attractors: attractors.map(&:to_h), count: attractors.size }
+              end
+
+              def thought_distribution(engine: nil, **)
+                eng = engine || gravity_engine
+                distribution = eng.thought_distribution
+                { success: true, distribution: distribution }
+              end
+
+              def cognitive_density_map(engine: nil, **)
+                eng = engine || gravity_engine
+                density_map = eng.cognitive_density_map
+                { success: true, density_map: density_map }
+              end
+
+              def gravity_report(engine: nil, **)
+                eng = engine || gravity_engine
+                report = eng.gravity_report
+                Legion::Logging.debug "[cognitive_gravity] report: attractors=#{report[:total_attractors]} " \
+                                      "orbiting=#{report[:total_orbiting]} supermassive=#{report[:supermassive_count]}"
+                { success: true, report: report }
+              end
+
+              private
+
+              def gravity_engine
+                @gravity_engine ||= Helpers::GravityEngine.new
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/legion/extensions/agentic/inference/gravity/version.rb

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

data/lib/legion/extensions/agentic/inference/gravity.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+require 'legion/extensions/agentic/inference/gravity/version'
+require 'legion/extensions/agentic/inference/gravity/helpers/constants'
+require 'legion/extensions/agentic/inference/gravity/helpers/attractor'
+require 'legion/extensions/agentic/inference/gravity/helpers/orbiting_thought'
+require 'legion/extensions/agentic/inference/gravity/helpers/gravity_engine'
+require 'legion/extensions/agentic/inference/gravity/runners/gravity'
+require 'legion/extensions/agentic/inference/gravity/client'
+
+module Legion
+  module Extensions
+    module Agentic
+      module Inference
+        module Gravity
+        end
+      end
+    end
+  end
+end

data/lib/legion/extensions/agentic/inference/horizon/actors/adjust.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+require 'legion/extensions/actors/every'
+
+module Legion
+  module Extensions
+    module Agentic
+      module Inference
+        module Horizon
+          module Actor
+            class Adjust < Legion::Extensions::Actors::Every
+              def runner_class
+                Legion::Extensions::Agentic::Inference::Horizon::Runners::CognitiveHorizon
+              end
+
+              def runner_function
+                'horizon_status'
+              end
+
+              def time
+                60
+              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/inference/horizon/client.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+require 'legion/extensions/agentic/inference/horizon/helpers/constants'
+require 'legion/extensions/agentic/inference/horizon/helpers/projection'
+require 'legion/extensions/agentic/inference/horizon/helpers/horizon_engine'
+require 'legion/extensions/agentic/inference/horizon/runners/cognitive_horizon'
+
+module Legion
+  module Extensions
+    module Agentic
+      module Inference
+        module Horizon
+          class Client
+            include Runners::CognitiveHorizon
+
+            def initialize(**)
+              @horizon_engine = Helpers::HorizonEngine.new
+            end
+
+            private
+
+            attr_reader :horizon_engine
+          end
+        end
+      end
+    end
+  end
+end

data/lib/legion/extensions/agentic/inference/horizon/helpers/constants.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module Agentic
+      module Inference
+        module Horizon
+          module Helpers
+            module Constants
+              # Projection store limit
+              MAX_PROJECTIONS = 200
+
+              # Horizon values (0.0 = immediate, 1.0 = strategic)
+              DEFAULT_HORIZON    = 0.5
+              HORIZON_EXPAND     = 0.08
+              HORIZON_CONTRACT   = 0.1
+              MIN_HORIZON        = 0.1
+              MAX_HORIZON        = 1.0
+
+              # Stress adds additional contraction on top of HORIZON_CONTRACT
+              STRESS_CONTRACTION = 0.15
+
+              # Ordered horizon levels (near -> far)
+              HORIZON_LEVELS = %i[immediate near_term medium_term long_term strategic].freeze
+
+              # Construal labels keyed by range (horizon distance 0..1)
+              CONSTRUAL_LABELS = [
+                { range: (0.0...0.2),  label: :concrete },
+                { range: (0.2...0.4),  label: :detailed },
+                { range: (0.4...0.6),  label: :balanced },
+                { range: (0.6...0.8),  label: :schematic },
+                { range: (0.8..1.0),   label: :abstract }
+              ].freeze
+
+              # Confidence erodes by this much per step away from current horizon
+              CONFIDENCE_DECAY_PER_STEP = 0.1
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/legion/extensions/agentic/inference/horizon/helpers/horizon_engine.rb

@@ -0,0 +1,110 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module Agentic
+      module Inference
+        module Horizon
+          module Helpers
+            class HorizonEngine
+              attr_reader :projections, :current_horizon, :stress_level
+
+              def initialize(initial_horizon: Constants::DEFAULT_HORIZON)
+                @projections     = []
+                @current_horizon = initial_horizon.clamp(Constants::MIN_HORIZON, Constants::MAX_HORIZON)
+                @stress_level    = 0.0
+              end
+
+              def add_projection(description:, domain: :general, horizon_distance: nil, confidence: 1.0)
+                dist = horizon_distance || @current_horizon
+                proj = Projection.new(
+                  description:      description,
+                  domain:           domain,
+                  horizon_distance: dist,
+                  confidence:       confidence
+                )
+                @projections << proj
+                @projections = @projections.last(Constants::MAX_PROJECTIONS) if @projections.size > Constants::MAX_PROJECTIONS
+                proj
+              end
+
+              def expand_horizon!(amount: Constants::HORIZON_EXPAND)
+                @current_horizon = (@current_horizon + amount).clamp(Constants::MIN_HORIZON, Constants::MAX_HORIZON)
+                @current_horizon
+              end
+
+              def contract_horizon!(amount: Constants::HORIZON_CONTRACT)
+                @current_horizon = (@current_horizon - amount).clamp(Constants::MIN_HORIZON, Constants::MAX_HORIZON)
+                @current_horizon
+              end
+
+              def apply_stress!(level)
+                @stress_level = level.clamp(0.0, 1.0)
+                @current_horizon = (@current_horizon - (@stress_level * Constants::STRESS_CONTRACTION))
+                                   .clamp(Constants::MIN_HORIZON, Constants::MAX_HORIZON)
+                @current_horizon
+              end
+
+              def relieve_stress!(amount: 0.1)
+                @stress_level = (@stress_level - amount).clamp(0.0, 1.0)
+              end
+
+              def effective_horizon
+                (@current_horizon - (@stress_level * Constants::STRESS_CONTRACTION))
+                  .clamp(Constants::MIN_HORIZON, Constants::MAX_HORIZON)
+              end
+
+              def projections_within_horizon
+                eh = effective_horizon
+                @projections.select { |p| p.horizon_distance <= eh }
+              end
+
+              def beyond_horizon_projections
+                eh = effective_horizon
+                @projections.select { |p| p.horizon_distance > eh }
+              end
+
+              def nearest_projections(num: 5)
+                @projections.sort_by(&:horizon_distance).first(num)
+              end
+
+              def farthest_projections(num: 5)
+                @projections.sort_by(&:horizon_distance).last(num).reverse
+              end
+
+              def construal_label
+                dist = effective_horizon
+                entry = Constants::CONSTRUAL_LABELS.find { |e| e[:range].cover?(dist) }
+                entry ? entry[:label] : :balanced
+              end
+
+              def horizon_report
+                {
+                  current_horizon:   @current_horizon.round(10),
+                  stress_level:      @stress_level.round(10),
+                  effective_horizon: effective_horizon.round(10),
+                  construal_label:   construal_label,
+                  horizon_level:     horizon_level,
+                  total_projections: @projections.size,
+                  within_horizon:    projections_within_horizon.size,
+                  beyond_horizon:    beyond_horizon_projections.size
+                }
+              end
+
+              def to_h
+                horizon_report.merge(projections: @projections.map(&:to_h))
+              end
+
+              private
+
+              def horizon_level
+                idx = (effective_horizon * (Constants::HORIZON_LEVELS.size - 1)).round
+                Constants::HORIZON_LEVELS[idx.clamp(0, Constants::HORIZON_LEVELS.size - 1)]
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/legion/extensions/agentic/inference/horizon/helpers/projection.rb

@@ -0,0 +1,59 @@
+# frozen_string_literal: true
+
+require 'securerandom'
+
+module Legion
+  module Extensions
+    module Agentic
+      module Inference
+        module Horizon
+          module Helpers
+            class Projection
+              attr_reader :id, :description, :domain, :horizon_distance, :confidence, :construal_level, :created_at
+
+              def initialize(description:, domain: :general, horizon_distance: Constants::DEFAULT_HORIZON,
+                             confidence: 1.0, construal_level: nil)
+                @id               = SecureRandom.uuid
+                @description      = description
+                @domain           = domain
+                @horizon_distance = horizon_distance.clamp(0.0, 1.0)
+                @confidence       = confidence.clamp(0.0, 1.0)
+                @construal_level  = construal_level || derive_construal_level(@horizon_distance)
+                @created_at       = Time.now.utc
+              end
+
+              def concrete?
+                @horizon_distance <= 0.3
+              end
+
+              def abstract?
+                @horizon_distance >= 0.7
+              end
+
+              def to_h
+                {
+                  id:               @id,
+                  description:      @description,
+                  domain:           @domain,
+                  horizon_distance: @horizon_distance.round(10),
+                  confidence:       @confidence.round(10),
+                  construal_level:  @construal_level,
+                  concrete:         concrete?,
+                  abstract:         abstract?,
+                  created_at:       @created_at
+                }
+              end
+
+              private
+
+              def derive_construal_level(distance)
+                entry = Constants::CONSTRUAL_LABELS.find { |e| e[:range].cover?(distance) }
+                entry ? entry[:label] : :balanced
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end