lex-agentic-executive 0.1.0

data/lib/legion/extensions/agentic/executive/prospective_memory/runners/prospective_memory.rb

@@ -0,0 +1,146 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module Agentic
+      module Executive
+        module ProspectiveMemory
+          module Runners
+            module ProspectiveMemory
+              include Legion::Extensions::Helpers::Lex if Legion::Extensions.const_defined?(:Helpers) &&
+                                                          Legion::Extensions::Helpers.const_defined?(:Lex)
+
+              def create_intention(description:, trigger_type:, trigger_condition:,
+                                   urgency: Helpers::Constants::DEFAULT_URGENCY,
+                                   domain: nil, expires_at: nil, **)
+                unless Helpers::Constants::TRIGGER_TYPES.include?(trigger_type)
+                  return { error: :invalid_trigger_type, valid_types: Helpers::Constants::TRIGGER_TYPES }
+                end
+
+                intention = prospective_engine.create_intention(
+                  description:       description,
+                  trigger_type:      trigger_type,
+                  trigger_condition: trigger_condition,
+                  urgency:           urgency,
+                  domain:            domain,
+                  expires_at:        expires_at
+                )
+
+                Legion::Logging.debug "[prospective_memory] created intention id=#{intention.id[0..7]} " \
+                                      "type=#{trigger_type} urgency=#{intention.urgency.round(2)}"
+
+                { created: true, intention: intention.to_h }
+              end
+
+              def monitor_intention(intention_id:, **)
+                intention = prospective_engine.monitor_intention(intention_id: intention_id)
+                if intention
+                  Legion::Logging.debug "[prospective_memory] monitoring intention id=#{intention_id[0..7]}"
+                  { updated: true, intention: intention.to_h }
+                else
+                  { updated: false, reason: :not_found }
+                end
+              end
+
+              def trigger_intention(intention_id:, **)
+                intention = prospective_engine.trigger_intention(intention_id: intention_id)
+                if intention
+                  Legion::Logging.info "[prospective_memory] triggered intention id=#{intention_id[0..7]}"
+                  { updated: true, intention: intention.to_h }
+                else
+                  { updated: false, reason: :not_found }
+                end
+              end
+
+              def execute_intention(intention_id:, **)
+                intention = prospective_engine.execute_intention(intention_id: intention_id)
+                if intention
+                  Legion::Logging.info "[prospective_memory] executed intention id=#{intention_id[0..7]}"
+                  { updated: true, intention: intention.to_h }
+                else
+                  { updated: false, reason: :not_found }
+                end
+              end
+
+              def cancel_intention(intention_id:, **)
+                intention = prospective_engine.cancel_intention(intention_id: intention_id)
+                if intention
+                  Legion::Logging.debug "[prospective_memory] cancelled intention id=#{intention_id[0..7]}"
+                  { updated: true, intention: intention.to_h }
+                else
+                  { updated: false, reason: :not_found }
+                end
+              end
+
+              def check_expirations(**)
+                expired_count = prospective_engine.check_expirations
+                Legion::Logging.debug "[prospective_memory] expiration check expired=#{expired_count}"
+                { expired_count: expired_count }
+              end
+
+              def pending_intentions(**)
+                intentions = prospective_engine.pending_intentions
+                Legion::Logging.debug "[prospective_memory] pending count=#{intentions.size}"
+                { intentions: intentions.map(&:to_h), count: intentions.size }
+              end
+
+              def monitoring_intentions(**)
+                intentions = prospective_engine.monitoring_intentions
+                Legion::Logging.debug "[prospective_memory] monitoring count=#{intentions.size}"
+                { intentions: intentions.map(&:to_h), count: intentions.size }
+              end
+
+              def triggered_intentions(**)
+                intentions = prospective_engine.triggered_intentions
+                Legion::Logging.debug "[prospective_memory] triggered count=#{intentions.size}"
+                { intentions: intentions.map(&:to_h), count: intentions.size }
+              end
+
+              def intentions_by_domain(domain:, **)
+                intentions = prospective_engine.by_domain(domain: domain)
+                Legion::Logging.debug "[prospective_memory] by_domain domain=#{domain} count=#{intentions.size}"
+                { intentions: intentions.map(&:to_h), count: intentions.size, domain: domain }
+              end
+
+              def intentions_by_urgency(min_urgency: 0.5, **)
+                intentions = prospective_engine.by_urgency(min_urgency: min_urgency)
+                Legion::Logging.debug "[prospective_memory] by_urgency min=#{min_urgency} count=#{intentions.size}"
+                { intentions: intentions.map(&:to_h), count: intentions.size }
+              end
+
+              def most_urgent_intentions(limit: 5, **)
+                intentions = prospective_engine.most_urgent(limit: limit)
+                Legion::Logging.debug "[prospective_memory] most_urgent limit=#{limit} found=#{intentions.size}"
+                { intentions: intentions.map(&:to_h), count: intentions.size }
+              end
+
+              def decay_urgency(**)
+                prospective_engine.decay_all_urgency
+                Legion::Logging.debug '[prospective_memory] urgency decay cycle complete'
+                { decayed: true }
+              end
+
+              def execution_rate(**)
+                rate = prospective_engine.execution_rate
+                Legion::Logging.debug "[prospective_memory] execution_rate=#{rate.round(4)}"
+                { execution_rate: rate }
+              end
+
+              def intention_report(**)
+                report = prospective_engine.intention_report
+                Legion::Logging.debug "[prospective_memory] report total=#{report[:total]}"
+                report
+              end
+
+              private
+
+              def prospective_engine
+                @prospective_engine ||= Helpers::ProspectiveEngine.new
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/legion/extensions/agentic/executive/prospective_memory/version.rb

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

data/lib/legion/extensions/agentic/executive/prospective_memory.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+require 'legion/extensions/agentic/executive/prospective_memory/version'
+require 'legion/extensions/agentic/executive/prospective_memory/helpers/constants'
+require 'legion/extensions/agentic/executive/prospective_memory/helpers/intention'
+require 'legion/extensions/agentic/executive/prospective_memory/helpers/prospective_engine'
+require 'legion/extensions/agentic/executive/prospective_memory/runners/prospective_memory'
+require 'legion/extensions/agentic/executive/prospective_memory/client'
+
+module Legion
+  module Extensions
+    module Agentic
+      module Executive
+        module ProspectiveMemory
+        end
+      end
+    end
+  end
+end

data/lib/legion/extensions/agentic/executive/triage/client.rb

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

data/lib/legion/extensions/agentic/executive/triage/helpers/constants.rb

@@ -0,0 +1,70 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module Agentic
+      module Executive
+        module Triage
+          module Helpers
+            module Constants
+              MAX_DEMANDS      = 500
+              MAX_QUEUE_SIZE   = 100
+              CAPACITY_DEFAULT = 1.0
+              CAPACITY_DRAIN   = 0.05
+              CAPACITY_RESTORE = 0.03
+              OVERLOAD_THRESHOLD = 0.2
+
+              SEVERITY_LEVELS = %i[critical major moderate minor trivial].freeze
+              URGENCY_LEVELS  = %i[immediate urgent soon deferred indefinite].freeze
+
+              SEVERITY_WEIGHTS = {
+                critical: 1.0,
+                major:    0.8,
+                moderate: 0.5,
+                minor:    0.3,
+                trivial:  0.1
+              }.freeze
+
+              URGENCY_WEIGHTS = {
+                immediate:  1.0,
+                urgent:     0.8,
+                soon:       0.5,
+                deferred:   0.3,
+                indefinite: 0.1
+              }.freeze
+
+              TRIAGE_LABELS = {
+                (0.8..)     => :red,
+                (0.6...0.8) => :orange,
+                (0.4...0.6) => :yellow,
+                (0.2...0.4) => :green,
+                (..0.2)     => :white
+              }.freeze
+
+              CAPACITY_LABELS = {
+                (0.8..)     => :fresh,
+                (0.6...0.8) => :engaged,
+                (0.4...0.6) => :strained,
+                (0.2...0.4) => :depleted,
+                (..0.2)     => :overloaded
+              }.freeze
+
+              QUEUE_LABELS = {
+                (0.8..)     => :overwhelmed,
+                (0.6...0.8) => :heavy,
+                (0.4...0.6) => :moderate,
+                (0.2...0.4) => :light,
+                (..0.2)     => :empty
+              }.freeze
+
+              def self.label_for(labels, value)
+                match = labels.find { |range, _| range.cover?(value) }
+                match&.last
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/legion/extensions/agentic/executive/triage/helpers/demand.rb

@@ -0,0 +1,101 @@
+# frozen_string_literal: true
+
+require 'securerandom'
+
+module Legion
+  module Extensions
+    module Agentic
+      module Executive
+        module Triage
+          module Helpers
+            class Demand
+              include Constants
+
+              attr_reader :id, :description, :domain, :severity, :urgency,
+                          :triage_score, :status, :created_at, :triaged_at
+
+              def initialize(description:, domain: :general, severity: :moderate, urgency: :soon)
+                @id           = SecureRandom.uuid
+                @description  = description
+                @domain       = domain.to_sym
+                @severity     = validate_level(severity, SEVERITY_LEVELS, :moderate)
+                @urgency      = validate_level(urgency, URGENCY_LEVELS, :soon)
+                @triage_score = compute_triage_score
+                @status       = :pending
+                @created_at   = Time.now.utc
+                @triaged_at   = nil
+              end
+
+              def triage!
+                @status = :triaged
+                @triaged_at = Time.now.utc
+                self
+              end
+
+              def defer!
+                @status = :deferred
+                self
+              end
+
+              def process!
+                @status = :processing
+                self
+              end
+
+              def complete!
+                @status = :completed
+                self
+              end
+
+              def drop!
+                @status = :dropped
+                self
+              end
+
+              def active?
+                %i[pending triaged processing].include?(@status)
+              end
+
+              def triage_label
+                Constants.label_for(TRIAGE_LABELS, @triage_score)
+              end
+
+              def red?
+                @triage_score >= 0.8
+              end
+
+              def to_h
+                {
+                  id:           @id,
+                  description:  @description,
+                  domain:       @domain,
+                  severity:     @severity,
+                  urgency:      @urgency,
+                  triage_score: @triage_score,
+                  triage_label: triage_label,
+                  status:       @status,
+                  red:          red?,
+                  created_at:   @created_at,
+                  triaged_at:   @triaged_at
+                }
+              end
+
+              private
+
+              def validate_level(level, valid_levels, default)
+                sym = level.to_sym
+                valid_levels.include?(sym) ? sym : default
+              end
+
+              def compute_triage_score
+                sev = SEVERITY_WEIGHTS.fetch(@severity, 0.5)
+                urg = URGENCY_WEIGHTS.fetch(@urgency, 0.5)
+                ((sev * 0.6) + (urg * 0.4)).round(10)
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/legion/extensions/agentic/executive/triage/helpers/triage_engine.rb

@@ -0,0 +1,150 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module Agentic
+      module Executive
+        module Triage
+          module Helpers
+            class TriageEngine
+              include Constants
+
+              attr_reader :capacity
+
+              def initialize
+                @demands  = {}
+                @capacity = CAPACITY_DEFAULT
+              end
+
+              def add_demand(description:, domain: :general, severity: :moderate, urgency: :soon)
+                prune_if_needed
+                demand = Demand.new(
+                  description: description, domain: domain, severity: severity, urgency: urgency
+                )
+                @demands[demand.id] = demand
+                drain_capacity!(demand.triage_score * CAPACITY_DRAIN)
+                demand.triage!
+                demand
+              end
+
+              def process_demand(demand_id:)
+                demand = @demands[demand_id]
+                return nil unless demand&.active?
+
+                demand.process!
+                demand
+              end
+
+              def complete_demand(demand_id:)
+                demand = @demands[demand_id]
+                return nil unless demand
+
+                demand.complete!
+                restore_capacity!(CAPACITY_RESTORE)
+                demand
+              end
+
+              def defer_demand(demand_id:)
+                demand = @demands[demand_id]
+                return nil unless demand&.active?
+
+                demand.defer!
+                restore_capacity!(CAPACITY_RESTORE * 0.5)
+                demand
+              end
+
+              def drop_demand(demand_id:)
+                demand = @demands[demand_id]
+                return nil unless demand&.active?
+
+                demand.drop!
+                restore_capacity!(CAPACITY_RESTORE)
+                demand
+              end
+
+              def next_demand
+                active_demands.max_by(&:triage_score)
+              end
+
+              def active_demands = @demands.values.select(&:active?)
+              def red_demands = @demands.values.select(&:red?)
+              def completed_demands = @demands.values.select { |d| d.status == :completed }
+              def dropped_demands = @demands.values.select { |d| d.status == :dropped }
+              def deferred_demands = @demands.values.select { |d| d.status == :deferred }
+
+              def demands_by_severity(severity:)
+                @demands.values.select { |d| d.severity == severity.to_sym }
+              end
+
+              def demands_by_domain(domain:)
+                @demands.values.select { |d| d.domain == domain.to_sym }
+              end
+
+              def overloaded?
+                @capacity <= OVERLOAD_THRESHOLD
+              end
+
+              def queue_pressure
+                return 0.0 if @demands.empty?
+
+                (active_demands.size.to_f / MAX_QUEUE_SIZE).clamp(0.0, 1.0).round(10)
+              end
+
+              def capacity_label = Constants.label_for(CAPACITY_LABELS, @capacity)
+              def queue_label = Constants.label_for(QUEUE_LABELS, queue_pressure)
+
+              def restore_capacity!(amount = CAPACITY_RESTORE)
+                @capacity = (@capacity + amount).clamp(0.0, 1.0).round(10)
+                self
+              end
+
+              def triage_report
+                {
+                  total_demands:  @demands.size,
+                  active_count:   active_demands.size,
+                  red_count:      red_demands.size,
+                  completed:      completed_demands.size,
+                  dropped:        dropped_demands.size,
+                  deferred:       deferred_demands.size,
+                  capacity:       @capacity,
+                  capacity_label: capacity_label,
+                  overloaded:     overloaded?,
+                  queue_pressure: queue_pressure,
+                  queue_label:    queue_label,
+                  next_demand:    next_demand&.to_h
+                }
+              end
+
+              def to_h
+                {
+                  total_demands: @demands.size,
+                  active:        active_demands.size,
+                  capacity:      @capacity,
+                  overloaded:    overloaded?
+                }
+              end
+
+              private
+
+              def drain_capacity!(amount)
+                @capacity = (@capacity - amount).clamp(0.0, 1.0).round(10)
+              end
+
+              def prune_if_needed
+                return if @demands.size < MAX_DEMANDS
+
+                oldest_completed = completed_demands.min_by(&:created_at)
+                if oldest_completed
+                  @demands.delete(oldest_completed.id)
+                else
+                  lowest = @demands.values.min_by(&:triage_score)
+                  @demands.delete(lowest.id) if lowest
+                end
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/legion/extensions/agentic/executive/triage/runners/cognitive_triage.rb

@@ -0,0 +1,110 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module Agentic
+      module Executive
+        module Triage
+          module Runners
+            module CognitiveTriage
+              include Legion::Extensions::Helpers::Lex if defined?(Legion::Extensions::Helpers::Lex)
+
+              def add_demand(description:, domain: :general, severity: :moderate, urgency: :soon, engine: nil, **)
+                eng = engine || default_engine
+                demand = eng.add_demand(
+                  description: description, domain: domain, severity: severity, urgency: urgency
+                )
+                { success: true, demand: demand.to_h, capacity: eng.capacity }
+              end
+
+              def process_demand(demand_id:, engine: nil, **)
+                eng = engine || default_engine
+                demand = eng.process_demand(demand_id: demand_id)
+                return { success: false, error: 'demand not found or not active' } unless demand
+
+                { success: true, demand: demand.to_h }
+              end
+
+              def complete_demand(demand_id:, engine: nil, **)
+                eng = engine || default_engine
+                demand = eng.complete_demand(demand_id: demand_id)
+                return { success: false, error: 'demand not found' } unless demand
+
+                { success: true, demand: demand.to_h, capacity: eng.capacity }
+              end
+
+              def defer_demand(demand_id:, engine: nil, **)
+                eng = engine || default_engine
+                demand = eng.defer_demand(demand_id: demand_id)
+                return { success: false, error: 'demand not found or not active' } unless demand
+
+                { success: true, demand: demand.to_h, capacity: eng.capacity }
+              end
+
+              def drop_demand(demand_id:, engine: nil, **)
+                eng = engine || default_engine
+                demand = eng.drop_demand(demand_id: demand_id)
+                return { success: false, error: 'demand not found or not active' } unless demand
+
+                { success: true, demand: demand.to_h, capacity: eng.capacity }
+              end
+
+              def next_demand(engine: nil, **)
+                eng = engine || default_engine
+                demand = eng.next_demand
+                return { success: true, found: false } unless demand
+
+                { success: true, found: true, demand: demand.to_h }
+              end
+
+              def active_demands(engine: nil, **)
+                eng = engine || default_engine
+                { success: true, demands: eng.active_demands.map(&:to_h), count: eng.active_demands.size }
+              end
+
+              def red_demands(engine: nil, **)
+                eng = engine || default_engine
+                { success: true, demands: eng.red_demands.map(&:to_h), count: eng.red_demands.size }
+              end
+
+              def demands_by_severity(severity:, engine: nil, **)
+                eng = engine || default_engine
+                demands = eng.demands_by_severity(severity: severity)
+                { success: true, demands: demands.map(&:to_h), count: demands.size }
+              end
+
+              def demands_by_domain(domain:, engine: nil, **)
+                eng = engine || default_engine
+                demands = eng.demands_by_domain(domain: domain)
+                { success: true, demands: demands.map(&:to_h), count: demands.size }
+              end
+
+              def capacity_status(engine: nil, **)
+                eng = engine || default_engine
+                {
+                  success:        true,
+                  capacity:       eng.capacity,
+                  capacity_label: eng.capacity_label,
+                  overloaded:     eng.overloaded?,
+                  queue_pressure: eng.queue_pressure,
+                  queue_label:    eng.queue_label
+                }
+              end
+
+              def triage_report(engine: nil, **)
+                eng = engine || default_engine
+                { success: true, report: eng.triage_report }
+              end
+
+              private
+
+              def default_engine
+                @default_engine ||= Helpers::TriageEngine.new
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/legion/extensions/agentic/executive/triage/version.rb

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

data/lib/legion/extensions/agentic/executive/triage.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+require_relative 'triage/version'
+require_relative 'triage/helpers/constants'
+require_relative 'triage/helpers/demand'
+require_relative 'triage/helpers/triage_engine'
+require_relative 'triage/runners/cognitive_triage'
+require_relative 'triage/client'
+
+module Legion
+  module Extensions
+    module Agentic
+      module Executive
+        module Triage
+        end
+      end
+    end
+  end
+end

data/lib/legion/extensions/agentic/executive/version.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module Agentic
+      module Executive
+        VERSION = '0.1.0'
+      end
+    end
+  end
+end