lex-agentic-integration 0.1.0

data/lib/legion/extensions/agentic/integration/distributed_cognition/helpers/participant.rb

@@ -0,0 +1,100 @@
+# frozen_string_literal: true
+
+require 'securerandom'
+
+module Legion
+  module Extensions
+    module Agentic
+      module Integration
+        module DistributedCognition
+          module Helpers
+            class Participant
+              include Constants
+
+              attr_reader :id, :name, :participant_type, :domain, :capabilities,
+                          :reliability, :contribution_count, :success_count,
+                          :created_at, :last_active_at
+
+              def initialize(name:, participant_type:, domain:, capabilities: [])
+                @id                 = SecureRandom.uuid
+                @name               = name
+                @participant_type   = participant_type
+                @domain             = domain
+                @capabilities       = capabilities
+                @reliability        = DEFAULT_RELIABILITY
+                @contribution_count = 0
+                @success_count      = 0
+                @created_at         = Time.now.utc
+                @last_active_at     = @created_at
+              end
+
+              def contribute!(success:)
+                @contribution_count += 1
+                @success_count      += 1 if success
+                @last_active_at      = Time.now.utc
+                adjust_reliability(success)
+              end
+
+              def add_capability(capability)
+                @capabilities << capability unless @capabilities.include?(capability)
+              end
+
+              def capable_of?(capability)
+                @capabilities.include?(capability)
+              end
+
+              def success_rate
+                return 0.0 if @contribution_count.zero?
+
+                @success_count.to_f / @contribution_count
+              end
+
+              def reliability_label
+                RELIABILITY_LABELS.find { |range, _| range.cover?(@reliability) }&.last || :unknown
+              end
+
+              def agent?
+                @participant_type == :agent
+              end
+
+              def artifact?
+                @participant_type == :artifact
+              end
+
+              def decay!
+                @reliability = (@reliability - DECAY_RATE).clamp(RELIABILITY_FLOOR, RELIABILITY_CEILING)
+              end
+
+              def stale?
+                (Time.now.utc - @last_active_at) > STALE_THRESHOLD
+              end
+
+              def to_h
+                {
+                  id:                 @id,
+                  name:               @name,
+                  participant_type:   @participant_type,
+                  domain:             @domain,
+                  capabilities:       @capabilities,
+                  reliability:        @reliability,
+                  reliability_label:  reliability_label,
+                  contribution_count: @contribution_count,
+                  success_rate:       success_rate,
+                  created_at:         @created_at,
+                  last_active_at:     @last_active_at
+                }
+              end
+
+              private
+
+              def adjust_reliability(success)
+                delta = success ? REINFORCEMENT_RATE : -PENALTY_RATE
+                @reliability = (@reliability + delta).clamp(RELIABILITY_FLOOR, RELIABILITY_CEILING)
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,107 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module Agentic
+      module Integration
+        module DistributedCognition
+          module Runners
+            module DistributedCognition
+              include Legion::Extensions::Helpers::Lex if Legion::Extensions.const_defined?(:Helpers) &&
+                                                          Legion::Extensions::Helpers.const_defined?(:Lex)
+
+              def register_cognitive_participant(name:, participant_type:, domain:, capabilities: [], **)
+                unless Helpers::Constants::PARTICIPANT_TYPES.include?(participant_type)
+                  return { success: false, error: :invalid_participant_type,
+                           valid_types: Helpers::Constants::PARTICIPANT_TYPES }
+                end
+
+                result = engine.register_participant(
+                  name: name, participant_type: participant_type,
+                  domain: domain, capabilities: capabilities
+                )
+
+                return result unless result.is_a?(Helpers::Participant)
+
+                Legion::Logging.debug "[distributed_cognition] registered #{name} " \
+                                      "type=#{participant_type} id=#{result.id[0..7]}"
+                { success: true, participant_id: result.id, name: name,
+                  participant_type: participant_type, domain: domain }
+              end
+
+              def record_cognitive_contribution(participant_id:, contribution_type:, success:, context: {}, **)
+                result = engine.record_contribution(
+                  participant_id: participant_id, contribution_type: contribution_type,
+                  success: success, context: context
+                )
+                Legion::Logging.debug '[distributed_cognition] contribution ' \
+                                      "type=#{contribution_type} success=#{success}"
+                result
+              end
+
+              def find_capable_participants(capability:, **)
+                participants = engine.find_capable(capability: capability)
+                Legion::Logging.debug '[distributed_cognition] find_capable ' \
+                                      "#{capability} count=#{participants.size}"
+                { success: true, capability: capability,
+                  participants: participants.map(&:to_h), count: participants.size }
+              end
+
+              def most_reliable_participants(limit: 5, **)
+                participants = engine.most_reliable(limit: limit)
+                Legion::Logging.debug "[distributed_cognition] most_reliable count=#{participants.size}"
+                { success: true, participants: participants.map(&:to_h), count: participants.size }
+              end
+
+              def distribution_assessment(**)
+                score = engine.distribution_score
+                label = engine.distribution_label
+                balance = engine.cognitive_load_balance
+                Legion::Logging.debug '[distributed_cognition] distribution ' \
+                                      "score=#{score.round(3)} label=#{label}"
+                { success: true, distribution_score: score, distribution_label: label,
+                  load_balance: balance }
+              end
+
+              def participants_by_type(participant_type:, **)
+                participants = engine.by_type(participant_type: participant_type)
+                Legion::Logging.debug "[distributed_cognition] by_type=#{participant_type} " \
+                                      "count=#{participants.size}"
+                { success: true, participant_type: participant_type,
+                  participants: participants.map(&:to_h), count: participants.size }
+              end
+
+              def participants_by_domain(domain:, **)
+                participants = engine.by_domain(domain: domain)
+                Legion::Logging.debug "[distributed_cognition] by_domain=#{domain} " \
+                                      "count=#{participants.size}"
+                { success: true, domain: domain,
+                  participants: participants.map(&:to_h), count: participants.size }
+              end
+
+              def update_distributed_cognition(**)
+                engine.decay_all
+                pruned = engine.prune_failing
+                Legion::Logging.debug "[distributed_cognition] decay+prune pruned=#{pruned}"
+                { success: true, pruned: pruned }
+              end
+
+              def distributed_cognition_stats(**)
+                stats = engine.to_h
+                Legion::Logging.debug '[distributed_cognition] stats ' \
+                                      "participants=#{stats[:total_participants]}"
+                { success: true }.merge(stats)
+              end
+
+              private
+
+              def engine
+                @engine ||= Helpers::DistributionEngine.new
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

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

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

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+require 'legion/extensions/agentic/integration/distributed_cognition/version'
+require 'legion/extensions/agentic/integration/distributed_cognition/helpers/constants'
+require 'legion/extensions/agentic/integration/distributed_cognition/helpers/participant'
+require 'legion/extensions/agentic/integration/distributed_cognition/helpers/distribution_engine'
+require 'legion/extensions/agentic/integration/distributed_cognition/runners/distributed_cognition'
+require 'legion/extensions/agentic/integration/distributed_cognition/client'
+
+module Legion
+  module Extensions
+    module Agentic
+      module Integration
+        module DistributedCognition
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module Agentic
+      module Integration
+        module Gestalt
+          class Client
+            include Runners::Gestalt
+
+            attr_reader :store
+
+            def initialize(store: nil, **)
+              @store = store || Helpers::PatternStore.new
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module Agentic
+      module Integration
+        module Gestalt
+          module Helpers
+            module Constants
+              # Minimum pattern match ratio to attempt completion
+              COMPLETION_THRESHOLD = 0.3
+
+              # Confidence boost for each additional matching element
+              MATCH_CONFIDENCE_BOOST = 0.15
+
+              # Maximum stored patterns
+              MAX_PATTERNS = 200
+
+              # Maximum elements per pattern
+              MAX_PATTERN_SIZE = 50
+
+              # Decay rate for pattern recency (older patterns contribute less)
+              PATTERN_DECAY = 0.01
+
+              # Minimum confidence to report a completion
+              MIN_COMPLETION_CONFIDENCE = 0.2
+
+              # Maximum completion candidates to return
+              MAX_COMPLETIONS = 5
+
+              # Grouping principles (Wertheimer's laws)
+              GROUPING_PRINCIPLES = %i[proximity similarity closure continuity common_fate].freeze
+
+              # Proximity threshold for grouping (normalized distance)
+              PROXIMITY_THRESHOLD = 0.3
+
+              # Similarity threshold for grouping
+              SIMILARITY_THRESHOLD = 0.6
+
+              # Reinforcement when a completion is confirmed correct
+              CORRECT_REINFORCEMENT = 0.1
+
+              # Penalty when a completion is wrong
+              INCORRECT_PENALTY = 0.15
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/legion/extensions/agentic/integration/gestalt/helpers/pattern.rb

@@ -0,0 +1,90 @@
+# frozen_string_literal: true
+
+require 'securerandom'
+
+module Legion
+  module Extensions
+    module Agentic
+      module Integration
+        module Gestalt
+          module Helpers
+            class Pattern
+              attr_reader :id, :name, :domain, :elements, :created_at
+              attr_accessor :strength, :match_count
+
+              def initialize(name:, elements:, domain: :general)
+                @id          = SecureRandom.uuid
+                @name        = name
+                @domain      = domain
+                @elements    = elements.first(Constants::MAX_PATTERN_SIZE)
+                @strength    = 1.0
+                @match_count = 0
+                @created_at  = Time.now.utc
+              end
+
+              def match_ratio(fragment)
+                return 0.0 if @elements.empty? || fragment.empty?
+
+                matches = fragment.count { |e| @elements.include?(e) }
+                matches.to_f / @elements.size
+              end
+
+              def missing_elements(fragment)
+                @elements - fragment
+              end
+
+              def complete(fragment)
+                ratio = match_ratio(fragment)
+                return nil if ratio < Constants::COMPLETION_THRESHOLD
+
+                confidence = compute_confidence(ratio)
+                missing = missing_elements(fragment)
+
+                @match_count += 1
+                {
+                  pattern_id:   @id,
+                  pattern_name: @name,
+                  completed:    @elements,
+                  missing:      missing,
+                  confidence:   confidence.round(4),
+                  match_ratio:  ratio.round(4)
+                }
+              end
+
+              def reinforce
+                @strength = [@strength + Constants::CORRECT_REINFORCEMENT, 2.0].min
+              end
+
+              def penalize
+                @strength = [@strength - Constants::INCORRECT_PENALTY, 0.1].max
+              end
+
+              def decay
+                @strength = [@strength - Constants::PATTERN_DECAY, 0.1].max
+              end
+
+              def to_h
+                {
+                  id:          @id,
+                  name:        @name,
+                  domain:      @domain,
+                  elements:    @elements,
+                  strength:    @strength.round(4),
+                  match_count: @match_count,
+                  size:        @elements.size
+                }
+              end
+
+              private
+
+              def compute_confidence(ratio)
+                base = ratio * Constants::MATCH_CONFIDENCE_BOOST / Constants::COMPLETION_THRESHOLD
+                (base * @strength).clamp(0.0, 1.0)
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/legion/extensions/agentic/integration/gestalt/helpers/pattern_store.rb

@@ -0,0 +1,123 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module Agentic
+      module Integration
+        module Gestalt
+          module Helpers
+            class PatternStore
+              attr_reader :patterns
+
+              def initialize
+                @patterns = []
+              end
+
+              def add(name:, elements:, domain: :general)
+                pattern = Pattern.new(name: name, elements: elements, domain: domain)
+                @patterns << pattern
+                trim
+                pattern
+              end
+
+              def find(id)
+                @patterns.find { |p| p.id == id }
+              end
+
+              def find_by_name(name)
+                @patterns.select { |p| p.name == name }
+              end
+
+              def in_domain(domain)
+                @patterns.select { |p| p.domain == domain }
+              end
+
+              def complete(fragment, domain: nil)
+                candidates = domain ? in_domain(domain) : @patterns
+                completions = candidates.filter_map { |p| p.complete(fragment) }
+                completions.sort_by { |c| -c[:confidence] }.first(Constants::MAX_COMPLETIONS)
+              end
+
+              def group_by_proximity(items, threshold: Constants::PROXIMITY_THRESHOLD)
+                return [items] if items.size <= 1
+
+                groups = []
+                remaining = items.dup
+
+                until remaining.empty?
+                  seed = remaining.shift
+                  group = [seed]
+                  remaining.reject! do |item|
+                    if proximity(seed, item) <= threshold
+                      group << item
+                      true
+                    else
+                      false
+                    end
+                  end
+                  groups << group
+                end
+                groups
+              end
+
+              def group_by_similarity(items, key: :type, **)
+                items.group_by { |item| item.is_a?(Hash) ? item[key] : item }.values
+              end
+
+              def reinforce(id)
+                pattern = find(id)
+                return nil unless pattern
+
+                pattern.reinforce
+                pattern
+              end
+
+              def penalize(id)
+                pattern = find(id)
+                return nil unless pattern
+
+                pattern.penalize
+                pattern
+              end
+
+              def decay_all
+                @patterns.each(&:decay)
+              end
+
+              def remove(id)
+                @patterns.reject! { |p| p.id == id }
+              end
+
+              def size
+                @patterns.size
+              end
+
+              def to_h
+                {
+                  pattern_count: @patterns.size,
+                  by_domain:     @patterns.group_by(&:domain).transform_values(&:size),
+                  total_matches: @patterns.sum(&:match_count)
+                }
+              end
+
+              private
+
+              def proximity(item_a, item_b)
+                return 1.0 unless item_a.is_a?(Numeric) && item_b.is_a?(Numeric)
+
+                (item_a - item_b).abs.to_f / [item_a.abs, item_b.abs, 1].max
+              end
+
+              def trim
+                return unless @patterns.size > Constants::MAX_PATTERNS
+
+                @patterns.sort_by!(&:strength)
+                @patterns.shift(@patterns.size - Constants::MAX_PATTERNS)
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,82 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module Agentic
+      module Integration
+        module Gestalt
+          module Runners
+            module Gestalt
+              include Legion::Extensions::Helpers::Lex
+
+              def store
+                @store ||= Helpers::PatternStore.new
+              end
+
+              def learn_pattern(name:, elements:, domain: :general, **)
+                pattern = store.add(name: name, elements: elements, domain: domain)
+                Legion::Logging.debug "[gestalt] learned pattern=#{name} domain=#{domain} size=#{elements.size}"
+                { success: true, pattern: pattern.to_h }
+              end
+
+              def complete_pattern(fragment:, domain: nil, **)
+                completions = store.complete(fragment, domain: domain)
+                Legion::Logging.debug "[gestalt] complete: #{completions.size} candidates for #{fragment.size} elements"
+                {
+                  success:     true,
+                  completions: completions,
+                  count:       completions.size,
+                  best:        completions.first
+                }
+              end
+
+              def confirm_completion(pattern_id:, correct: true, **)
+                result = if correct
+                           store.reinforce(pattern_id)
+                         else
+                           store.penalize(pattern_id)
+                         end
+                return { success: false, reason: :not_found } unless result
+
+                Legion::Logging.debug "[gestalt] #{correct ? 'reinforced' : 'penalized'} pattern=#{pattern_id}"
+                { success: true, pattern: result.to_h }
+              end
+
+              def group_items(items:, principle: :proximity, **)
+                groups = case principle
+                         when :proximity
+                           store.group_by_proximity(items)
+                         when :similarity
+                           store.group_by_similarity(items)
+                         else
+                           [items]
+                         end
+                { success: true, groups: groups, group_count: groups.size, principle: principle }
+              end
+
+              def update_gestalt(**)
+                store.decay_all
+                Legion::Logging.debug "[gestalt] tick: patterns=#{store.size}"
+                { success: true, pattern_count: store.size }
+              end
+
+              def patterns_in_domain(domain:, **)
+                patterns = store.in_domain(domain)
+                { success: true, patterns: patterns.map(&:to_h), count: patterns.size }
+              end
+
+              def remove_pattern(id:, **)
+                store.remove(id)
+                { success: true }
+              end
+
+              def gestalt_stats(**)
+                { success: true, stats: store.to_h }
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

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

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

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+require_relative 'gestalt/version'
+require_relative 'gestalt/helpers/constants'
+require_relative 'gestalt/helpers/pattern'
+require_relative 'gestalt/helpers/pattern_store'
+require_relative 'gestalt/runners/gestalt'
+require_relative 'gestalt/client'
+
+module Legion
+  module Extensions
+    module Agentic
+      module Integration
+        module Gestalt
+        end
+      end
+    end
+  end
+end

data/lib/legion/extensions/agentic/integration/global_workspace/actors/competition.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+require 'legion/extensions/actors/every'
+
+module Legion
+  module Extensions
+    module Agentic
+      module Integration
+        module GlobalWorkspace
+          module Actor
+            class Competition < Legion::Extensions::Actors::Every
+              def runner_class
+                Legion::Extensions::Agentic::Integration::GlobalWorkspace::Runners::GlobalWorkspace
+              end
+
+              def runner_function
+                'update_global_workspace'
+              end
+
+              def time
+                2
+              end
+
+              def run_now?
+                false
+              end
+
+              def use_runner?
+                false
+              end
+
+              def check_subtask?
+                false
+              end
+
+              def generate_task?
+                false
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end