lex-apollo 0.2.0

data/spec/legion/extensions/apollo/runners/knowledge_spec.rb

@@ -0,0 +1,308 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+require 'legion/extensions/apollo/helpers/confidence'
+require 'legion/extensions/apollo/helpers/similarity'
+require 'legion/extensions/apollo/helpers/embedding'
+require 'legion/extensions/apollo/helpers/graph_query'
+require 'legion/extensions/apollo/runners/knowledge'
+
+RSpec.describe Legion::Extensions::Apollo::Runners::Knowledge do
+  let(:runner) do
+    obj = Object.new
+    obj.extend(described_class)
+    obj
+  end
+
+  describe '#store_knowledge' do
+    it 'returns a message payload hash' do
+      result = runner.store_knowledge(
+        content:      'Vault namespace ash1234 uses PKI',
+        content_type: :fact,
+        tags:         %w[vault pki]
+      )
+      expect(result).to be_a(Hash)
+      expect(result[:action]).to eq(:store)
+      expect(result[:content]).to eq('Vault namespace ash1234 uses PKI')
+      expect(result[:content_type]).to eq(:fact)
+      expect(result[:tags]).to eq(%w[vault pki])
+    end
+
+    it 'includes source_agent when provided' do
+      result = runner.store_knowledge(
+        content: 'test', content_type: :fact, source_agent: 'worker-1'
+      )
+      expect(result[:source_agent]).to eq('worker-1')
+    end
+
+    it 'rejects invalid content_type' do
+      expect do
+        runner.store_knowledge(content: 'test', content_type: :invalid)
+      end.to raise_error(ArgumentError, /content_type/)
+    end
+  end
+
+  describe '#query_knowledge' do
+    it 'returns a query payload hash' do
+      result = runner.query_knowledge(query: 'PKI configuration')
+      expect(result[:action]).to eq(:query)
+      expect(result[:query]).to eq('PKI configuration')
+      expect(result[:limit]).to eq(10)
+      expect(result[:min_confidence]).to eq(0.3)
+    end
+
+    it 'accepts custom limit and filters' do
+      result = runner.query_knowledge(
+        query: 'vault', limit: 5, min_confidence: 0.5,
+        status: [:confirmed], tags: %w[vault]
+      )
+      expect(result[:limit]).to eq(5)
+      expect(result[:min_confidence]).to eq(0.5)
+      expect(result[:status]).to eq([:confirmed])
+      expect(result[:tags]).to eq(%w[vault])
+    end
+  end
+
+  describe '#related_entries' do
+    it 'returns a traversal payload hash' do
+      result = runner.related_entries(entry_id: 'uuid-123')
+      expect(result[:action]).to eq(:traverse)
+      expect(result[:entry_id]).to eq('uuid-123')
+      expect(result[:depth]).to eq(2)
+    end
+
+    it 'accepts relation_types filter' do
+      result = runner.related_entries(
+        entry_id: 'uuid-123', relation_types: %w[causes depends_on], depth: 3
+      )
+      expect(result[:relation_types]).to eq(%w[causes depends_on])
+      expect(result[:depth]).to eq(3)
+    end
+  end
+
+  describe '#deprecate_entry' do
+    it 'returns a deprecate payload' do
+      result = runner.deprecate_entry(entry_id: 'uuid-123', reason: 'outdated')
+      expect(result[:action]).to eq(:deprecate)
+      expect(result[:entry_id]).to eq('uuid-123')
+      expect(result[:reason]).to eq('outdated')
+    end
+  end
+
+  describe '#handle_ingest' do
+    let(:host) { Object.new.extend(described_class) }
+
+    context 'when Apollo data is not available' do
+      before { hide_const('Legion::Data::Model::ApolloEntry') if defined?(Legion::Data::Model::ApolloEntry) }
+
+      it 'returns a structured error' do
+        result = host.handle_ingest(content: 'test', content_type: 'fact')
+        expect(result[:success]).to be false
+        expect(result[:error]).to eq('apollo_data_not_available')
+      end
+    end
+
+    context 'when Apollo data is available' do
+      let(:mock_entry_class) { double('ApolloEntry') }
+      let(:mock_relation_class) { double('ApolloRelation') }
+      let(:mock_expertise_class) { double('ApolloExpertise') }
+      let(:mock_access_log_class) { double('ApolloAccessLog') }
+      let(:mock_entry) { double('entry', id: 'uuid-123', embedding: nil) }
+      let(:empty_dataset) { double('dataset', each: nil) }
+
+      before do
+        stub_const('Legion::Data::Model::ApolloEntry', mock_entry_class)
+        stub_const('Legion::Data::Model::ApolloRelation', mock_relation_class)
+        stub_const('Legion::Data::Model::ApolloExpertise', mock_expertise_class)
+        stub_const('Legion::Data::Model::ApolloAccessLog', mock_access_log_class)
+        allow(Legion::Extensions::Apollo::Helpers::Embedding).to receive(:generate)
+          .and_return(Array.new(1536, 0.0))
+
+        allow(mock_entry_class).to receive(:where).and_return(double(exclude: double(limit: empty_dataset)))
+        allow(mock_entry_class).to receive(:create).and_return(mock_entry)
+        allow(mock_expertise_class).to receive(:where).and_return(double(first: nil))
+        allow(mock_expertise_class).to receive(:create)
+        allow(mock_access_log_class).to receive(:create)
+      end
+
+      it 'creates a new candidate entry when novel' do
+        result = host.handle_ingest(content: 'Ruby is great', content_type: 'fact',
+                                    tags: ['ruby'], source_agent: 'agent-1')
+        expect(result[:success]).to be true
+        expect(result[:status]).to eq('candidate')
+        expect(result[:corroborated]).to be false
+      end
+
+      it 'creates expertise record for source agent' do
+        expect(mock_expertise_class).to receive(:create).with(
+          hash_including(agent_id: 'agent-1', domain: 'ruby')
+        )
+        host.handle_ingest(content: 'Ruby is great', content_type: 'fact',
+                           tags: ['ruby'], source_agent: 'agent-1')
+      end
+
+      it 'logs access' do
+        expect(mock_access_log_class).to receive(:create).with(
+          hash_including(agent_id: 'agent-1', action: 'ingest')
+        )
+        host.handle_ingest(content: 'Ruby is great', content_type: 'fact',
+                           tags: ['ruby'], source_agent: 'agent-1')
+      end
+
+      it 'defaults domain to general when no tags' do
+        expect(mock_expertise_class).to receive(:create).with(
+          hash_including(domain: 'general')
+        )
+        host.handle_ingest(content: 'test', content_type: 'fact', source_agent: 'agent-1')
+      end
+    end
+
+    context 'when Sequel raises an error' do
+      before do
+        stub_const('Legion::Data::Model::ApolloEntry', Class.new)
+        allow(Legion::Extensions::Apollo::Helpers::Embedding).to receive(:generate)
+          .and_return(Array.new(1536, 0.0))
+        allow(Legion::Data::Model::ApolloEntry).to receive(:where)
+          .and_raise(Sequel::Error, 'connection lost')
+      end
+
+      it 'returns a structured error' do
+        result = host.handle_ingest(content: 'test', content_type: 'fact', source_agent: 'a')
+        expect(result[:success]).to be false
+        expect(result[:error]).to eq('connection lost')
+      end
+    end
+  end
+
+  describe '#handle_query' do
+    let(:host) { Object.new.extend(described_class) }
+
+    context 'when Apollo data is not available' do
+      before { hide_const('Legion::Data::Model::ApolloEntry') if defined?(Legion::Data::Model::ApolloEntry) }
+
+      it 'returns a structured error' do
+        result = host.handle_query(query: 'test')
+        expect(result[:success]).to be false
+        expect(result[:error]).to eq('apollo_data_not_available')
+      end
+    end
+
+    context 'when Apollo data is available' do
+      let(:mock_entry_class) { double('ApolloEntry') }
+      let(:mock_access_log_class) { double('ApolloAccessLog') }
+      let(:mock_db) { double('db') }
+      let(:sample_entries) do
+        [{ id: 'uuid-1', content: 'Ruby is interpreted', content_type: 'fact',
+           confidence: 0.8, distance: 0.15, tags: ['ruby'], source_agent: 'agent-1',
+           access_count: 3 }]
+      end
+
+      before do
+        stub_const('Legion::Data::Model::ApolloEntry', mock_entry_class)
+        stub_const('Legion::Data::Model::ApolloAccessLog', mock_access_log_class)
+        allow(Legion::Extensions::Apollo::Helpers::Embedding).to receive(:generate)
+          .and_return(Array.new(1536, 0.0))
+        allow(mock_entry_class).to receive(:db).and_return(mock_db)
+        allow(mock_db).to receive(:fetch).and_return(double(all: sample_entries))
+        allow(mock_entry_class).to receive(:where).and_return(double(update: true))
+        allow(mock_access_log_class).to receive(:create)
+      end
+
+      it 'returns matching entries' do
+        result = host.handle_query(query: 'Ruby', agent_id: 'agent-2')
+        expect(result[:success]).to be true
+        expect(result[:count]).to eq(1)
+        expect(result[:entries].first[:content]).to eq('Ruby is interpreted')
+      end
+
+      it 'boosts access count on matched entries' do
+        expect(mock_entry_class).to receive(:where).with(id: 'uuid-1')
+                                                   .and_return(double(update: true))
+        host.handle_query(query: 'Ruby', agent_id: 'agent-2')
+      end
+
+      it 'logs query access' do
+        expect(mock_access_log_class).to receive(:create).with(
+          hash_including(agent_id: 'agent-2', action: 'query')
+        )
+        host.handle_query(query: 'Ruby', agent_id: 'agent-2')
+      end
+    end
+
+    context 'when no results found' do
+      let(:mock_entry_class) { double('ApolloEntry') }
+      let(:mock_db) { double('db') }
+
+      before do
+        stub_const('Legion::Data::Model::ApolloEntry', mock_entry_class)
+        allow(Legion::Extensions::Apollo::Helpers::Embedding).to receive(:generate)
+          .and_return(Array.new(1536, 0.0))
+        allow(mock_entry_class).to receive(:db).and_return(mock_db)
+        allow(mock_db).to receive(:fetch).and_return(double(all: []))
+      end
+
+      it 'returns empty entries array' do
+        result = host.handle_query(query: 'nonexistent')
+        expect(result[:success]).to be true
+        expect(result[:entries]).to eq([])
+        expect(result[:count]).to eq(0)
+      end
+    end
+  end
+
+  describe '#retrieve_relevant' do
+    let(:host) { Object.new.extend(described_class) }
+
+    it 'returns skipped when skip is true' do
+      result = host.retrieve_relevant(skip: true)
+      expect(result[:status]).to eq(:skipped)
+    end
+
+    context 'when Apollo data is not available' do
+      before { hide_const('Legion::Data::Model::ApolloEntry') if defined?(Legion::Data::Model::ApolloEntry) }
+
+      it 'returns a structured error' do
+        result = host.retrieve_relevant(query: 'test')
+        expect(result[:success]).to be false
+      end
+    end
+
+    it 'returns empty when query is nil' do
+      stub_const('Legion::Data::Model::ApolloEntry', Class.new)
+      result = host.retrieve_relevant(query: nil)
+      expect(result[:success]).to be true
+      expect(result[:entries]).to eq([])
+    end
+
+    it 'returns empty when query is blank' do
+      stub_const('Legion::Data::Model::ApolloEntry', Class.new)
+      result = host.retrieve_relevant(query: '  ')
+      expect(result[:success]).to be true
+      expect(result[:entries]).to eq([])
+    end
+
+    context 'with valid query and data available' do
+      let(:mock_entry_class) { double('ApolloEntry') }
+      let(:mock_db) { double('db') }
+      let(:sample_entries) do
+        [{ id: 'uuid-1', content: 'fact', content_type: 'fact',
+           confidence: 0.7, distance: 0.2, tags: ['ruby'], source_agent: 'agent-1' }]
+      end
+
+      before do
+        stub_const('Legion::Data::Model::ApolloEntry', mock_entry_class)
+        allow(Legion::Extensions::Apollo::Helpers::Embedding).to receive(:generate)
+          .and_return(Array.new(1536, 0.0))
+        allow(mock_entry_class).to receive(:db).and_return(mock_db)
+        allow(mock_db).to receive(:fetch).and_return(double(all: sample_entries))
+        allow(mock_entry_class).to receive(:where).and_return(double(update: true))
+      end
+
+      it 'returns entries without access logging' do
+        result = host.retrieve_relevant(query: 'Ruby facts')
+        expect(result[:success]).to be true
+        expect(result[:count]).to eq(1)
+      end
+    end
+  end
+end

data/spec/legion/extensions/apollo/runners/maintenance_spec.rb

@@ -0,0 +1,133 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+require 'legion/extensions/apollo/helpers/confidence'
+require 'legion/extensions/apollo/helpers/similarity'
+require 'legion/extensions/apollo/helpers/embedding'
+require 'legion/extensions/apollo/runners/maintenance'
+
+RSpec.describe Legion::Extensions::Apollo::Runners::Maintenance do
+  let(:runner) do
+    obj = Object.new
+    obj.extend(described_class)
+    obj
+  end
+
+  describe '#force_decay' do
+    it 'returns a force_decay payload' do
+      result = runner.force_decay(factor: 0.5)
+      expect(result[:action]).to eq(:force_decay)
+      expect(result[:factor]).to eq(0.5)
+    end
+  end
+
+  describe '#archive_stale' do
+    it 'returns an archive payload with default days' do
+      result = runner.archive_stale
+      expect(result[:action]).to eq(:archive_stale)
+      expect(result[:days]).to eq(90)
+    end
+  end
+
+  describe '#resolve_dispute' do
+    it 'returns a resolve payload' do
+      result = runner.resolve_dispute(entry_id: 'uuid-123', resolution: :keep)
+      expect(result[:action]).to eq(:resolve_dispute)
+      expect(result[:resolution]).to eq(:keep)
+    end
+  end
+
+  describe '#check_corroboration' do
+    let(:host) { Object.new.extend(described_class) }
+
+    context 'when Apollo data is not available' do
+      before { hide_const('Legion::Data::Model::ApolloEntry') if defined?(Legion::Data::Model::ApolloEntry) }
+
+      it 'returns a structured error' do
+        result = host.check_corroboration
+        expect(result[:success]).to be false
+        expect(result[:error]).to eq('apollo_data_not_available')
+      end
+    end
+
+    context 'when no candidates exist' do
+      let(:mock_entry_class) { double('ApolloEntry') }
+
+      before do
+        stub_const('Legion::Data::Model::ApolloEntry', mock_entry_class)
+        allow(mock_entry_class).to receive(:where).with(status: 'candidate')
+                                                  .and_return(double(exclude: double(all: [])))
+        allow(mock_entry_class).to receive(:where).with(status: 'confirmed')
+                                                  .and_return(double(exclude: double(all: [])))
+      end
+
+      it 'returns zero promoted and scanned' do
+        result = host.check_corroboration
+        expect(result[:success]).to be true
+        expect(result[:promoted]).to eq(0)
+        expect(result[:scanned]).to eq(0)
+      end
+    end
+
+    context 'when a candidate matches a confirmed entry' do
+      let(:mock_entry_class) { double('ApolloEntry') }
+      let(:mock_relation_class) { double('ApolloRelation') }
+      let(:embedding) { Array.new(1536, 0.5) }
+      let(:candidate) do
+        double('candidate', id: 'c-1', content_type: 'fact', embedding: embedding,
+               confidence: 0.5, update: true)
+      end
+      let(:confirmed_entry) do
+        double('confirmed', id: 'f-1', content_type: 'fact', embedding: embedding)
+      end
+
+      before do
+        stub_const('Legion::Data::Model::ApolloEntry', mock_entry_class)
+        stub_const('Legion::Data::Model::ApolloRelation', mock_relation_class)
+        allow(mock_entry_class).to receive(:where).with(status: 'candidate')
+                                                  .and_return(double(exclude: double(all: [candidate])))
+        allow(mock_entry_class).to receive(:where).with(status: 'confirmed')
+                                                  .and_return(double(exclude: double(all: [confirmed_entry])))
+        allow(mock_relation_class).to receive(:create)
+      end
+
+      it 'promotes the candidate' do
+        expect(candidate).to receive(:update).with(hash_including(status: 'confirmed'))
+        result = host.check_corroboration
+        expect(result[:promoted]).to eq(1)
+        expect(result[:scanned]).to eq(1)
+      end
+
+      it 'creates a similar_to relation' do
+        expect(mock_relation_class).to receive(:create).with(
+          hash_including(from_entry_id: 'c-1', to_entry_id: 'f-1', relation_type: 'similar_to')
+        )
+        host.check_corroboration
+      end
+    end
+
+    context 'when candidate has different content_type than confirmed' do
+      let(:mock_entry_class) { double('ApolloEntry') }
+      let(:embedding) { Array.new(1536, 0.5) }
+      let(:candidate) do
+        double('candidate', id: 'c-1', content_type: 'fact', embedding: embedding, confidence: 0.5)
+      end
+      let(:confirmed_entry) do
+        double('confirmed', id: 'f-1', content_type: 'concept', embedding: embedding)
+      end
+
+      before do
+        stub_const('Legion::Data::Model::ApolloEntry', mock_entry_class)
+        allow(mock_entry_class).to receive(:where).with(status: 'candidate')
+                                                  .and_return(double(exclude: double(all: [candidate])))
+        allow(mock_entry_class).to receive(:where).with(status: 'confirmed')
+                                                  .and_return(double(exclude: double(all: [confirmed_entry])))
+      end
+
+      it 'does not promote' do
+        result = host.check_corroboration
+        expect(result[:promoted]).to eq(0)
+      end
+    end
+  end
+end

data/spec/legion/extensions/apollo/transport/messages/ingest_spec.rb

@@ -0,0 +1,65 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+unless defined?(Legion::Transport::Message)
+  module Legion
+    module Transport
+      class Message
+        attr_reader :options
+
+        def initialize(**opts)
+          @options = opts
+        end
+
+        def publish
+          { published: true }
+        end
+      end
+
+      class Exchange
+        def exchange_name
+          'mock'
+        end
+      end
+    end
+  end
+  $LOADED_FEATURES << 'legion/transport/message' unless $LOADED_FEATURES.include?('legion/transport/message')
+  $LOADED_FEATURES << 'legion/transport/exchange' unless $LOADED_FEATURES.include?('legion/transport/exchange')
+end
+
+require 'legion/extensions/apollo/transport/exchanges/apollo'
+require 'legion/extensions/apollo/transport/messages/ingest'
+
+RSpec.describe Legion::Extensions::Apollo::Transport::Messages::Ingest do
+  let(:message) do
+    described_class.new(
+      content:      'test fact',
+      content_type: :fact,
+      tags:         %w[vault],
+      source_agent: 'worker-1'
+    )
+  end
+
+  describe '#routing_key' do
+    it 'returns apollo.ingest' do
+      expect(message.routing_key).to eq('apollo.ingest')
+    end
+  end
+
+  describe '#message' do
+    it 'includes content and metadata' do
+      msg = message.message
+      expect(msg[:content]).to eq('test fact')
+      expect(msg[:content_type]).to eq(:fact)
+      expect(msg[:tags]).to eq(%w[vault])
+      expect(msg[:source_agent]).to eq('worker-1')
+    end
+  end
+
+  describe '#type' do
+    it 'returns apollo_ingest' do
+      expect(message.type).to eq('apollo_ingest')
+    end
+  end
+end

data/spec/legion/extensions/apollo/transport/messages/query_spec.rb

@@ -0,0 +1,75 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+unless defined?(Legion::Transport::Message)
+  module Legion
+    module Transport
+      class Message
+        attr_reader :options
+
+        def initialize(**opts)
+          @options = opts
+        end
+
+        def publish
+          { published: true }
+        end
+      end
+
+      class Exchange
+        def exchange_name
+          'mock'
+        end
+      end
+    end
+  end
+  $LOADED_FEATURES << 'legion/transport/message' unless $LOADED_FEATURES.include?('legion/transport/message')
+  $LOADED_FEATURES << 'legion/transport/exchange' unless $LOADED_FEATURES.include?('legion/transport/exchange')
+end
+
+require 'legion/extensions/apollo/transport/exchanges/apollo'
+require 'legion/extensions/apollo/transport/messages/query'
+
+RSpec.describe Legion::Extensions::Apollo::Transport::Messages::Query do
+  let(:message) do
+    described_class.new(
+      action:         :query,
+      query:          'PKI configuration',
+      limit:          5,
+      min_confidence: 0.3,
+      reply_to:       'reply-queue',
+      correlation_id: 'corr-123'
+    )
+  end
+
+  describe '#routing_key' do
+    it 'returns apollo.query' do
+      expect(message.routing_key).to eq('apollo.query')
+    end
+  end
+
+  describe '#message' do
+    it 'includes query params' do
+      msg = message.message
+      expect(msg[:action]).to eq(:query)
+      expect(msg[:query]).to eq('PKI configuration')
+      expect(msg[:limit]).to eq(5)
+      expect(msg[:reply_to]).to eq('reply-queue')
+      expect(msg[:correlation_id]).to eq('corr-123')
+    end
+
+    it 'compacts nil values' do
+      simple = described_class.new(action: :query, query: 'test')
+      msg = simple.message
+      expect(msg).not_to have_key(:tags)
+      expect(msg).not_to have_key(:relation_types)
+    end
+  end
+
+  describe '#type' do
+    it 'returns apollo_query' do
+      expect(message.type).to eq('apollo_query')
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+require 'bundler/setup'
+
+module Legion
+  module Logging
+    def self.debug(_msg); end
+    def self.info(_msg); end
+    def self.warn(_msg); end
+    def self.error(_msg); end
+  end
+end
+
+# Sequel is a runtime dependency via legion-data; stub for specs
+unless defined?(Sequel)
+  module Sequel
+    class Error < StandardError; end
+
+    def self.pg_array(arr) = arr
+    def self.lit(str) = str
+    Expr = Struct.new(:value) { def +(other) = "#{value} + #{other}" }
+    def self.expr(sym) = Expr.new(sym)
+  end
+end
+
+RSpec.configure do |config|
+  config.example_status_persistence_file_path = '.rspec_status'
+  config.disable_monkey_patching!
+  config.expect_with(:rspec) { |c| c.syntax = :expect }
+end