lex-mesh 0.1.1 → 0.2.3

data/spec/legion/extensions/mesh/actors/preference_listener_spec.rb

@@ -0,0 +1,87 @@
+# frozen_string_literal: true
+
+# Stub the framework subscription base class
+unless defined?(Legion::Extensions::Actors::Subscription)
+  module Legion
+    module Extensions
+      module Actors
+        class Subscription # rubocop:disable Lint/EmptyClass
+        end
+      end
+    end
+  end
+
+  $LOADED_FEATURES << 'legion/extensions/actors/subscription'
+end
+
+# Stub transport queue base classes if not loaded
+unless defined?(Legion::Transport::Queues::Agent)
+  module Legion
+    module Transport
+      module Queues
+        class Agent # rubocop:disable Lint/EmptyClass
+        end
+      end
+    end
+  end
+end
+
+require 'legion/extensions/mesh/transport/queues/preference'
+require 'legion/extensions/mesh/runners/preferences'
+require 'legion/extensions/mesh/actors/preference_listener'
+
+RSpec.describe Legion::Extensions::Mesh::Actor::PreferenceListener do
+  subject(:actor) { described_class.new }
+
+  describe '#runner_class' do
+    it 'returns the Preferences runner module' do
+      expect(actor.runner_class).to eq(Legion::Extensions::Mesh::Runners::Preferences)
+    end
+  end
+
+  describe '#runner_function' do
+    it 'returns dispatch_preference_message' do
+      expect(actor.runner_function).to eq('dispatch_preference_message')
+    end
+  end
+
+  describe '#check_subtask?' do
+    it 'returns false' do
+      expect(actor.check_subtask?).to be false
+    end
+  end
+
+  describe '#generate_task?' do
+    it 'returns false' do
+      expect(actor.generate_task?).to be false
+    end
+  end
+
+  describe '#use_runner?' do
+    it 'returns false' do
+      expect(actor.use_runner?).to be false
+    end
+  end
+
+  describe '#queue' do
+    it 'returns the Preference queue class' do
+      expect(actor.queue).to eq(Legion::Extensions::Mesh::Transport::Queues::Preference)
+    end
+  end
+
+  describe '#enabled?' do
+    context 'when transport is available' do
+      it 'returns truthy' do
+        stub_const('Legion::Transport', Module.new)
+        expect(actor.enabled?).to be_truthy
+      end
+    end
+
+    context 'when transport is not available' do
+      it 'returns falsey' do
+        hide_const('Legion::Transport')
+        expect(actor.enabled?).to be_falsey
+      end
+    end
+  end
+end

data/spec/legion/extensions/mesh/actors/silence_watchdog_spec.rb

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+unless defined?(Legion::Extensions::Actors::Every)
+  module Legion
+    module Extensions
+      module Actors
+        class Every; end # rubocop:disable Lint/EmptyClass
+      end
+    end
+  end
+end
+
+require 'legion/extensions/mesh/actors/silence_watchdog'
+
+RSpec.describe Legion::Extensions::Mesh::Actor::SilenceWatchdog do
+  subject(:actor) { described_class.allocate }
+
+  describe '#runner_class' do
+    it 'returns the Mesh runner module' do
+      expect(actor.runner_class).to eq(Legion::Extensions::Mesh::Runners::Mesh)
+    end
+  end
+
+  describe '#runner_function' do
+    it 'returns expire_silent_agents' do
+      expect(actor.runner_function).to eq('expire_silent_agents')
+    end
+  end
+
+  describe '#time' do
+    it 'returns 15' do
+      expect(actor.time).to eq(15)
+    end
+  end
+
+  describe '#use_runner?' do
+    it 'returns false' do
+      expect(actor.use_runner?).to be false
+    end
+  end
+
+  describe '#check_subtask?' do
+    it 'returns false' do
+      expect(actor.check_subtask?).to be false
+    end
+  end
+
+  describe '#generate_task?' do
+    it 'returns false' do
+      expect(actor.generate_task?).to be false
+    end
+  end
+end

data/spec/legion/extensions/mesh/client_spec.rb

@@ -3,8 +3,9 @@
 require 'legion/extensions/mesh/client'
 
 RSpec.describe Legion::Extensions::Mesh::Client do
+  let(:client) { described_class.new }
+
   it 'responds to mesh runner methods' do
-    client = described_class.new
     expect(client).to respond_to(:register)
     expect(client).to respond_to(:unregister)
     expect(client).to respond_to(:heartbeat)
@@ -12,4 +13,42 @@ RSpec.describe Legion::Extensions::Mesh::Client do
     expect(client).to respond_to(:find_agents)
     expect(client).to respond_to(:mesh_status)
   end
+
+  it 'responds to preference runner methods' do
+    expect(client).to respond_to(:query_preferences)
+    expect(client).to respond_to(:handle_preference_query)
+    expect(client).to respond_to(:handle_preference_response)
+    expect(client).to respond_to(:expire_pending_requests)
+  end
+
+  describe '#query_preferences' do
+    it 'returns a result hash with success key' do
+      result = client.query_preferences(target_agent_id: 'agent-1')
+      expect(result).to have_key(:success)
+      expect(result[:success]).to be true
+    end
+  end
+
+  describe '#handle_preference_query' do
+    it 'returns local profile' do
+      result = client.handle_preference_query(requesting_agent_id: 'agent-1')
+      expect(result[:success]).to be true
+      expect(result[:profile]).to be_a(Hash)
+    end
+  end
+
+  describe '#handle_preference_response' do
+    it 'returns resolved false for unknown id' do
+      result = client.handle_preference_response(correlation_id: 'nope', profile: {})
+      expect(result[:resolved]).to be false
+    end
+  end
+
+  describe '#expire_pending_requests' do
+    it 'returns expiry summary' do
+      result = client.expire_pending_requests
+      expect(result).to have_key(:expired)
+      expect(result[:expired]).to eq(0)
+    end
+  end
 end

data/spec/legion/extensions/mesh/helpers/pending_requests_spec.rb

@@ -0,0 +1,80 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+require 'legion/extensions/mesh/helpers/pending_requests'
+
+RSpec.describe Legion::Extensions::Mesh::Helpers::PendingRequests do
+  subject(:tracker) { described_class.new(default_ttl: 5) }
+
+  describe '#register' do
+    it 'stores a pending request' do
+      tracker.register(correlation_id: 'abc', callback: ->(_r) {})
+      expect(tracker.pending?('abc')).to be true
+    end
+
+    it 'increments pending_count' do
+      expect { tracker.register(correlation_id: 'x', callback: nil) }
+        .to change { tracker.pending_count }.by(1)
+    end
+  end
+
+  describe '#resolve' do
+    it 'invokes callback and removes entry' do
+      received = nil
+      tracker.register(correlation_id: 'r1', callback: ->(result) { received = result })
+      result = tracker.resolve(correlation_id: 'r1', result: { verbosity: :concise })
+      expect(result).to be true
+      expect(received).to eq({ verbosity: :concise })
+      expect(tracker.pending?('r1')).to be false
+    end
+
+    it 'returns false for unknown correlation_id' do
+      result = tracker.resolve(correlation_id: 'nonexistent', result: {})
+      expect(result).to be false
+    end
+
+    it 'handles nil callback gracefully' do
+      tracker.register(correlation_id: 'nil-cb', callback: nil)
+      expect { tracker.resolve(correlation_id: 'nil-cb', result: {}) }.not_to raise_error
+    end
+  end
+
+  describe '#pending?' do
+    it 'returns false for unregistered id' do
+      expect(tracker.pending?('missing')).to be false
+    end
+  end
+
+  describe '#pending_count' do
+    it 'returns correct count' do
+      tracker.register(correlation_id: 'a', callback: nil)
+      tracker.register(correlation_id: 'b', callback: nil)
+      expect(tracker.pending_count).to eq(2)
+    end
+  end
+
+  describe '#expire' do
+    it 'removes entries past TTL' do
+      tracker.register(correlation_id: 'old', callback: nil, ttl: 1)
+      entry = tracker.instance_variable_get(:@requests)['old']
+      entry[:registered_at] = Time.now - 10
+      expired = tracker.expire
+      expect(expired).to include('old')
+      expect(tracker.pending?('old')).to be false
+    end
+
+    it 'does not remove entries within TTL' do
+      tracker.register(correlation_id: 'fresh', callback: nil, ttl: 60)
+      tracker.expire
+      expect(tracker.pending?('fresh')).to be true
+    end
+
+    it 'returns array of expired correlation ids' do
+      tracker.register(correlation_id: 'e1', callback: nil, ttl: 1)
+      tracker.register(correlation_id: 'e2', callback: nil, ttl: 1)
+      tracker.instance_variable_get(:@requests).each_value { |e| e[:registered_at] = Time.now - 10 }
+      expired = tracker.expire
+      expect(expired).to contain_exactly('e1', 'e2')
+    end
+  end
+end

data/spec/legion/extensions/mesh/helpers/registry_spec.rb

@@ -272,6 +272,47 @@ RSpec.describe Legion::Extensions::Mesh::Helpers::Registry do
     end
   end
 
+  describe '#expire_silent_agents' do
+    it 'marks stale agents as offline' do
+      registry.register_agent('a1')
+      registry.agents['a1'][:last_seen] = Time.now.utc - 60
+      expired = registry.expire_silent_agents(timeout: 30)
+      expect(expired).to eq(['a1'])
+      expect(registry.agents['a1'][:status]).to eq(:offline)
+    end
+
+    it 'does not expire agents within timeout' do
+      registry.register_agent('a1')
+      expired = registry.expire_silent_agents(timeout: 30)
+      expect(expired).to eq([])
+      expect(registry.agents['a1'][:status]).to eq(:online)
+    end
+
+    it 'does not expire already-offline agents' do
+      registry.register_agent('a1')
+      registry.agents['a1'][:last_seen] = Time.now.utc - 60
+      registry.agents['a1'][:status] = :offline
+      expired = registry.expire_silent_agents(timeout: 30)
+      expect(expired).to eq([])
+    end
+
+    it 'returns multiple expired agent ids' do
+      registry.register_agent('a1')
+      registry.register_agent('a2')
+      registry.agents['a1'][:last_seen] = Time.now.utc - 60
+      registry.agents['a2'][:last_seen] = Time.now.utc - 60
+      expired = registry.expire_silent_agents(timeout: 30)
+      expect(expired).to contain_exactly('a1', 'a2')
+    end
+
+    it 'uses MESH_SILENCE_TIMEOUT as default' do
+      registry.register_agent('a1')
+      registry.agents['a1'][:last_seen] = Time.now.utc - 31
+      expired = registry.expire_silent_agents
+      expect(expired).to eq(['a1'])
+    end
+  end
+
   describe '#count' do
     it 'returns 0 for an empty registry' do
       expect(registry.count).to eq(0)

data/spec/legion/extensions/mesh/runners/mesh_spec.rb

@@ -23,6 +23,22 @@ RSpec.describe Legion::Extensions::Mesh::Runners::Mesh do
       result = client.unregister(agent_id: 'unknown')
       expect(result[:error]).to eq(:not_found)
     end
+
+    it 'publishes mesh departure signal when transport available' do
+      client.register(agent_id: 'agent-1', capabilities: [:search])
+
+      mock_msg = instance_double('MeshDeparture', publish: nil)
+      stub_const('Legion::Extensions::Mesh::Transport::Messages::MeshDeparture', class_double('MeshDeparture', new: mock_msg))
+
+      client.unregister(agent_id: 'agent-1')
+      expect(mock_msg).to have_received(:publish)
+    end
+
+    it 'succeeds without transport available' do
+      client.register(agent_id: 'agent-1')
+      result = client.unregister(agent_id: 'agent-1')
+      expect(result[:unregistered]).to be true
+    end
   end
 
   describe '#send_message' do
@@ -65,4 +81,13 @@ RSpec.describe Legion::Extensions::Mesh::Runners::Mesh do
       expect(status[:online]).to eq(1)
     end
   end
+
+  describe '#expire_silent_agents' do
+    it 'returns expired agent count' do
+      client.register(agent_id: 'a1')
+      result = client.expire_silent_agents
+      expect(result[:success]).to be true
+      expect(result[:count]).to eq(0)
+    end
+  end
 end

data/spec/legion/extensions/mesh/runners/preferences_spec.rb

@@ -0,0 +1,164 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+require 'legion/extensions/mesh/helpers/pending_requests'
+require 'legion/extensions/mesh/helpers/preference_profile'
+require 'legion/extensions/mesh/runners/preferences'
+
+RSpec.describe Legion::Extensions::Mesh::Runners::Preferences do
+  let(:runner) { Object.new.extend(described_class) }
+
+  describe '#query_preferences' do
+    context 'without transport' do
+      it 'returns local_default profile' do
+        result = runner.query_preferences(target_agent_id: 'agent-99')
+        expect(result[:success]).to be true
+        expect(result[:source]).to eq(:local_default)
+        expect(result[:profile]).to be_a(Hash)
+      end
+
+      it 'includes default preference keys in profile' do
+        result = runner.query_preferences(target_agent_id: 'agent-99')
+        expect(result[:profile]).to have_key(:verbosity)
+        expect(result[:profile]).to have_key(:tone)
+      end
+    end
+
+    context 'with transport available' do
+      before do
+        stub_const('Legion::Transport::Connection', Class.new do
+          def self.session; end
+        end)
+        stub_const('Legion::Extensions::Mesh::Transport::Messages::PreferenceQuery',
+                   Class.new do
+                     def initialize(**_opts); end
+
+                     def publish; end
+                   end)
+      end
+
+      it 'returns pending status with correlation_id' do
+        result = runner.query_preferences(target_agent_id: 'agent-42')
+        expect(result[:success]).to be true
+        expect(result[:source]).to eq(:pending)
+        expect(result[:correlation_id]).to be_a(String)
+        expect(result[:correlation_id]).not_to be_empty
+      end
+
+      it 'registers a pending request' do
+        result = runner.query_preferences(target_agent_id: 'agent-42')
+        pending_req = runner.send(:pending_requests)
+        expect(pending_req.pending?(result[:correlation_id])).to be true
+      end
+    end
+  end
+
+  describe '#handle_preference_query' do
+    it 'returns local profile' do
+      result = runner.handle_preference_query(requesting_agent_id: 'agent-1')
+      expect(result[:success]).to be true
+      expect(result[:profile]).to be_a(Hash)
+      expect(result[:responding_agent_id]).not_to be_nil
+    end
+
+    it 'includes verbosity in profile' do
+      result = runner.handle_preference_query(requesting_agent_id: 'agent-1')
+      expect(result[:profile]).to have_key(:verbosity)
+    end
+  end
+
+  describe '#handle_preference_response' do
+    it 'resolves a pending request' do
+      received = nil
+      pending_req = runner.send(:pending_requests)
+      pending_req.register(
+        correlation_id: 'corr-1',
+        callback:       ->(profile) { received = profile }
+      )
+      result = runner.handle_preference_response(
+        correlation_id: 'corr-1',
+        profile:        { verbosity: :concise }
+      )
+      expect(result[:resolved]).to be true
+      expect(received).to eq({ verbosity: :concise })
+    end
+
+    it 'returns false for unknown correlation_id' do
+      result = runner.handle_preference_response(
+        correlation_id: 'unknown-corr',
+        profile:        {}
+      )
+      expect(result[:resolved]).to be false
+    end
+  end
+
+  describe '#dispatch_preference_message' do
+    context 'with preference_query type' do
+      it 'calls handle_preference_query and returns profile' do
+        result = runner.dispatch_preference_message(
+          type:                'preference_query',
+          requesting_agent_id: 'agent-1',
+          correlation_id:      'corr-123'
+        )
+        expect(result[:success]).to be true
+        expect(result[:profile]).to be_a(Hash)
+      end
+    end
+
+    context 'with preference_response type' do
+      it 'resolves a pending request' do
+        pending_req = runner.send(:pending_requests)
+        pending_req.register(correlation_id: 'corr-abc', callback: ->(_p) {})
+        result = runner.dispatch_preference_message(
+          type:           'preference_response',
+          correlation_id: 'corr-abc',
+          profile:        { verbosity: :concise }
+        )
+        expect(result[:resolved]).to be true
+      end
+
+      it 'returns false for unknown correlation_id' do
+        result = runner.dispatch_preference_message(
+          type:           'preference_response',
+          correlation_id: 'unknown',
+          profile:        {}
+        )
+        expect(result[:resolved]).to be false
+      end
+    end
+
+    context 'with unknown type' do
+      it 'returns error' do
+        result = runner.dispatch_preference_message(type: 'bogus')
+        expect(result[:success]).to be false
+        expect(result[:error]).to include('unknown')
+      end
+    end
+
+    context 'with nil type' do
+      it 'returns error' do
+        result = runner.dispatch_preference_message(type: nil)
+        expect(result[:success]).to be false
+      end
+    end
+  end
+
+  describe '#expire_pending_requests' do
+    it 'cleans up expired entries and returns count' do
+      pending_req = runner.send(:pending_requests)
+      pending_req.register(correlation_id: 'old-1', callback: nil, ttl: 1)
+      pending_req.register(correlation_id: 'old-2', callback: nil, ttl: 1)
+      pending_req.instance_variable_get(:@requests).each_value { |e| e[:registered_at] = Time.now - 60 }
+
+      result = runner.expire_pending_requests
+      expect(result[:expired]).to eq(2)
+      expect(result[:correlation_ids]).to contain_exactly('old-1', 'old-2')
+    end
+
+    it 'returns zero when nothing expired' do
+      result = runner.expire_pending_requests
+      expect(result[:expired]).to eq(0)
+      expect(result[:correlation_ids]).to be_empty
+    end
+  end
+end

data/spec/legion/extensions/mesh/transport/messages/mesh_departure_spec.rb

@@ -0,0 +1,81 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+unless defined?(Legion::Transport::Message)
+  module Legion
+    module Transport
+      class Message
+        def initialize(**options)
+          @options = options
+        end
+      end
+    end
+  end
+end
+
+unless defined?(Legion::Transport::Exchanges::Node)
+  module Legion
+    module Transport
+      module Exchanges
+        class Node # rubocop:disable Lint/EmptyClass
+        end
+      end
+    end
+  end
+end
+
+require 'legion/extensions/mesh/transport/messages/mesh_departure'
+
+RSpec.describe Legion::Extensions::Mesh::Transport::Messages::MeshDeparture do
+  subject(:msg) do
+    described_class.new(
+      agent_id:     'agent-42',
+      capabilities: %i[code_review search]
+    )
+  end
+
+  describe '#exchange' do
+    it 'returns the Node exchange' do
+      expect(msg.exchange).to eq(Legion::Transport::Exchanges::Node)
+    end
+  end
+
+  describe '#routing_key' do
+    it 'uses mesh.departure' do
+      expect(msg.routing_key).to eq('mesh.departure')
+    end
+  end
+
+  describe '#message' do
+    it 'includes type mesh_departure' do
+      expect(msg.message[:type]).to eq('mesh_departure')
+    end
+
+    it 'includes agent_id' do
+      expect(msg.message[:agent_id]).to eq('agent-42')
+    end
+
+    it 'includes capabilities' do
+      expect(msg.message[:capabilities]).to eq(%i[code_review search])
+    end
+
+    it 'includes departed_at timestamp' do
+      expect(msg.message[:departed_at]).to be_a(String)
+    end
+  end
+
+  describe '#type' do
+    it 'returns mesh_departure' do
+      expect(msg.type).to eq('mesh_departure')
+    end
+  end
+
+  describe 'empty capabilities default' do
+    subject(:msg_no_caps) { described_class.new(agent_id: 'x') }
+
+    it 'defaults capabilities to empty array' do
+      expect(msg_no_caps.message[:capabilities]).to eq([])
+    end
+  end
+end

data/spec/legion/extensions/mesh/transport/messages/preference_query_spec.rb

@@ -0,0 +1,85 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+unless defined?(Legion::Transport::Message)
+  module Legion
+    module Transport
+      class Message
+        def initialize(**options)
+          @options = options
+        end
+      end
+    end
+  end
+end
+
+unless defined?(Legion::Transport::Exchanges::Agent)
+  module Legion
+    module Transport
+      module Exchanges
+        class Agent
+          def self.name
+            'Legion::Transport::Exchanges::Agent'
+          end
+        end
+      end
+    end
+  end
+end
+
+require 'legion/extensions/mesh/transport/messages/preference_query'
+
+RSpec.describe Legion::Extensions::Mesh::Transport::Messages::PreferenceQuery do
+  subject(:msg) do
+    described_class.new(
+      target_agent_id:     'agent-42',
+      requesting_agent_id: 'agent-1',
+      domains:             %i[verbosity tone]
+    )
+  end
+
+  describe '#exchange' do
+    it 'returns the Agent exchange' do
+      expect(msg.exchange).to eq(Legion::Transport::Exchanges::Agent)
+    end
+  end
+
+  describe '#routing_key' do
+    it 'routes to target agent' do
+      expect(msg.routing_key).to eq('agent.agent-42.preferences')
+    end
+  end
+
+  describe '#message' do
+    it 'includes type preference_query' do
+      expect(msg.message[:type]).to eq('preference_query')
+    end
+
+    it 'includes requesting_agent_id' do
+      expect(msg.message[:requesting_agent_id]).to eq('agent-1')
+    end
+
+    it 'includes domains' do
+      expect(msg.message[:domains]).to eq(%i[verbosity tone])
+    end
+
+    it 'includes requested_at timestamp' do
+      expect(msg.message[:requested_at]).to be_a(String)
+    end
+  end
+
+  describe '#type' do
+    it 'returns preference_query' do
+      expect(msg.type).to eq('preference_query')
+    end
+  end
+
+  describe 'empty domains default' do
+    subject(:msg_no_domains) { described_class.new(target_agent_id: 'x', requesting_agent_id: 'y') }
+
+    it 'defaults domains to empty array' do
+      expect(msg_no_domains.message[:domains]).to eq([])
+    end
+  end
+end