lex-agentic-integration 0.1.0

data/lib/legion/extensions/agentic/integration/situation_model/helpers/situation_engine.rb

@@ -0,0 +1,73 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module Agentic
+      module Integration
+        module SituationModel
+          module Helpers
+            class SituationEngine
+              include Constants
+
+              def initialize
+                @models = {}
+              end
+
+              def create_model(label:)
+                model = SituationModel.new(label: label)
+                @models[model.id] = model
+                model
+              end
+
+              def add_event_to_model(model_id:, content:, dimension_values: {})
+                model = @models[model_id]
+                return nil unless model
+
+                event = SituationEvent.new(content: content, dimension_values: dimension_values)
+                model.add_event(event)
+                event
+              end
+
+              def model_coherence(model_id:)
+                @models[model_id]&.coherence
+              end
+
+              def find_boundaries(model_id:, threshold: 0.3)
+                @models[model_id]&.event_boundaries(threshold: threshold)
+              end
+
+              def dimension_trajectory(model_id:, dimension:)
+                @models[model_id]&.dimension_trajectory(dimension)
+              end
+
+              def most_coherent(limit: 5)
+                @models.values
+                       .sort_by { |m| -m.coherence }
+                       .first(limit)
+              end
+
+              def models_by_label(label:)
+                @models.values.select { |m| m.label == label }
+              end
+
+              def decay_all
+                @models.each_value(&:decay!)
+              end
+
+              def prune_collapsed
+                @models.delete_if { |_, m| m.coherence <= 0.1 }
+              end
+
+              def to_h
+                {
+                  model_count: @models.size,
+                  models:      @models.values.map(&:to_h)
+                }
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/legion/extensions/agentic/integration/situation_model/helpers/situation_event.rb

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module Agentic
+      module Integration
+        module SituationModel
+          module Helpers
+            class SituationEvent
+              include Constants
+
+              attr_reader :content, :dimension_values, :created_at
+
+              def initialize(content:, dimension_values: {})
+                @content          = content
+                @dimension_values = build_dimension_values(dimension_values)
+                @created_at       = Time.now.utc
+              end
+
+              def continuity_with(other_event)
+                total_diff = DIMENSIONS.sum do |dim|
+                  (dimension_values[dim] - other_event.dimension_values[dim]).abs
+                end
+                avg_diff = total_diff / DIMENSIONS.size.to_f
+                1.0 - avg_diff
+              end
+
+              def discontinuous_dimensions(other_event, threshold: 0.3)
+                DIMENSIONS.select do |dim|
+                  (dimension_values[dim] - other_event.dimension_values[dim]).abs > threshold
+                end
+              end
+
+              def to_h
+                {
+                  content:          content,
+                  dimension_values: dimension_values,
+                  created_at:       created_at.iso8601
+                }
+              end
+
+              private
+
+              def build_dimension_values(values)
+                DIMENSIONS.to_h do |dim|
+                  raw = values.fetch(dim, DEFAULT_DIMENSION_VALUE)
+                  [dim, raw.clamp(0.0, 1.0)]
+                end
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/legion/extensions/agentic/integration/situation_model/helpers/situation_model.rb

@@ -0,0 +1,90 @@
+# frozen_string_literal: true
+
+require 'securerandom'
+
+module Legion
+  module Extensions
+    module Agentic
+      module Integration
+        module SituationModel
+          module Helpers
+            class SituationModel
+              include Constants
+
+              attr_reader :id, :label, :events, :current_state, :created_at, :last_updated_at
+
+              def initialize(label:)
+                @id             = SecureRandom.uuid
+                @label          = label
+                @events         = []
+                @current_state  = DIMENSIONS.to_h { |dim| [dim, DEFAULT_DIMENSION_VALUE] }
+                @created_at     = Time.now.utc
+                @last_updated_at = Time.now.utc
+              end
+
+              def add_event(event)
+                previous = events.last
+                events << event
+                @current_state   = event.dimension_values.dup
+                @last_updated_at = Time.now.utc
+                previous ? event.continuity_with(previous) : 1.0
+              end
+
+              def coherence
+                return 1.0 if events.size <= 1
+
+                pairs = events.each_cons(2).to_a
+                total = pairs.sum { |a, b| b.continuity_with(a) }
+                (total / pairs.size.to_f).clamp(COHERENCE_FLOOR, COHERENCE_CEILING)
+              end
+
+              def health_label
+                c = coherence
+                MODEL_HEALTH_LABELS.find { |range, _| range.cover?(c) }&.last || :collapsed
+              end
+
+              def dominant_dimension
+                current_state.max_by { |_, v| v }&.first
+              end
+
+              def weakest_dimension
+                current_state.min_by { |_, v| v }&.first
+              end
+
+              def event_boundaries(threshold: 0.3)
+                indices = []
+                events.each_cons(2).with_index do |(a, b), idx|
+                  indices << (idx + 1) unless b.discontinuous_dimensions(a, threshold: threshold).empty?
+                end
+                indices
+              end
+
+              def dimension_trajectory(dimension)
+                events.map { |e| e.dimension_values[dimension] }
+              end
+
+              def decay!
+                DIMENSIONS.each do |dim|
+                  current_state[dim] = (current_state[dim] - DECAY_RATE).clamp(COHERENCE_FLOOR, COHERENCE_CEILING)
+                end
+              end
+
+              def to_h
+                {
+                  id:              id,
+                  label:           label,
+                  event_count:     events.size,
+                  current_state:   current_state,
+                  coherence:       coherence,
+                  health_label:    health_label,
+                  created_at:      created_at.iso8601,
+                  last_updated_at: last_updated_at.iso8601
+                }
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/legion/extensions/agentic/integration/situation_model/runners/situation_model.rb

@@ -0,0 +1,99 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module Agentic
+      module Integration
+        module SituationModel
+          module Runners
+            module SituationModel
+              include Legion::Extensions::Helpers::Lex if Legion::Extensions.const_defined?(:Helpers) &&
+                                                          Legion::Extensions::Helpers.const_defined?(:Lex)
+
+              def create_situation_model(label:, **)
+                model = engine.create_model(label: label)
+                Legion::Logging.debug "[situation_model] create_model: id=#{model.id} label=#{label}"
+                { success: true, model: model.to_h }
+              end
+
+              def add_situation_event(model_id:, content:, **opts)
+                dim_values = {
+                  space:          opts.fetch(:space, 0.5),
+                  time:           opts.fetch(:time, 0.5),
+                  causation:      opts.fetch(:causation, 0.5),
+                  intentionality: opts.fetch(:intentionality, 0.5),
+                  protagonist:    opts.fetch(:protagonist, 0.5)
+                }
+                event = engine.add_event_to_model(model_id: model_id, content: content, dimension_values: dim_values)
+                unless event
+                  Legion::Logging.debug "[situation_model] add_event: model_id=#{model_id} not found"
+                  return { success: false, error: 'model not found' }
+                end
+
+                coherence = engine.model_coherence(model_id: model_id)
+                Legion::Logging.debug "[situation_model] add_event: model_id=#{model_id} coherence=#{coherence.round(3)}"
+                { success: true, event: event.to_h, coherence: coherence }
+              end
+
+              def situation_model_coherence(model_id:, **)
+                coherence = engine.model_coherence(model_id: model_id)
+                Legion::Logging.debug "[situation_model] coherence: model_id=#{model_id} value=#{coherence}"
+                return { success: false, error: 'model not found' } if coherence.nil?
+
+                { success: true, model_id: model_id, coherence: coherence }
+              end
+
+              def find_situation_boundaries(model_id:, threshold: 0.3, **)
+                boundaries = engine.find_boundaries(model_id: model_id, threshold: threshold)
+                Legion::Logging.debug "[situation_model] boundaries: model_id=#{model_id} count=#{boundaries&.size}"
+                return { success: false, error: 'model not found' } if boundaries.nil?
+
+                { success: true, model_id: model_id, boundaries: boundaries, threshold: threshold }
+              end
+
+              def situation_dimension_trajectory(model_id:, dimension:, **)
+                dim = dimension.to_sym
+                trajectory = engine.dimension_trajectory(model_id: model_id, dimension: dim)
+                Legion::Logging.debug "[situation_model] trajectory: model_id=#{model_id} dimension=#{dim} points=#{trajectory&.size}"
+                return { success: false, error: 'model not found' } if trajectory.nil?
+
+                { success: true, model_id: model_id, dimension: dim, trajectory: trajectory }
+              end
+
+              def most_coherent_situations(limit: 5, **)
+                models = engine.most_coherent(limit: limit)
+                Legion::Logging.debug "[situation_model] most_coherent: limit=#{limit} found=#{models.size}"
+                { success: true, models: models.map(&:to_h), count: models.size }
+              end
+
+              def situations_by_label(label:, **)
+                models = engine.models_by_label(label: label)
+                Legion::Logging.debug "[situation_model] by_label: label=#{label} found=#{models.size}"
+                { success: true, label: label, models: models.map(&:to_h), count: models.size }
+              end
+
+              def update_situation_models(**)
+                engine.decay_all
+                pruned = engine.prune_collapsed
+                Legion::Logging.debug "[situation_model] update: decay_all pruned=#{pruned.size}"
+                { success: true, pruned_count: pruned.size }
+              end
+
+              def situation_model_stats(**)
+                stats = engine.to_h
+                Legion::Logging.debug "[situation_model] stats: model_count=#{stats[:model_count]}"
+                { success: true, **stats }
+              end
+
+              private
+
+              def engine
+                @engine ||= Helpers::SituationEngine.new
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/legion/extensions/agentic/integration/situation_model/version.rb

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

data/lib/legion/extensions/agentic/integration/situation_model.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+require 'legion/extensions/agentic/integration/situation_model/version'
+require 'legion/extensions/agentic/integration/situation_model/helpers/constants'
+require 'legion/extensions/agentic/integration/situation_model/helpers/situation_event'
+require 'legion/extensions/agentic/integration/situation_model/helpers/situation_model'
+require 'legion/extensions/agentic/integration/situation_model/helpers/situation_engine'
+require 'legion/extensions/agentic/integration/situation_model/runners/situation_model'
+require 'legion/extensions/agentic/integration/situation_model/helpers/client'
+require 'legion/extensions/agentic/integration/situation_model/client'
+
+module Legion
+  module Extensions
+    module Agentic
+      module Integration
+        module SituationModel
+        end
+      end
+    end
+  end
+end

data/lib/legion/extensions/agentic/integration/synthesis/client.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+require 'legion/extensions/agentic/integration/synthesis/helpers/constants'
+require 'legion/extensions/agentic/integration/synthesis/helpers/synthesis_stream'
+require 'legion/extensions/agentic/integration/synthesis/helpers/synthesis'
+require 'legion/extensions/agentic/integration/synthesis/helpers/synthesis_engine'
+require 'legion/extensions/agentic/integration/synthesis/runners/cognitive_synthesis'
+
+module Legion
+  module Extensions
+    module Agentic
+      module Integration
+        module Synthesis
+          class Client
+            include Runners::CognitiveSynthesis
+
+            def initialize(engine: nil, **)
+              @synthesis_engine = engine || Helpers::SynthesisEngine.new
+            end
+
+            private
+
+            attr_reader :synthesis_engine
+          end
+        end
+      end
+    end
+  end
+end

data/lib/legion/extensions/agentic/integration/synthesis/helpers/constants.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module Agentic
+      module Integration
+        module Synthesis
+          module Helpers
+            module Constants
+              MAX_STREAMS             = 50
+              MAX_SYNTHESES           = 200
+              DEFAULT_WEIGHT          = 0.5
+              COHERENCE_THRESHOLD     = 0.6
+              NOVELTY_THRESHOLD       = 0.7
+              FRESHNESS_DECAY         = 0.02
+              MIN_STREAMS_FOR_SYNTHESIS = 2
+
+              STREAM_TYPES = %i[emotional perceptual memorial predictive reasoning social identity motor].freeze
+
+              COHERENCE_LABELS = {
+                (0.8..)     => :unified,
+                (0.6...0.8) => :coherent,
+                (0.4...0.6) => :fragmented,
+                (0.2...0.4) => :dissonant,
+                (..0.2)     => :chaotic
+              }.freeze
+
+              CONFIDENCE_LABELS = {
+                (0.8..)     => :certain,
+                (0.6...0.8) => :confident,
+                (0.4...0.6) => :uncertain,
+                (0.2...0.4) => :doubtful,
+                (..0.2)     => :guessing
+              }.freeze
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/legion/extensions/agentic/integration/synthesis/helpers/synthesis.rb

@@ -0,0 +1,63 @@
+# frozen_string_literal: true
+
+require 'securerandom'
+
+module Legion
+  module Extensions
+    module Agentic
+      module Integration
+        module Synthesis
+          module Helpers
+            class Synthesis
+              include Constants
+
+              attr_reader :id, :streams, :coherence, :novelty, :confidence, :content, :created_at
+
+              def initialize(streams:, coherence:, novelty:, confidence:, content:)
+                @id         = SecureRandom.uuid
+                @streams    = streams
+                @coherence  = coherence.clamp(0.0, 1.0)
+                @novelty    = novelty.clamp(0.0, 1.0)
+                @confidence = confidence.clamp(0.0, 1.0)
+                @content    = content
+                @created_at = Time.now.utc
+              end
+
+              def fragmented?
+                @coherence < COHERENCE_THRESHOLD
+              end
+
+              def novel?
+                @novelty > NOVELTY_THRESHOLD
+              end
+
+              def coherence_label
+                COHERENCE_LABELS.find { |range, _| range.cover?(@coherence) }&.last || :chaotic
+              end
+
+              def confidence_label
+                CONFIDENCE_LABELS.find { |range, _| range.cover?(@confidence) }&.last || :guessing
+              end
+
+              def to_h
+                {
+                  id:               @id,
+                  streams:          @streams,
+                  coherence:        @coherence,
+                  novelty:          @novelty,
+                  confidence:       @confidence,
+                  content:          @content,
+                  fragmented:       fragmented?,
+                  novel:            novel?,
+                  coherence_label:  coherence_label,
+                  confidence_label: confidence_label,
+                  created_at:       @created_at
+                }
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end