lex-agentic-integration 0.1.0

data/lib/legion/extensions/agentic/integration/tessellation/helpers/tessellation_engine.rb

@@ -0,0 +1,141 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module Agentic
+      module Integration
+        module Tessellation
+          module Helpers
+            class TessellationEngine
+              include Constants
+
+              def initialize
+                @tiles   = {}
+                @mosaics = {}
+              end
+
+              def create_tile(tile_type:, shape:, domain:, coverage: nil, fit_score: nil)
+                tile = Tile.new(tile_type: tile_type, shape: shape, domain: domain,
+                                coverage: coverage, fit_score: fit_score)
+                @tiles[tile.id] = tile
+                mosaic = find_or_create_mosaic(domain: domain)
+                mosaic.add_tile(tile)
+                prune_tiles
+                tile
+              end
+
+              def expand_tile(tile_id:, amount: COVERAGE_GROWTH)
+                tile = @tiles[tile_id]
+                return nil unless tile
+
+                tile.expand!(amount)
+                tile
+              end
+
+              def shrink_all!
+                @tiles.each_value { |t| t.shrink!(COVERAGE_DECAY) }
+              end
+
+              def connect_tiles(tile_a_id:, tile_b_id:)
+                a = @tiles[tile_a_id]
+                b = @tiles[tile_b_id]
+                return nil unless a && b
+
+                a.connect!(b.id)
+                b.connect!(a.id)
+                { connected: true, tile_a: a.id, tile_b: b.id }
+              end
+
+              def tiles_by_domain(domain:) = @tiles.values.select { |t| t.domain == domain.to_sym }
+              def tiles_by_type(tile_type:) = @tiles.values.select { |t| t.tile_type == tile_type.to_sym }
+              def tiles_by_shape(shape:) = @tiles.values.select { |t| t.shape == shape.to_sym }
+              def gapped_tiles = @tiles.values.select(&:gapped?)
+              def seamless_tiles = @tiles.values.select(&:seamless?)
+              def isolated_tiles = @tiles.values.select(&:isolated?)
+              def full_coverage_tiles = @tiles.values.select(&:full_coverage?)
+
+              def overall_coverage
+                return 0.0 if @mosaics.empty?
+
+                (@mosaics.values.sum(&:total_coverage) / @mosaics.size).round(10)
+              end
+
+              def overall_fit
+                return 0.0 if @tiles.empty?
+
+                (@tiles.values.sum(&:fit_score) / @tiles.size).round(10)
+              end
+
+              def overall_coherence
+                return 0.0 if @mosaics.empty?
+
+                (@mosaics.values.sum(&:coherence) / @mosaics.size).round(10)
+              end
+
+              def domain_coverage
+                @mosaics.transform_values(&:total_coverage)
+              end
+
+              def gap_density
+                return 0.0 if @tiles.empty?
+
+                (gapped_tiles.size.to_f / @tiles.size).round(10)
+              end
+
+              def most_covered(limit: 5)
+                @tiles.values.sort_by { |t| -t.effective_coverage }.first(limit)
+              end
+
+              def least_covered(limit: 5)
+                @tiles.values.sort_by(&:effective_coverage).first(limit)
+              end
+
+              def tessellation_report
+                {
+                  total_tiles:       @tiles.size,
+                  total_mosaics:     @mosaics.size,
+                  overall_coverage:  overall_coverage,
+                  coverage_label:    Constants.label_for(COVERAGE_LABELS, overall_coverage),
+                  overall_fit:       overall_fit,
+                  fit_label:         Constants.label_for(FIT_LABELS, overall_fit),
+                  overall_coherence: overall_coherence,
+                  gap_density:       gap_density,
+                  gapped_count:      gapped_tiles.size,
+                  seamless_count:    seamless_tiles.size,
+                  isolated_count:    isolated_tiles.size,
+                  domain_coverage:   domain_coverage,
+                  mosaics:           @mosaics.values.map(&:to_h)
+                }
+              end
+
+              def to_h
+                {
+                  total_tiles:   @tiles.size,
+                  total_mosaics: @mosaics.size,
+                  coverage:      overall_coverage,
+                  fit:           overall_fit,
+                  coherence:     overall_coherence
+                }
+              end
+
+              private
+
+              def find_or_create_mosaic(domain:)
+                key = domain.to_sym
+                @mosaics[key] ||= Mosaic.new(domain: key)
+              end
+
+              def prune_tiles
+                return if @tiles.size <= MAX_TILES
+
+                sorted = @tiles.values.sort_by(&:effective_coverage)
+                to_remove = sorted.first(@tiles.size - MAX_TILES)
+                to_remove.each { |t| @tiles.delete(t.id) }
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/legion/extensions/agentic/integration/tessellation/helpers/tile.rb

@@ -0,0 +1,76 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module Agentic
+      module Integration
+        module Tessellation
+          module Helpers
+            class Tile
+              include Constants
+
+              attr_reader :id, :tile_type, :shape, :domain, :coverage, :fit_score,
+                          :adjacent_ids, :created_at
+
+              def initialize(tile_type:, shape:, domain:, coverage: nil, fit_score: nil)
+                @id          = SecureRandom.uuid
+                @tile_type   = tile_type.to_sym
+                @shape       = shape.to_sym
+                @domain      = domain.to_sym
+                @coverage    = (coverage || DEFAULT_COVERAGE).to_f.clamp(0.0, 1.0)
+                @fit_score   = (fit_score || 0.5).to_f.clamp(0.0, 1.0)
+                @adjacent_ids = []
+                @created_at = Time.now.utc
+              end
+
+              def expand!(amount = COVERAGE_GROWTH)
+                @coverage = (@coverage + amount).clamp(0.0, 1.0).round(10)
+              end
+
+              def shrink!(amount = COVERAGE_DECAY)
+                @coverage = (@coverage - amount).clamp(0.0, 1.0).round(10)
+              end
+
+              def adjust_fit!(new_fit)
+                @fit_score = new_fit.to_f.clamp(0.0, 1.0).round(10)
+              end
+
+              def connect!(other_id)
+                @adjacent_ids << other_id unless @adjacent_ids.include?(other_id)
+              end
+
+              def full_coverage? = @coverage >= FULL_COVERAGE_THRESHOLD
+              def gapped? = @fit_score < GAP_THRESHOLD
+              def overlapping? = @fit_score > OVERLAP_THRESHOLD && @adjacent_ids.size > 3
+              def isolated? = @adjacent_ids.empty?
+              def well_connected? = @adjacent_ids.size >= 3
+              def seamless? = @fit_score >= 0.8
+
+              def effective_coverage
+                penalty = overlapping? ? OVERLAP_PENALTY * @adjacent_ids.size : 0.0
+                (@coverage - penalty).clamp(0.0, 1.0).round(10)
+              end
+
+              def to_h
+                {
+                  id:                 @id,
+                  tile_type:          @tile_type,
+                  shape:              @shape,
+                  domain:             @domain,
+                  coverage:           @coverage.round(10),
+                  fit_score:          @fit_score.round(10),
+                  effective_coverage: effective_coverage,
+                  adjacent_count:     @adjacent_ids.size,
+                  full_coverage:      full_coverage?,
+                  gapped:             gapped?,
+                  seamless:           seamless?,
+                  created_at:         @created_at.iso8601
+                }
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/legion/extensions/agentic/integration/tessellation/runners/cognitive_tessellation.rb

@@ -0,0 +1,58 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module Agentic
+      module Integration
+        module Tessellation
+          module Runners
+            module CognitiveTessellation
+              include Legion::Extensions::Helpers::Lex if defined?(Legion::Extensions::Helpers::Lex)
+
+              def create_tile(tile_type:, shape:, domain:, coverage: nil, fit_score: nil, engine: nil, **)
+                eng = engine || @default_engine
+                tile = eng.create_tile(tile_type: tile_type, shape: shape, domain: domain,
+                                       coverage: coverage, fit_score: fit_score)
+                { success: true, tile: tile.to_h }
+              end
+
+              def expand_tile(tile_id:, amount: nil, engine: nil, **)
+                eng = engine || @default_engine
+                tile = eng.expand_tile(tile_id: tile_id, amount: amount || Helpers::Constants::COVERAGE_GROWTH)
+                return { success: false, error: 'tile not found' } unless tile
+
+                { success: true, tile: tile.to_h }
+              end
+
+              def connect_tiles(tile_a_id:, tile_b_id:, engine: nil, **)
+                eng = engine || @default_engine
+                result = eng.connect_tiles(tile_a_id: tile_a_id, tile_b_id: tile_b_id)
+                return { success: false, error: 'one or both tiles not found' } unless result
+
+                { success: true, **result }
+              end
+
+              def shrink_all(engine: nil, **)
+                eng = engine || @default_engine
+                eng.shrink_all!
+                { success: true }
+              end
+
+              def list_gaps(engine: nil, **)
+                eng = engine || @default_engine
+                gaps = eng.gapped_tiles
+                { success: true, count: gaps.size, tiles: gaps.map(&:to_h) }
+              end
+
+              def tessellation_status(engine: nil, **)
+                eng = engine || @default_engine
+                report = eng.tessellation_report
+                { success: true, **report }
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

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

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

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+require 'securerandom'
+
+require_relative 'tessellation/version'
+require_relative 'tessellation/helpers/constants'
+require_relative 'tessellation/helpers/tile'
+require_relative 'tessellation/helpers/mosaic'
+require_relative 'tessellation/helpers/tessellation_engine'
+require_relative 'tessellation/runners/cognitive_tessellation'
+require_relative 'tessellation/client'
+
+module Legion
+  module Extensions
+    module Agentic
+      module Integration
+        module Tessellation
+        end
+      end
+    end
+  end
+end

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

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

data/lib/legion/extensions/agentic/integration/zeitgeist/helpers/client.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module Agentic
+      module Integration
+        module Zeitgeist
+          module Helpers
+            class Client
+              include Runners::CognitiveZeitgeist
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/legion/extensions/agentic/integration/zeitgeist/helpers/cognitive_signal.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module Agentic
+      module Integration
+        module Zeitgeist
+          module Helpers
+            class CognitiveSignal
+              attr_reader :id, :source_subsystem, :domain, :intensity, :valence, :timestamp
+
+              def initialize(source_subsystem:, domain:, intensity: Constants::DEFAULT_INTENSITY,
+                             valence: 0.0, timestamp: nil)
+                @id               = SecureRandom.uuid
+                @source_subsystem = source_subsystem.to_sym
+                @domain           = domain.to_sym
+                @intensity        = intensity.to_f.clamp(0.0, 1.0)
+                @valence          = valence.to_f.clamp(-1.0, 1.0)
+                @timestamp        = timestamp || Time.now.utc
+              end
+
+              def to_h
+                {
+                  id:               @id,
+                  source_subsystem: @source_subsystem,
+                  domain:           @domain,
+                  intensity:        @intensity.round(10),
+                  valence:          @valence.round(10),
+                  timestamp:        @timestamp.iso8601
+                }
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,64 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module Agentic
+      module Integration
+        module Zeitgeist
+          module Helpers
+            module Constants
+              MAX_SIGNALS          = 1000
+              WINDOW_SIZE          = 100
+              DEFAULT_INTENSITY    = 0.5
+              MOMENTUM_THRESHOLD   = 0.3
+              CONVERGENCE_THRESHOLD = 0.7
+              DIVERGENCE_THRESHOLD = 0.3
+
+              SIGNAL_DOMAINS = %i[
+                threat
+                opportunity
+                curiosity
+                anxiety
+                creativity
+                routine
+                social
+                abstract
+              ].freeze
+
+              MOOD_LABELS = {
+                (0.8..)     => :euphoric,
+                (0.6...0.8) => :elevated,
+                (0.4...0.6) => :neutral,
+                (0.2...0.4) => :subdued,
+                (..0.2)     => :suppressed
+              }.freeze
+
+              CONVERGENCE_LABELS = {
+                (0.8..)     => :unified,
+                (0.6...0.8) => :aligned,
+                (0.4...0.6) => :mixed,
+                (0.2...0.4) => :fragmented,
+                (..0.2)     => :divergent
+              }.freeze
+
+              MOMENTUM_LABELS = {
+                (0.6..)      => :surging,
+                (0.3...0.6)  => :building,
+                (0.0...0.3)  => :steady,
+                (-0.3...0.0) => :fading,
+                (..-0.3)     => :collapsing
+              }.freeze
+
+              def self.label_for(labels_hash, value)
+                labels_hash.each do |range, label|
+                  return label if range.cover?(value)
+                end
+                nil
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/legion/extensions/agentic/integration/zeitgeist/helpers/trend_window.rb

@@ -0,0 +1,80 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module Agentic
+      module Integration
+        module Zeitgeist
+          module Helpers
+            class TrendWindow
+              include Constants
+
+              attr_reader :signals, :window_size
+
+              def initialize(window_size: WINDOW_SIZE)
+                @signals     = []
+                @window_size = window_size
+              end
+
+              def add(signal)
+                @signals << signal
+                @signals.shift while @signals.size > @window_size
+                self
+              end
+
+              def dominant_domain
+                return nil if @signals.empty?
+
+                counts = Hash.new(0.0)
+                @signals.each { |s| counts[s.domain] += s.intensity }
+                counts.max_by { |_d, weight| weight }&.first
+              end
+
+              def dominant_valence
+                return 0.0 if @signals.empty?
+
+                weighted_sum = @signals.sum { |s| s.valence * s.intensity }
+                total_intensity = @signals.sum(&:intensity)
+                return 0.0 if total_intensity.zero?
+
+                (weighted_sum / total_intensity).clamp(-1.0, 1.0).round(10)
+              end
+
+              def momentum
+                return 0.0 if @signals.size < 2
+
+                half = @signals.size / 2
+                first_half  = @signals.first(half)
+                second_half = @signals.last(half)
+
+                avg_intensity = ->(arr) { arr.sum(&:intensity) / arr.size.to_f }
+                delta = avg_intensity.call(second_half) - avg_intensity.call(first_half)
+                delta.clamp(-1.0, 1.0).round(10)
+              end
+
+              def accelerating?
+                momentum > MOMENTUM_THRESHOLD
+              end
+
+              def decelerating?
+                momentum < -MOMENTUM_THRESHOLD
+              end
+
+              def to_h
+                {
+                  size:             @signals.size,
+                  window_size:      @window_size,
+                  dominant_domain:  dominant_domain,
+                  dominant_valence: dominant_valence,
+                  momentum:         momentum,
+                  accelerating:     accelerating?,
+                  decelerating:     decelerating?
+                }
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/legion/extensions/agentic/integration/zeitgeist/helpers/zeitgeist_engine.rb

@@ -0,0 +1,157 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module Agentic
+      module Integration
+        module Zeitgeist
+          module Helpers
+            class ZeitgeistEngine
+              include Constants
+
+              attr_reader :signals, :trend_window
+
+              def initialize
+                @signals      = []
+                @trend_window = TrendWindow.new
+              end
+
+              def ingest(source_subsystem:, domain:, intensity: DEFAULT_INTENSITY, valence: 0.0, timestamp: nil)
+                signal = CognitiveSignal.new(
+                  source_subsystem: source_subsystem,
+                  domain:           domain,
+                  intensity:        intensity,
+                  valence:          valence,
+                  timestamp:        timestamp
+                )
+                @signals << signal
+                @signals.shift while @signals.size > MAX_SIGNALS
+                @trend_window.add(signal)
+                signal
+              end
+
+              def dominant_themes(limit: 5)
+                return [] if @signals.empty?
+
+                weights = Hash.new(0.0)
+                @signals.each { |s| weights[s.domain] += s.intensity }
+                weights.sort_by { |_d, w| -w }.first(limit).map do |domain, weight|
+                  { domain: domain, weight: weight.round(10) }
+                end
+              end
+
+              def collective_mood
+                return 0.0 if @signals.empty?
+
+                weighted_sum = @signals.sum { |s| s.valence * s.intensity }
+                total = @signals.sum(&:intensity)
+                return 0.0 if total.zero?
+
+                (weighted_sum / total).clamp(-1.0, 1.0).round(10)
+              end
+
+              def cognitive_convergence
+                return 1.0 if @signals.empty?
+
+                subsystems = @signals.map(&:source_subsystem).uniq
+                return 1.0 if subsystems.size <= 1
+
+                compute_alignment(subsystems)
+              end
+
+              def rising_domains(window_size: WINDOW_SIZE / 2)
+                return [] if @signals.size < window_size
+
+                recent  = @signals.last(window_size)
+                earlier = @signals.last(window_size * 2).first(window_size)
+
+                deltas = domain_intensity_deltas(recent, earlier)
+                deltas.select { |d| d[:delta] > 0.0 }.sort_by { |d| -d[:delta] }
+              end
+
+              def falling_domains(window_size: WINDOW_SIZE / 2)
+                return [] if @signals.size < window_size
+
+                recent  = @signals.last(window_size)
+                earlier = @signals.last(window_size * 2).first(window_size)
+
+                deltas = domain_intensity_deltas(recent, earlier)
+                deltas.select { |d| d[:delta] < 0.0 }.sort_by { |d| d[:delta] }
+              end
+
+              def divergence_alert?
+                cognitive_convergence < DIVERGENCE_THRESHOLD
+              end
+
+              def zeitgeist_report
+                mood_value = collective_mood
+                conv_value = cognitive_convergence
+                mom_value  = @trend_window.momentum
+
+                {
+                  signal_count:      @signals.size,
+                  dominant_themes:   dominant_themes,
+                  collective_mood:   mood_value,
+                  mood_label:        Constants.label_for(MOOD_LABELS, normalize_mood(mood_value)),
+                  convergence:       conv_value,
+                  convergence_label: Constants.label_for(CONVERGENCE_LABELS, conv_value),
+                  momentum:          mom_value,
+                  momentum_label:    Constants.label_for(MOMENTUM_LABELS, mom_value),
+                  rising_domains:    rising_domains,
+                  falling_domains:   falling_domains,
+                  divergence_alert:  divergence_alert?,
+                  trend_window:      @trend_window.to_h
+                }
+              end
+
+              private
+
+              def compute_alignment(subsystems)
+                subsystem_domains = subsystems.to_h do |sub|
+                  subs_signals = @signals.select { |s| s.source_subsystem == sub }
+                  [sub, compute_dominant_domain(subs_signals)]
+                end
+
+                overall_dominant = dominant_themes(limit: 1).first&.fetch(:domain)
+                return 0.5 unless overall_dominant
+
+                aligned = subsystem_domains.count { |_sub, dom| dom == overall_dominant }
+                (aligned.to_f / subsystems.size).round(10)
+              end
+
+              def compute_dominant_domain(subs_signals)
+                return nil if subs_signals.empty?
+
+                weights = Hash.new(0.0)
+                subs_signals.each { |s| weights[s.domain] += s.intensity }
+                weights.max_by { |_d, w| w }&.first
+              end
+
+              def domain_intensity_deltas(recent, earlier)
+                recent_weights  = aggregate_domain_weights(recent)
+                earlier_weights = aggregate_domain_weights(earlier)
+
+                all_domains = (recent_weights.keys + earlier_weights.keys).uniq
+                all_domains.map do |domain|
+                  r = recent_weights.fetch(domain, 0.0)
+                  e = earlier_weights.fetch(domain, 0.0)
+                  { domain: domain, delta: (r - e).round(10) }
+                end
+              end
+
+              def aggregate_domain_weights(sigs)
+                weights = Hash.new(0.0)
+                sigs.each { |s| weights[s.domain] += s.intensity }
+                weights
+              end
+
+              def normalize_mood(mood_value)
+                ((mood_value + 1.0) / 2.0).clamp(0.0, 1.0)
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end