lex-agentic-integration 0.1.0

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

@@ -0,0 +1,213 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module Agentic
+      module Integration
+        module Synthesis
+          module Helpers
+            class SynthesisEngine
+              include Constants
+
+              attr_reader :streams, :syntheses
+
+              def initialize
+                @streams    = {}
+                @syntheses  = []
+              end
+
+              def add_stream(stream_type:, content:, weight: DEFAULT_WEIGHT, confidence: DEFAULT_WEIGHT, **)
+                return { success: false, error: :invalid_stream_type, valid_types: STREAM_TYPES } unless STREAM_TYPES.include?(stream_type)
+
+                stream = SynthesisStream.new(
+                  stream_type: stream_type,
+                  content:     content,
+                  weight:      weight,
+                  confidence:  confidence
+                )
+
+                @streams[stream.id] = stream
+                prune_streams! if @streams.size > MAX_STREAMS
+
+                Legion::Logging.debug "[cognitive_synthesis] stream added id=#{stream.id[0..7]} " \
+                                      "type=#{stream_type} weight=#{weight.round(2)}"
+
+                { success: true, stream_id: stream.id, stream_type: stream_type }
+              end
+
+              def remove_stream(stream_id:, **)
+                removed = @streams.delete(stream_id)
+                if removed
+                  Legion::Logging.debug "[cognitive_synthesis] stream removed id=#{stream_id[0..7]}"
+                  { success: true, stream_id: stream_id }
+                else
+                  { success: false, error: :not_found }
+                end
+              end
+
+              def synthesize!(**)
+                active = @streams.values.reject(&:stale?)
+
+                if active.size < MIN_STREAMS_FOR_SYNTHESIS
+                  Legion::Logging.debug "[cognitive_synthesis] synthesize! skipped: only #{active.size} active streams"
+                  return { success: false, error: :insufficient_streams, active_count: active.size, required: MIN_STREAMS_FOR_SYNTHESIS }
+                end
+
+                coherence   = compute_coherence(active)
+                novelty     = compute_novelty(active)
+                confidence  = compute_weighted_confidence(active)
+                content     = merge_content(active)
+
+                synthesis = Synthesis.new(
+                  streams:    active.map(&:id),
+                  coherence:  coherence,
+                  novelty:    novelty,
+                  confidence: confidence,
+                  content:    content
+                )
+
+                @syntheses << synthesis
+                @syntheses.shift while @syntheses.size > MAX_SYNTHESES
+
+                Legion::Logging.info "[cognitive_synthesis] synthesis id=#{synthesis.id[0..7]} " \
+                                     "coherence=#{coherence.round(2)} novelty=#{novelty.round(2)} " \
+                                     "streams=#{active.size} label=#{synthesis.coherence_label}"
+
+                { success: true, synthesis: synthesis.to_h }
+              end
+
+              def decay_all!(**)
+                before = @streams.size
+                @streams.each_value(&:decay_freshness!)
+                @streams.reject! { |_, s| s.stale? }
+                removed = before - @streams.size
+
+                Legion::Logging.debug "[cognitive_synthesis] decay_all! removed=#{removed} remaining=#{@streams.size}"
+                { success: true, streams_removed: removed, streams_remaining: @streams.size }
+              end
+
+              def stream_conflict?(stream_id_a:, stream_id_b:, **)
+                a = @streams[stream_id_a]
+                b = @streams[stream_id_b]
+
+                return { success: false, error: :stream_not_found } unless a && b
+
+                weight_opposition = opposing_weights?(a, b)
+                content_conflict  = conflicting_content?(a, b)
+                conflict          = weight_opposition || content_conflict
+
+                Legion::Logging.debug "[cognitive_synthesis] conflict check #{stream_id_a[0..7]}<>#{stream_id_b[0..7]} " \
+                                      "result=#{conflict}"
+
+                {
+                  success:           true,
+                  conflict:          conflict,
+                  weight_opposition: weight_opposition,
+                  content_conflict:  content_conflict
+                }
+              end
+
+              def dominant_stream(**)
+                return { success: false, error: :no_streams } if @streams.empty?
+
+                stream = @streams.values.max_by(&:effective_weight)
+                Legion::Logging.debug "[cognitive_synthesis] dominant stream id=#{stream.id[0..7]} " \
+                                      "effective_weight=#{stream.effective_weight.round(4)}"
+                { success: true, stream: stream.to_h }
+              end
+
+              def synthesis_history(limit: 10, **)
+                recent = @syntheses.last(limit)
+                { success: true, syntheses: recent.map(&:to_h), count: recent.size }
+              end
+
+              def average_coherence(window: 10, **)
+                recent = @syntheses.last(window)
+                return { success: true, average_coherence: 0.0, sample_size: 0 } if recent.empty?
+
+                avg = recent.sum(&:coherence).round(10) / recent.size
+                { success: true, average_coherence: avg.round(10), sample_size: recent.size }
+              end
+
+              def to_h
+                {
+                  stream_count:      @streams.size,
+                  synthesis_count:   @syntheses.size,
+                  active_streams:    @streams.values.reject(&:stale?).size,
+                  stale_streams:     @streams.values.count(&:stale?),
+                  average_coherence: @syntheses.empty? ? 0.0 : (@syntheses.sum(&:coherence).round(10) / @syntheses.size).round(6)
+                }
+              end
+
+              private
+
+              def prune_streams!
+                overflow = @streams.size - MAX_STREAMS
+                return if overflow <= 0
+
+                ids_to_prune = @streams.min_by(overflow) { |_, s| s.effective_weight }.map(&:first)
+                ids_to_prune.each { |id| @streams.delete(id) }
+              end
+
+              def compute_coherence(active)
+                return 1.0 if active.size == 1
+
+                weights = active.map(&:effective_weight)
+                mean    = weights.sum.round(10) / weights.size
+                variance = weights.sum { |w| ((w - mean)**2).round(10) }.round(10) / weights.size
+                std_dev  = Math.sqrt(variance)
+
+                (1.0 - [std_dev, 1.0].min).round(10)
+              end
+
+              def compute_novelty(active)
+                return 1.0 if @syntheses.empty?
+
+                last_syn = @syntheses.last
+                last_ids = Set.new(last_syn.streams)
+                current_ids = Set.new(active.map(&:id))
+
+                overlap = (last_ids & current_ids).size.to_f
+                union   = (last_ids | current_ids).size.to_f
+
+                return 1.0 if union.zero?
+
+                jaccard_similarity = overlap / union
+                (1.0 - jaccard_similarity).round(10)
+              end
+
+              def compute_weighted_confidence(active)
+                total_weight = active.sum(&:effective_weight).round(10)
+                return 0.0 if total_weight.zero?
+
+                weighted_sum = active.sum { |s| (s.confidence * s.effective_weight).round(10) }.round(10)
+                (weighted_sum / total_weight).round(10)
+              end
+
+              def merge_content(active)
+                dominant = active.max_by(&:effective_weight)
+                {
+                  dominant_type:    dominant.stream_type,
+                  dominant_weight:  dominant.effective_weight.round(6),
+                  stream_types:     active.map(&:stream_type).uniq,
+                  stream_count:     active.size,
+                  payload_snapshot: dominant.content
+                }
+              end
+
+              def opposing_weights?(str_a, str_b)
+                (str_a.weight - str_b.weight).abs > 0.5
+              end
+
+              def conflicting_content?(str_a, str_b)
+                keys_a = str_a.content.is_a?(Hash) ? str_a.content.keys : []
+                keys_b = str_b.content.is_a?(Hash) ? str_b.content.keys : []
+                (keys_a & keys_b).any? { |k| str_a.content[k] != str_b.content[k] }
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,67 @@
+# frozen_string_literal: true
+
+require 'securerandom'
+
+module Legion
+  module Extensions
+    module Agentic
+      module Integration
+        module Synthesis
+          module Helpers
+            class SynthesisStream
+              include Constants
+
+              attr_reader :id, :stream_type, :content, :weight, :confidence, :freshness, :created_at
+
+              def initialize(stream_type:, content:, weight: DEFAULT_WEIGHT, confidence: DEFAULT_WEIGHT)
+                @id          = SecureRandom.uuid
+                @stream_type = stream_type
+                @content     = content
+                @weight      = weight.clamp(0.0, 1.0)
+                @confidence  = confidence.clamp(0.0, 1.0)
+                @freshness   = 1.0
+                @created_at  = Time.now.utc
+              end
+
+              def decay_freshness!
+                @freshness = (@freshness - FRESHNESS_DECAY).clamp(0.0, 1.0)
+              end
+
+              def stale?
+                @freshness < 0.1
+              end
+
+              def effective_weight
+                (@weight * @freshness * @confidence).round(10)
+              end
+
+              def coherence_label
+                COHERENCE_LABELS.find { |range, _| range.cover?(@weight) }&.last || :chaotic
+              end
+
+              def confidence_label
+                CONFIDENCE_LABELS.find { |range, _| range.cover?(@confidence) }&.last || :guessing
+              end
+
+              def to_h
+                {
+                  id:               @id,
+                  stream_type:      @stream_type,
+                  content:          @content,
+                  weight:           @weight,
+                  confidence:       @confidence,
+                  freshness:        @freshness,
+                  effective_weight: effective_weight,
+                  stale:            stale?,
+                  coherence_label:  coherence_label,
+                  confidence_label: confidence_label,
+                  created_at:       @created_at
+                }
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/legion/extensions/agentic/integration/synthesis/runners/cognitive_synthesis.rb

@@ -0,0 +1,82 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module Agentic
+      module Integration
+        module Synthesis
+          module Runners
+            module CognitiveSynthesis
+              include Legion::Extensions::Helpers::Lex if Legion::Extensions.const_defined?(:Helpers) &&
+                                                          Legion::Extensions::Helpers.const_defined?(:Lex)
+
+              def add_stream(stream_type:, content:, weight: Helpers::Constants::DEFAULT_WEIGHT,
+                             confidence: Helpers::Constants::DEFAULT_WEIGHT, engine: nil, **)
+                target = engine || synthesis_engine
+                result = target.add_stream(stream_type: stream_type, content: content,
+                                           weight: weight, confidence: confidence)
+                Legion::Logging.debug "[cognitive_synthesis] runner add_stream type=#{stream_type}"
+                result
+              end
+
+              def remove_stream(stream_id:, engine: nil, **)
+                target = engine || synthesis_engine
+                Legion::Logging.debug "[cognitive_synthesis] runner remove_stream id=#{stream_id[0..7]}"
+                target.remove_stream(stream_id: stream_id)
+              end
+
+              def synthesize(engine: nil, **)
+                target = engine || synthesis_engine
+                Legion::Logging.debug '[cognitive_synthesis] runner synthesize'
+                target.synthesize!
+              end
+
+              def decay_streams(engine: nil, **)
+                target = engine || synthesis_engine
+                Legion::Logging.debug '[cognitive_synthesis] runner decay_streams'
+                target.decay_all!
+              end
+
+              def check_conflict(stream_id_a:, stream_id_b:, engine: nil, **)
+                target = engine || synthesis_engine
+                Legion::Logging.debug "[cognitive_synthesis] runner check_conflict #{stream_id_a[0..7]}<>#{stream_id_b[0..7]}"
+                target.stream_conflict?(stream_id_a: stream_id_a, stream_id_b: stream_id_b)
+              end
+
+              def dominant_stream(engine: nil, **)
+                target = engine || synthesis_engine
+                Legion::Logging.debug '[cognitive_synthesis] runner dominant_stream'
+                target.dominant_stream
+              end
+
+              def synthesis_history(limit: 10, engine: nil, **)
+                target = engine || synthesis_engine
+                Legion::Logging.debug "[cognitive_synthesis] runner synthesis_history limit=#{limit}"
+                target.synthesis_history(limit: limit)
+              end
+
+              def average_coherence(window: 10, engine: nil, **)
+                target = engine || synthesis_engine
+                Legion::Logging.debug "[cognitive_synthesis] runner average_coherence window=#{window}"
+                target.average_coherence(window: window)
+              end
+
+              def status(engine: nil, **)
+                target = engine || synthesis_engine
+                stats  = target.to_h
+                Legion::Logging.debug "[cognitive_synthesis] runner status streams=#{stats[:stream_count]}"
+                { success: true }.merge(stats)
+              end
+
+              private
+
+              def synthesis_engine
+                @synthesis_engine ||= Helpers::SynthesisEngine.new
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

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

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

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+require 'legion/extensions/agentic/integration/synthesis/version'
+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'
+require 'legion/extensions/agentic/integration/synthesis/client'
+
+module Legion
+  module Extensions
+    module Agentic
+      module Integration
+        module Synthesis
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module Agentic
+      module Integration
+        module Tapestry
+          class Client
+            include Runners::CognitiveTapestry
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module Agentic
+      module Integration
+        module Tapestry
+          module Helpers
+            module Constants
+              THREAD_TYPES = %i[experience belief memory emotion narrative].freeze
+
+              WEAVE_PATTERNS = %i[plain twill satin brocade].freeze
+
+              MAX_THREADS    = 500
+              MAX_TAPESTRIES = 50
+              TENSION_RATE   = 0.05
+              FRAY_RATE      = 0.03
+
+              INTEGRITY_LABELS = [
+                [(0.9..),      :masterwork],
+                [(0.7...0.9),  :sturdy],
+                [(0.5...0.7),  :woven],
+                [(0.3...0.5),  :fraying],
+                [(0.1...0.3),  :tattered],
+                [(..0.1),      :rags]
+              ].freeze
+
+              COMPLEXITY_LABELS = [
+                [(0.85..),     :baroque],
+                [(0.65...0.85), :elaborate],
+                [(0.45...0.65), :patterned],
+                [(0.25...0.45), :plain_woven],
+                [(..0.25), :simple]
+              ].freeze
+
+              def self.label_for(table, value)
+                table.each { |range, label| return label if range.cover?(value) }
+                table.last.last
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/legion/extensions/agentic/integration/tapestry/helpers/loom_engine.rb

@@ -0,0 +1,125 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module Agentic
+      module Integration
+        module Tapestry
+          module Helpers
+            class LoomEngine
+              def initialize
+                @threads    = {}
+                @tapestries = {}
+              end
+
+              def spin_thread(thread_type:, domain:, content:,
+                              strength: nil, color: nil)
+                raise ArgumentError, 'thread limit reached' if @threads.size >= Constants::MAX_THREADS
+
+                t = Helpers::Thread.new(
+                  thread_type: thread_type,
+                  domain:      domain,
+                  content:     content,
+                  strength:    strength,
+                  color:       color
+                )
+                @threads[t.id] = t
+                t
+              end
+
+              def create_tapestry(name:, pattern:, capacity: 50)
+                raise ArgumentError, 'tapestry limit reached' if @tapestries.size >= Constants::MAX_TAPESTRIES
+
+                tap = Tapestry.new(name: name, pattern: pattern, capacity: capacity)
+                @tapestries[tap.id] = tap
+                tap
+              end
+
+              def weave(thread_id:, tapestry_id:)
+                thread   = fetch_thread(thread_id)
+                tapestry = fetch_tapestry(tapestry_id)
+
+                raise ArgumentError, 'thread already woven' if thread.woven?
+                raise ArgumentError, 'tapestry is full'     if tapestry.full?
+
+                tapestry.weave_thread(thread_id)
+                thread.woven_into!(tapestry_id)
+              end
+
+              def unravel(thread_id:, tapestry_id:)
+                thread   = fetch_thread(thread_id)
+                tapestry = fetch_tapestry(tapestry_id)
+
+                tapestry.unravel_thread(thread_id)
+                thread.unwoven!
+              end
+
+              def fray_all!(rate: Constants::FRAY_RATE)
+                @threads.each_value { |t| t.fray!(rate: rate) }
+                snapped = @threads.count { |_, t| t.snap? }
+                { total: @threads.size, snapped: snapped }
+              end
+
+              def most_complete(limit: 5)
+                @tapestries.values.sort_by { |tap| -tap.completeness }.first(limit)
+              end
+
+              def most_coherent(limit: 5)
+                threads_arr = @threads.values
+                @tapestries.values
+                           .sort_by { |tap| -tap.coherence_score(threads_arr) }
+                           .first(limit)
+              end
+
+              def thread_inventory
+                counts = Constants::THREAD_TYPES.to_h { |type| [type, 0] }
+                @threads.each_value { |t| counts[t.thread_type] += 1 }
+                counts
+              end
+
+              def tapestry_report
+                threads_arr = @threads.values
+                {
+                  total_threads:    @threads.size,
+                  total_tapestries: @tapestries.size,
+                  loose_count:      loose_threads.size,
+                  by_type:          thread_inventory,
+                  fraying_count:    @tapestries.count { |_, tap| tap.fraying?(threads_arr) },
+                  avg_completeness: avg_completeness
+                }
+              end
+
+              def all_threads
+                @threads.values
+              end
+
+              def all_tapestries
+                @tapestries.values
+              end
+
+              def loose_threads
+                @threads.values.select(&:loose?)
+              end
+
+              private
+
+              def fetch_thread(id)
+                @threads.fetch(id) { raise ArgumentError, "thread not found: #{id}" }
+              end
+
+              def fetch_tapestry(id)
+                @tapestries.fetch(id) { raise ArgumentError, "tapestry not found: #{id}" }
+              end
+
+              def avg_completeness
+                return 0.0 if @tapestries.empty?
+
+                (@tapestries.values.sum(&:completeness) / @tapestries.size).round(10)
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end