lex-agentic-integration 0.1.0

data/spec/legion/extensions/agentic/integration/distributed_cognition/helpers/distribution_engine_spec.rb

@@ -0,0 +1,149 @@
+# frozen_string_literal: true
+
+RSpec.describe Legion::Extensions::Agentic::Integration::DistributedCognition::Helpers::DistributionEngine do
+  subject(:engine) { described_class.new }
+
+  let(:agent) do
+    engine.register_participant(
+      name: 'worker-alpha', participant_type: :agent,
+      domain: :reasoning, capabilities: %i[computation retrieval]
+    )
+  end
+
+  describe '#register_participant' do
+    it 'creates and stores a participant' do
+      result = agent
+      expect(result).to be_a(Legion::Extensions::Agentic::Integration::DistributedCognition::Helpers::Participant)
+    end
+
+    it 'rejects invalid participant types' do
+      result = engine.register_participant(
+        name: 'test', participant_type: :invalid, domain: :test
+      )
+      expect(result[:success]).to be false
+    end
+
+    it 'records history' do
+      agent
+      expect(engine.history.size).to eq(1)
+    end
+  end
+
+  describe '#record_contribution' do
+    it 'records a successful contribution' do
+      result = engine.record_contribution(
+        participant_id: agent.id, contribution_type: :computation, success: true
+      )
+      expect(result[:success]).to be true
+      expect(result[:reliability]).to be > 0.5
+    end
+
+    it 'returns error for unknown participant' do
+      result = engine.record_contribution(
+        participant_id: 'bad', contribution_type: :computation, success: true
+      )
+      expect(result[:success]).to be false
+    end
+
+    it 'rejects invalid contribution types' do
+      result = engine.record_contribution(
+        participant_id: agent.id, contribution_type: :invalid, success: true
+      )
+      expect(result[:success]).to be false
+    end
+  end
+
+  describe '#find_capable' do
+    it 'finds participants with capability' do
+      agent
+      results = engine.find_capable(capability: :computation)
+      expect(results.size).to eq(1)
+    end
+
+    it 'returns empty for unknown capability' do
+      agent
+      results = engine.find_capable(capability: :transformation)
+      expect(results).to be_empty
+    end
+  end
+
+  describe '#by_type' do
+    it 'filters by participant type' do
+      agent
+      engine.register_participant(
+        name: 'db', participant_type: :artifact, domain: :storage
+      )
+      agents = engine.by_type(participant_type: :agent)
+      expect(agents.size).to eq(1)
+    end
+  end
+
+  describe '#by_domain' do
+    it 'filters by domain' do
+      agent
+      results = engine.by_domain(domain: :reasoning)
+      expect(results.size).to eq(1)
+    end
+  end
+
+  describe '#most_reliable' do
+    it 'returns sorted by reliability' do
+      agent
+      other = engine.register_participant(
+        name: 'worker-beta', participant_type: :agent, domain: :reasoning
+      )
+      3.times { engine.record_contribution(participant_id: other.id, contribution_type: :computation, success: true) }
+      results = engine.most_reliable(limit: 2)
+      expect(results.first.reliability).to be >= results.last.reliability
+    end
+  end
+
+  describe '#distribution_score' do
+    it 'returns 0.0 with no contributions' do
+      expect(engine.distribution_score).to eq(0.0)
+    end
+
+    it 'returns higher score for even distribution' do
+      other = engine.register_participant(
+        name: 'worker-beta', participant_type: :agent, domain: :reasoning
+      )
+      3.times do
+        engine.record_contribution(participant_id: agent.id, contribution_type: :computation, success: true)
+        engine.record_contribution(participant_id: other.id, contribution_type: :computation, success: true)
+      end
+      expect(engine.distribution_score).to be > 0.5
+    end
+  end
+
+  describe '#distribution_label' do
+    it 'returns a symbol' do
+      expect(engine.distribution_label).to be_a(Symbol)
+    end
+  end
+
+  describe '#decay_all' do
+    it 'reduces reliability of all participants' do
+      original = agent.reliability
+      engine.decay_all
+      expect(agent.reliability).to be < original
+    end
+  end
+
+  describe '#prune_failing' do
+    it 'removes very unreliable participants' do
+      agent
+      30.times { agent.decay! }
+      pruned = engine.prune_failing
+      expect(pruned).to be >= 0
+    end
+  end
+
+  describe '#to_h' do
+    it 'returns summary stats' do
+      agent
+      stats = engine.to_h
+      expect(stats[:total_participants]).to eq(1)
+      expect(stats).to include(:distribution_score, :agent_count)
+    end
+  end
+end

data/spec/legion/extensions/agentic/integration/distributed_cognition/helpers/participant_spec.rb

@@ -0,0 +1,116 @@
+# frozen_string_literal: true
+
+RSpec.describe Legion::Extensions::Agentic::Integration::DistributedCognition::Helpers::Participant do
+  subject(:participant) do
+    described_class.new(
+      name:             'worker-alpha',
+      participant_type: :agent,
+      domain:           :reasoning,
+      capabilities:     %i[computation retrieval]
+    )
+  end
+
+  describe '#initialize' do
+    it 'assigns a UUID' do
+      expect(participant.id).to match(/\A[0-9a-f-]{36}\z/)
+    end
+
+    it 'stores name and type' do
+      expect(participant.name).to eq('worker-alpha')
+      expect(participant.participant_type).to eq(:agent)
+    end
+
+    it 'stores capabilities' do
+      expect(participant.capabilities).to eq(%i[computation retrieval])
+    end
+  end
+
+  describe '#contribute!' do
+    it 'increments contribution count' do
+      expect { participant.contribute!(success: true) }.to change(participant, :contribution_count).by(1)
+    end
+
+    it 'increments success count on success' do
+      expect { participant.contribute!(success: true) }.to change(participant, :success_count).by(1)
+    end
+
+    it 'increases reliability on success' do
+      original = participant.reliability
+      participant.contribute!(success: true)
+      expect(participant.reliability).to be > original
+    end
+
+    it 'decreases reliability on failure' do
+      original = participant.reliability
+      participant.contribute!(success: false)
+      expect(participant.reliability).to be < original
+    end
+  end
+
+  describe '#capable_of?' do
+    it 'returns true for known capability' do
+      expect(participant).to be_capable_of(:computation)
+    end
+
+    it 'returns false for unknown capability' do
+      expect(participant).not_to be_capable_of(:transformation)
+    end
+  end
+
+  describe '#add_capability' do
+    it 'adds a new capability' do
+      participant.add_capability(:storage)
+      expect(participant.capabilities).to include(:storage)
+    end
+
+    it 'does not add duplicates' do
+      2.times { participant.add_capability(:computation) }
+      expect(participant.capabilities.count(:computation)).to eq(1)
+    end
+  end
+
+  describe '#success_rate' do
+    it 'returns 0.0 with no contributions' do
+      expect(participant.success_rate).to eq(0.0)
+    end
+
+    it 'computes ratio' do
+      3.times { participant.contribute!(success: true) }
+      participant.contribute!(success: false)
+      expect(participant.success_rate).to eq(0.75)
+    end
+  end
+
+  describe '#agent?' do
+    it 'returns true for agent type' do
+      expect(participant).to be_agent
+    end
+  end
+
+  describe '#artifact?' do
+    it 'returns false for agent type' do
+      expect(participant).not_to be_artifact
+    end
+  end
+
+  describe '#reliability_label' do
+    it 'returns a symbol' do
+      expect(participant.reliability_label).to be_a(Symbol)
+    end
+  end
+
+  describe '#decay!' do
+    it 'reduces reliability' do
+      original = participant.reliability
+      participant.decay!
+      expect(participant.reliability).to be < original
+    end
+  end
+
+  describe '#to_h' do
+    it 'returns hash representation' do
+      hash = participant.to_h
+      expect(hash).to include(:id, :name, :participant_type, :reliability, :capabilities)
+    end
+  end
+end

data/spec/legion/extensions/agentic/integration/distributed_cognition/runners/distributed_cognition_spec.rb

@@ -0,0 +1,102 @@
+# frozen_string_literal: true
+
+RSpec.describe Legion::Extensions::Agentic::Integration::DistributedCognition::Runners::DistributedCognition do
+  let(:runner_host) do
+    obj = Object.new
+    obj.extend(described_class)
+    obj
+  end
+
+  describe '#register_cognitive_participant' do
+    it 'registers a participant' do
+      result = runner_host.register_cognitive_participant(
+        name: 'worker', participant_type: :agent, domain: :test
+      )
+      expect(result[:success]).to be true
+      expect(result[:participant_id]).to be_a(String)
+    end
+
+    it 'rejects invalid type' do
+      result = runner_host.register_cognitive_participant(
+        name: 'test', participant_type: :invalid, domain: :test
+      )
+      expect(result[:success]).to be false
+    end
+  end
+
+  describe '#record_cognitive_contribution' do
+    it 'records a contribution' do
+      created = runner_host.register_cognitive_participant(
+        name: 'worker', participant_type: :agent, domain: :test
+      )
+      result = runner_host.record_cognitive_contribution(
+        participant_id: created[:participant_id],
+        contribution_type: :computation, success: true
+      )
+      expect(result[:success]).to be true
+    end
+  end
+
+  describe '#find_capable_participants' do
+    it 'finds capable participants' do
+      runner_host.register_cognitive_participant(
+        name: 'worker', participant_type: :agent,
+        domain: :test, capabilities: [:computation]
+      )
+      result = runner_host.find_capable_participants(capability: :computation)
+      expect(result[:success]).to be true
+      expect(result[:count]).to eq(1)
+    end
+  end
+
+  describe '#most_reliable_participants' do
+    it 'returns reliable participants' do
+      result = runner_host.most_reliable_participants(limit: 3)
+      expect(result[:success]).to be true
+    end
+  end
+
+  describe '#distribution_assessment' do
+    it 'returns distribution metrics' do
+      result = runner_host.distribution_assessment
+      expect(result[:success]).to be true
+      expect(result).to include(:distribution_score, :distribution_label)
+    end
+  end
+
+  describe '#participants_by_type' do
+    it 'filters by type' do
+      runner_host.register_cognitive_participant(
+        name: 'db', participant_type: :artifact, domain: :storage
+      )
+      result = runner_host.participants_by_type(participant_type: :artifact)
+      expect(result[:count]).to eq(1)
+    end
+  end
+
+  describe '#participants_by_domain' do
+    it 'filters by domain' do
+      runner_host.register_cognitive_participant(
+        name: 'worker', participant_type: :agent, domain: :reasoning
+      )
+      result = runner_host.participants_by_domain(domain: :reasoning)
+      expect(result[:count]).to eq(1)
+    end
+  end
+
+  describe '#update_distributed_cognition' do
+    it 'runs decay and prune cycle' do
+      result = runner_host.update_distributed_cognition
+      expect(result[:success]).to be true
+      expect(result).to include(:pruned)
+    end
+  end
+
+  describe '#distributed_cognition_stats' do
+    it 'returns stats' do
+      result = runner_host.distributed_cognition_stats
+      expect(result[:success]).to be true
+      expect(result).to include(:total_participants, :distribution_score)
+    end
+  end
+end

data/spec/legion/extensions/agentic/integration/gestalt/client_spec.rb

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+RSpec.describe Legion::Extensions::Agentic::Integration::Gestalt::Client do
+  subject(:client) { described_class.new }
+
+  describe '#initialize' do
+    it 'creates a default store' do
+      expect(client.store).to be_a(Legion::Extensions::Agentic::Integration::Gestalt::Helpers::PatternStore)
+    end
+
+    it 'accepts an injected store' do
+      custom = Legion::Extensions::Agentic::Integration::Gestalt::Helpers::PatternStore.new
+      injected = described_class.new(store: custom)
+      expect(injected.store).to equal(custom)
+    end
+  end
+
+  describe 'gestalt pattern completion lifecycle' do
+    it 'learns patterns and completes fragments' do
+      # Learn some patterns
+      client.learn_pattern(name: :greeting, elements: %i[hello how are you today], domain: :social)
+      client.learn_pattern(name: :farewell, elements: %i[goodbye see you later], domain: :social)
+      client.learn_pattern(name: :fibonacci, elements: [1, 1, 2, 3, 5, 8, 13], domain: :math)
+
+      # Complete a partial greeting
+      result = client.complete_pattern(fragment: %i[hello how are])
+      expect(result[:count]).to eq(1)
+      expect(result[:best][:pattern_name]).to eq(:greeting)
+      expect(result[:best][:missing]).to eq(%i[you today])
+
+      # Confirm the completion was correct -> reinforces pattern
+      client.confirm_completion(pattern_id: result[:best][:pattern_id], correct: true)
+
+      # Try completing a math pattern
+      math_result = client.complete_pattern(fragment: [1, 1, 2, 3], domain: :math)
+      expect(math_result[:count]).to eq(1)
+      expect(math_result[:best][:missing]).to eq([5, 8, 13])
+
+      # Group items by proximity
+      groups = client.group_items(items: [1, 2, 3, 50, 51, 52], principle: :proximity)
+      expect(groups[:group_count]).to be >= 2
+
+      # Decay over time
+      client.update_gestalt
+
+      # Stats
+      stats = client.gestalt_stats
+      expect(stats[:stats][:pattern_count]).to eq(3)
+    end
+  end
+end

data/spec/legion/extensions/agentic/integration/gestalt/helpers/constants_spec.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+RSpec.describe Legion::Extensions::Agentic::Integration::Gestalt::Helpers::Constants do
+  describe 'COMPLETION_THRESHOLD' do
+    it 'is between 0 and 1' do
+      expect(described_class::COMPLETION_THRESHOLD).to be_between(0.0, 1.0).exclusive
+    end
+  end
+
+  describe 'GROUPING_PRINCIPLES' do
+    it 'includes all Wertheimer laws' do
+      expect(described_class::GROUPING_PRINCIPLES).to include(:proximity, :similarity, :closure)
+    end
+
+    it 'is frozen' do
+      expect(described_class::GROUPING_PRINCIPLES).to be_frozen
+    end
+  end
+
+  describe 'reinforcement asymmetry' do
+    it 'penalizes more than reinforces' do
+      expect(described_class::INCORRECT_PENALTY).to be > described_class::CORRECT_REINFORCEMENT
+    end
+  end
+end

data/spec/legion/extensions/agentic/integration/gestalt/helpers/pattern_spec.rb

@@ -0,0 +1,128 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+RSpec.describe Legion::Extensions::Agentic::Integration::Gestalt::Helpers::Pattern do
+  subject(:pattern) { described_class.new(name: :abc_sequence, elements: %i[a b c d e]) }
+
+  describe '#initialize' do
+    it 'generates a uuid' do
+      expect(pattern.id).to match(/\A[0-9a-f-]{36}\z/)
+    end
+
+    it 'stores name and elements' do
+      expect(pattern.name).to eq(:abc_sequence)
+      expect(pattern.elements).to eq(%i[a b c d e])
+    end
+
+    it 'defaults domain to general' do
+      expect(pattern.domain).to eq(:general)
+    end
+
+    it 'starts with strength 1.0' do
+      expect(pattern.strength).to eq(1.0)
+    end
+
+    it 'starts with zero match count' do
+      expect(pattern.match_count).to eq(0)
+    end
+
+    it 'truncates elements at MAX_PATTERN_SIZE' do
+      big = described_class.new(name: :big, elements: (1..100).to_a)
+      expect(big.elements.size).to eq(Legion::Extensions::Agentic::Integration::Gestalt::Helpers::Constants::MAX_PATTERN_SIZE)
+    end
+  end
+
+  describe '#match_ratio' do
+    it 'returns 1.0 for perfect match' do
+      expect(pattern.match_ratio(%i[a b c d e])).to eq(1.0)
+    end
+
+    it 'returns 0.0 for no match' do
+      expect(pattern.match_ratio(%i[x y z])).to eq(0.0)
+    end
+
+    it 'returns partial ratio' do
+      expect(pattern.match_ratio(%i[a b c])).to eq(0.6)
+    end
+
+    it 'returns 0.0 for empty fragment' do
+      expect(pattern.match_ratio([])).to eq(0.0)
+    end
+  end
+
+  describe '#missing_elements' do
+    it 'returns elements not in fragment' do
+      expect(pattern.missing_elements(%i[a b c])).to eq(%i[d e])
+    end
+
+    it 'returns all elements for empty fragment' do
+      expect(pattern.missing_elements([])).to eq(%i[a b c d e])
+    end
+
+    it 'returns empty for complete fragment' do
+      expect(pattern.missing_elements(%i[a b c d e])).to eq([])
+    end
+  end
+
+  describe '#complete' do
+    it 'returns completion for sufficient match' do
+      result = pattern.complete(%i[a b c])
+      expect(result).not_to be_nil
+      expect(result[:pattern_name]).to eq(:abc_sequence)
+      expect(result[:missing]).to eq(%i[d e])
+      expect(result[:confidence]).to be > 0
+    end
+
+    it 'returns nil for insufficient match' do
+      result = pattern.complete(%i[x])
+      expect(result).to be_nil
+    end
+
+    it 'increments match count' do
+      pattern.complete(%i[a b c])
+      expect(pattern.match_count).to eq(1)
+    end
+  end
+
+  describe '#reinforce' do
+    it 'increases strength' do
+      initial = pattern.strength
+      pattern.reinforce
+      expect(pattern.strength).to be > initial
+    end
+
+    it 'caps at 2.0' do
+      20.times { pattern.reinforce }
+      expect(pattern.strength).to eq(2.0)
+    end
+  end
+
+  describe '#penalize' do
+    it 'decreases strength' do
+      initial = pattern.strength
+      pattern.penalize
+      expect(pattern.strength).to be < initial
+    end
+
+    it 'floors at 0.1' do
+      20.times { pattern.penalize }
+      expect(pattern.strength).to eq(0.1)
+    end
+  end
+
+  describe '#decay' do
+    it 'slowly reduces strength' do
+      initial = pattern.strength
+      pattern.decay
+      expect(pattern.strength).to be < initial
+    end
+  end
+
+  describe '#to_h' do
+    it 'returns all fields' do
+      h = pattern.to_h
+      expect(h).to include(:id, :name, :domain, :elements, :strength, :match_count, :size)
+    end
+  end
+end