lex-agentic-integration 0.1.0

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

@@ -0,0 +1,144 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module Agentic
+      module Integration
+        module Tapestry
+          module Helpers
+            class Tapestry
+              attr_reader :id, :name, :pattern, :capacity, :thread_ids, :created_at
+
+              def initialize(name:, pattern:, capacity: 50)
+                validate_pattern!(pattern)
+                @id         = SecureRandom.uuid
+                @name       = name.to_s
+                @pattern    = pattern.to_sym
+                @capacity   = capacity.to_i.clamp(1, 500)
+                @thread_ids = []
+                @created_at = Time.now.utc
+              end
+
+              def weave_thread(thread_id)
+                return false if @thread_ids.include?(thread_id)
+                return false if full?
+
+                @thread_ids << thread_id
+                true
+              end
+
+              def unravel_thread(thread_id)
+                @thread_ids.delete(thread_id) ? true : false
+              end
+
+              def size
+                @thread_ids.size
+              end
+
+              def full?
+                @thread_ids.size >= @capacity
+              end
+
+              def empty?
+                @thread_ids.empty?
+              end
+
+              def completeness
+                return 0.0 if @capacity.zero?
+
+                (@thread_ids.size.to_f / @capacity).clamp(0.0, 1.0).round(10)
+              end
+
+              def age!(fray_rate: Constants::FRAY_RATE)
+                fray_rate
+              end
+
+              def repair!(boost: 0.1)
+                boost
+              end
+
+              def fraying?(threads)
+                return false if empty?
+
+                avg = average_strength(threads)
+                avg < 0.3
+              end
+
+              def masterwork?(threads)
+                return false if empty?
+
+                avg = average_strength(threads)
+                avg >= 0.9 && completeness >= 0.9
+              end
+
+              def coherence_score(threads)
+                return 0.0 if empty?
+
+                placed = threads.select { |t| @thread_ids.include?(t.id) }
+                return 0.0 if placed.empty?
+
+                type_diversity = placed.map(&:thread_type).uniq.size.to_f / Constants::THREAD_TYPES.size
+                avg_str        = placed.sum(&:strength) / placed.size
+                pattern_bonus  = pattern_coherence_factor
+                ((avg_str * 0.5) + (type_diversity * 0.3) + (pattern_bonus * 0.2)).clamp(0.0, 1.0).round(10)
+              end
+
+              def completeness_label
+                Constants.label_for(Constants::INTEGRITY_LABELS, completeness)
+              end
+
+              def complexity_label(threads)
+                Constants.label_for(Constants::COMPLEXITY_LABELS, coherence_score(threads))
+              end
+
+              def gap_count
+                @capacity - @thread_ids.size
+              end
+
+              def to_h(threads = [])
+                {
+                  id:                 @id,
+                  name:               @name,
+                  pattern:            @pattern,
+                  capacity:           @capacity,
+                  size:               size,
+                  completeness:       completeness,
+                  completeness_label: completeness_label,
+                  coherence_score:    coherence_score(threads),
+                  gap_count:          gap_count,
+                  full:               full?,
+                  empty:              empty?,
+                  fraying:            fraying?(threads),
+                  masterwork:         masterwork?(threads),
+                  thread_ids:         @thread_ids.dup,
+                  created_at:         @created_at
+                }
+              end
+
+              private
+
+              def average_strength(threads)
+                placed = threads.select { |t| @thread_ids.include?(t.id) }
+                return 0.0 if placed.empty?
+
+                placed.sum(&:strength) / placed.size
+              end
+
+              def pattern_coherence_factor
+                { plain: 0.6, twill: 0.7, satin: 0.8, brocade: 1.0 }.fetch(@pattern, 0.5)
+              end
+
+              def validate_pattern!(val)
+                return if Constants::WEAVE_PATTERNS.include?(val.to_sym)
+
+                raise ArgumentError,
+                      "unknown pattern: #{val.inspect}; " \
+                      "must be one of #{Constants::WEAVE_PATTERNS.inspect}"
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,112 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module Agentic
+      module Integration
+        module Tapestry
+          module Helpers
+            class Thread
+              attr_reader :id, :thread_type, :domain, :content,
+                          :color, :created_at, :tapestry_id
+              attr_accessor :strength
+
+              COLOR_MAP = {
+                experience: :gold,
+                belief:     :silver,
+                memory:     :blue,
+                emotion:    :crimson,
+                narrative:  :violet
+              }.freeze
+
+              def initialize(thread_type:, domain:, content:,
+                             strength: nil, color: nil)
+                validate_thread_type!(thread_type)
+                @id          = SecureRandom.uuid
+                @thread_type = thread_type.to_sym
+                @domain      = domain.to_sym
+                @content     = content.to_s
+                @strength    = (strength || 0.5).to_f.clamp(0.0, 1.0).round(10)
+                @color       = (color || default_color(thread_type)).to_sym
+                @created_at  = Time.now.utc
+                @tapestry_id = nil
+              end
+
+              def woven_into!(tapestry_id)
+                @tapestry_id = tapestry_id
+                self
+              end
+
+              def unwoven!
+                @tapestry_id = nil
+                self
+              end
+
+              def reinforce!(rate: Constants::TENSION_RATE)
+                @strength = (@strength + rate.abs).clamp(0.0, 1.0).round(10)
+                self
+              end
+
+              def fray!(rate: Constants::FRAY_RATE)
+                @strength = (@strength - rate.abs).clamp(0.0, 1.0).round(10)
+                self
+              end
+
+              def snap?
+                @strength <= 0.0
+              end
+
+              def taut?
+                @strength >= 0.9
+              end
+
+              def woven?
+                !@tapestry_id.nil?
+              end
+
+              def loose?
+                @tapestry_id.nil?
+              end
+
+              def thread_integrity
+                Constants.label_for(Constants::INTEGRITY_LABELS, @strength)
+              end
+
+              def to_h
+                {
+                  id:               @id,
+                  thread_type:      @thread_type,
+                  domain:           @domain,
+                  content:          @content,
+                  strength:         @strength,
+                  color:            @color,
+                  thread_integrity: thread_integrity,
+                  woven:            woven?,
+                  loose:            loose?,
+                  snap:             snap?,
+                  taut:             taut?,
+                  tapestry_id:      @tapestry_id,
+                  created_at:       @created_at
+                }
+              end
+
+              private
+
+              def default_color(type)
+                COLOR_MAP.fetch(type.to_sym, :grey)
+              end
+
+              def validate_thread_type!(val)
+                return if Constants::THREAD_TYPES.include?(val.to_sym)
+
+                raise ArgumentError,
+                      "unknown thread_type: #{val.inspect}; " \
+                      "must be one of #{Constants::THREAD_TYPES.inspect}"
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/legion/extensions/agentic/integration/tapestry/runners/cognitive_tapestry.rb

@@ -0,0 +1,81 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module Agentic
+      module Integration
+        module Tapestry
+          module Runners
+            module CognitiveTapestry
+              extend self
+
+              include Legion::Extensions::Helpers::Lex if defined?(Legion::Extensions::Helpers::Lex)
+
+              def spin_thread(thread_type:, domain:, content:,
+                              strength: nil, color: nil, engine: nil, **)
+                eng = resolve_engine(engine)
+                t   = eng.spin_thread(
+                  thread_type: thread_type,
+                  domain:      domain,
+                  content:     content,
+                  strength:    strength,
+                  color:       color
+                )
+                { success: true, thread: t.to_h }
+              rescue ArgumentError => e
+                { success: false, error: e.message }
+              end
+
+              def create_tapestry(name:, pattern:, capacity: 50, engine: nil, **)
+                eng = resolve_engine(engine)
+                tap = eng.create_tapestry(name: name, pattern: pattern, capacity: capacity)
+                threads_arr = eng.all_threads
+                { success: true, tapestry: tap.to_h(threads_arr) }
+              rescue ArgumentError => e
+                { success: false, error: e.message }
+              end
+
+              def weave(thread_id:, tapestry_id:, engine: nil, **)
+                eng = resolve_engine(engine)
+                t   = eng.weave(thread_id: thread_id, tapestry_id: tapestry_id)
+                { success: true, thread: t.to_h }
+              rescue ArgumentError => e
+                { success: false, error: e.message }
+              end
+
+              def list_tapestries(engine: nil, pattern: nil, fraying_only: false, **)
+                eng         = resolve_engine(engine)
+                threads_arr = eng.all_threads
+                results     = eng.all_tapestries
+
+                results = results.select { |tap| tap.pattern == pattern.to_sym } if pattern
+                results = results.select { |tap| tap.fraying?(threads_arr) }     if fraying_only
+
+                {
+                  success:    true,
+                  tapestries: results.map { |tap| tap.to_h(threads_arr) },
+                  count:      results.size
+                }
+              end
+
+              def loom_status(engine: nil, **)
+                eng = resolve_engine(engine)
+                { success: true, report: eng.tapestry_report }
+              end
+
+              private
+
+              def resolve_engine(engine)
+                engine || default_engine
+              end
+
+              def default_engine
+                @default_engine ||= Helpers::LoomEngine.new
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

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

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

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+require 'securerandom'
+
+require_relative 'tapestry/version'
+require_relative 'tapestry/helpers/constants'
+require_relative 'tapestry/helpers/thread'
+require_relative 'tapestry/helpers/tapestry'
+require_relative 'tapestry/helpers/loom_engine'
+require_relative 'tapestry/runners/cognitive_tapestry'
+require_relative 'tapestry/client'
+
+module Legion
+  module Extensions
+    module Agentic
+      module Integration
+        module Tapestry
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module Agentic
+      module Integration
+        module Tessellation
+          class Client
+            include Runners::CognitiveTessellation
+
+            def initialize
+              @default_engine = Helpers::TessellationEngine.new
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,72 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module Agentic
+      module Integration
+        module Tessellation
+          module Helpers
+            module Constants
+              MAX_TILES = 500
+              MAX_MOSAICS = 50
+
+              DEFAULT_COVERAGE = 0.0
+              FULL_COVERAGE_THRESHOLD = 0.95
+              GAP_THRESHOLD = 0.3
+              OVERLAP_THRESHOLD = 0.7
+              FIT_TOLERANCE = 0.05
+
+              COVERAGE_GROWTH = 0.08
+              COVERAGE_DECAY = 0.02
+              OVERLAP_PENALTY = 0.05
+
+              TILE_SHAPES = %i[
+                triangular square hexagonal pentagonal
+                irregular fractal amorphous crystalline
+              ].freeze
+
+              DOMAINS = %i[
+                cognitive emotional procedural semantic
+                episodic social creative analytical
+              ].freeze
+
+              TILE_TYPES = %i[
+                knowledge skill pattern belief
+                heuristic schema model framework
+              ].freeze
+
+              COVERAGE_LABELS = {
+                (0.9..)     => :complete,
+                (0.7...0.9) => :substantial,
+                (0.5...0.7) => :partial,
+                (0.3...0.5) => :sparse,
+                (..0.3)     => :fragmented
+              }.freeze
+
+              FIT_LABELS = {
+                (0.8..)     => :seamless,
+                (0.6...0.8) => :snug,
+                (0.4...0.6) => :loose,
+                (0.2...0.4) => :gapped,
+                (..0.2)     => :disjointed
+              }.freeze
+
+              DENSITY_LABELS = {
+                (0.8..)     => :saturated,
+                (0.6...0.8) => :dense,
+                (0.4...0.6) => :moderate,
+                (0.2...0.4) => :thin,
+                (..0.2)     => :vacant
+              }.freeze
+
+              def self.label_for(labels, value)
+                labels.each { |range, label| return label if range.cover?(value) }
+                :unknown
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,99 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module Agentic
+      module Integration
+        module Tessellation
+          module Helpers
+            class Mosaic
+              include Constants
+
+              attr_reader :id, :domain, :tiles, :created_at
+
+              def initialize(domain:)
+                @id         = SecureRandom.uuid
+                @domain     = domain.to_sym
+                @tiles      = []
+                @created_at = Time.now.utc
+              end
+
+              def add_tile(tile)
+                @tiles << tile
+                auto_connect(tile)
+                tile
+              end
+
+              def total_coverage
+                return 0.0 if @tiles.empty?
+
+                raw = @tiles.sum(&:effective_coverage) / @tiles.size
+                raw.clamp(0.0, 1.0).round(10)
+              end
+
+              def average_fit
+                return 0.0 if @tiles.empty?
+
+                (@tiles.sum(&:fit_score) / @tiles.size).round(10)
+              end
+
+              def gap_count = @tiles.count(&:gapped?)
+              def seamless_count = @tiles.count(&:seamless?)
+              def isolated_count = @tiles.count(&:isolated?)
+              def complete? = total_coverage >= FULL_COVERAGE_THRESHOLD
+
+              def coherence
+                return 0.0 if @tiles.empty?
+
+                connected = @tiles.count(&:well_connected?)
+                (connected.to_f / @tiles.size).round(10)
+              end
+
+              def uniformity
+                return 1.0 if @tiles.size <= 1
+
+                coverages = @tiles.map(&:coverage)
+                mean = coverages.sum / coverages.size
+                variance = coverages.sum { |c| (c - mean)**2 } / coverages.size
+                (1.0 - Math.sqrt(variance)).clamp(0.0, 1.0).round(10)
+              end
+
+              def to_h
+                {
+                  id:             @id,
+                  domain:         @domain,
+                  tile_count:     @tiles.size,
+                  total_coverage: total_coverage,
+                  average_fit:    average_fit,
+                  coherence:      coherence,
+                  uniformity:     uniformity,
+                  gaps:           gap_count,
+                  seamless:       seamless_count,
+                  complete:       complete?
+                }
+              end
+
+              private
+
+              def auto_connect(new_tile)
+                same_domain = @tiles.select { |t| t.domain == new_tile.domain && t.id != new_tile.id }
+                same_domain.last(2).each do |neighbor|
+                  new_tile.connect!(neighbor.id)
+                  neighbor.connect!(new_tile.id)
+                  compute_fit(new_tile, neighbor)
+                end
+              end
+
+              def compute_fit(tile_a, tile_b)
+                shape_match = tile_a.shape == tile_b.shape ? 0.2 : 0.0
+                type_match  = tile_a.tile_type == tile_b.tile_type ? 0.1 : 0.0
+                base_fit    = 0.5 + shape_match + type_match + (rand * 0.2)
+                tile_a.adjust_fit!(base_fit)
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end