lex-apollo 0.4.21 → 0.4.23

data/spec/legion/extensions/apollo/api_spec.rb

@@ -25,4 +25,88 @@ RSpec.describe Legion::Extensions::Apollo::Api do
   it 'is defined as a Sinatra app' do
     expect(described_class.superclass).to eq(Sinatra::Base)
   end
+
+  describe '.stats_payload' do
+    let(:entry_model) { class_double('Legion::Data::Model::ApolloEntry') }
+    let(:relation_model) { class_double('Legion::Data::Model::ApolloRelation', count: 4) }
+    let(:status_counts) do
+      instance_double(
+        'StatusCounts',
+        all: [
+          { status: 'candidate', count: 2 },
+          { status: 'confirmed', count: 3 },
+          { status: 'archived', count: 1 }
+        ]
+      )
+    end
+    let(:content_type_counts) do
+      instance_double(
+        'ContentTypeCounts',
+        all: [
+          { content_type: 'document_chunk', count: 5 },
+          { content_type: 'observation', count: 1 }
+        ]
+      )
+    end
+    let(:active_entries) { instance_double('ActiveEntries', count: 5) }
+    let(:recent_entries) { instance_double('RecentEntries', count: 2) }
+
+    before do
+      stub_const('Legion::Data::Model::ApolloEntry', entry_model)
+      stub_const('Legion::Data::Model::ApolloRelation', relation_model)
+      allow(entry_model).to receive(:count).and_return(6)
+      allow(entry_model).to receive(:avg).with(:confidence).and_return(0.81234)
+      allow(entry_model).to receive(:exclude).with(status: 'archived').and_return(active_entries)
+      allow(entry_model).to receive(:where).and_return(recent_entries)
+      allow(entry_model).to receive(:group_and_count).with(:status).and_return(status_counts)
+      allow(entry_model).to receive(:group_and_count).with(:content_type).and_return(content_type_counts)
+    end
+
+    it 'returns the health UI metrics expected by Interlink' do
+      payload = described_class.stats_payload(now: Time.utc(2026, 4, 28, 12, 0, 0))
+
+      expect(payload).to include(
+        total_entries:   6,
+        recent_24h:      2,
+        avg_confidence:  0.812,
+        total_relations: 4
+      )
+      expect(payload[:by_status]).to include(
+        'candidate' => 2,
+        'confirmed' => 3,
+        'archived'  => 1,
+        'active'    => 5
+      )
+      expect(payload[:by_content_type]).to eq(
+        'document_chunk' => 5,
+        'observation'    => 1
+      )
+    end
+
+    context 'when legion-data exposes namespaced Apollo models' do
+      before do
+        hide_const('Legion::Data::Model::ApolloEntry') if defined?(Legion::Data::Model::ApolloEntry)
+        hide_const('Legion::Data::Model::ApolloRelation') if defined?(Legion::Data::Model::ApolloRelation)
+        stub_const('Legion::Data::Model::Apollo::Entry', entry_model)
+        stub_const('Legion::Data::Model::Apollo::Relation', relation_model)
+      end
+
+      it 'uses the namespaced models for stats' do
+        payload = described_class.stats_payload(now: Time.utc(2026, 4, 28, 12, 0, 0))
+
+        expect(payload).to include(
+          total_entries:   6,
+          recent_24h:      2,
+          avg_confidence:  0.812,
+          total_relations: 4
+        )
+      end
+    end
+
+    it 'returns an apollo data error when the entry model is unavailable' do
+      hide_const('Legion::Data::Model::ApolloEntry')
+
+      expect(described_class.stats_payload).to eq(error: 'apollo_data_not_available')
+    end
+  end
 end

data/spec/legion/extensions/apollo/helpers/capability_spec.rb

@@ -13,6 +13,7 @@ end
 
 RSpec.describe Legion::Extensions::Apollo::Helpers::Capability do
   before do
+    Legion::Settings[:extensions][:apollo] = Legion::Extensions::Apollo.default_settings
     described_class.instance_variable_set(:@apollo_write_privilege, nil)
   end
 
@@ -31,12 +32,12 @@ RSpec.describe Legion::Extensions::Apollo::Helpers::Capability do
 
   describe '.can_write?' do
     it 'returns false when apollo_write setting is false' do
-      allow(Legion::Settings).to receive(:dig).with(:data, :apollo_write).and_return(false)
+      described_class.settings[:data][:apollo_write] = false
       expect(described_class.can_write?).to be false
     end
 
     it 'returns false when Data is not connected' do
-      allow(Legion::Settings).to receive(:dig).with(:data, :apollo_write).and_return(true)
+      described_class.settings[:data][:apollo_write] = true
       allow(Legion::Data).to receive(:connected?).and_return(false) if defined?(Legion::Data)
       expect(described_class.can_write?).to be false
     end
@@ -44,12 +45,11 @@ RSpec.describe Legion::Extensions::Apollo::Helpers::Capability do
 
   describe '.apollo_write_enabled?' do
     it 'reads from settings' do
-      allow(Legion::Settings).to receive(:dig).with(:data, :apollo_write).and_return(true)
+      described_class.settings[:data][:apollo_write] = true
       expect(described_class.apollo_write_enabled?).to be true
     end
 
     it 'defaults to false' do
-      allow(Legion::Settings).to receive(:dig).with(:data, :apollo_write).and_return(nil)
       expect(described_class.apollo_write_enabled?).to be false
     end
   end

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

@@ -38,9 +38,6 @@ RSpec.describe Legion::Extensions::Apollo::Runners::Gas, '.phase_anticipate' do
     before do
       stub_const('Legion::LLM::Pipeline::GaiaCaller', gaia_caller)
       allow(gaia_caller).to receive(:structured).and_return(mock_response)
-      allow(Legion::JSON).to receive(:load).and_return(
-        { 'questions' => ['How fast is pgvector HNSW search?', 'What distance metrics does pgvector support?'] }
-      )
     end
 
     it 'generates anticipated questions' do

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

@@ -67,7 +67,6 @@ RSpec.describe Legion::Extensions::Apollo::Runners::Gas, '.phase_relate' do
 
       before do
         stub_const('Legion::LLM::Pipeline::GaiaCaller', gaia_caller)
-        stub_const('Legion::JSON', double(load: { 'relations' => [{ 'relation_type' => 'depends_on', 'confidence' => 0.85 }] }))
         allow(gaia_caller).to receive(:structured).and_return(mock_response)
       end
 
@@ -85,9 +84,6 @@ RSpec.describe Legion::Extensions::Apollo::Runners::Gas, '.phase_relate' do
           }
         )
         allow(gaia_caller).to receive(:structured).and_return(low_conf_response)
-        allow(Legion::JSON).to receive(:load).and_return(
-          { 'relations' => [{ 'relation_type' => 'contradicts', 'confidence' => 0.3 }] }
-        )
 
         result = described_class.phase_relate(facts, entities)
         # Low confidence relations should fall back to similar_to

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

@@ -39,17 +39,6 @@ RSpec.describe Legion::Extensions::Apollo::Runners::Gas, '.phase_synthesize' do
     before do
       stub_const('Legion::LLM::Pipeline::GaiaCaller', gaia_caller)
       allow(gaia_caller).to receive(:structured).and_return(mock_response)
-      allow(Legion::JSON).to receive(:load).and_return(
-        {
-          'synthesis' => [
-            {
-              'content'        => 'pgvector achieves fast similarity search through HNSW logarithmic indexing',
-              'content_type'   => 'inference',
-              'source_indices' => [0, 1]
-            }
-          ]
-        }
-      )
     end
 
     it 'generates derivative knowledge entries' do

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

@@ -21,7 +21,7 @@ RSpec.describe Legion::Extensions::Apollo::Runners::Knowledge do
         { vector: Array.new(1024, 0.0), model: 'test', provider: :ollama, dimensions: 1024, tokens: 0 }
       end
     end
-    stub_const('Legion::LLM::Embeddings', embeddings_mod)
+    stub_const('Legion::LLM::Call::Embeddings', embeddings_mod)
   end
 
   describe '#store_knowledge' do
@@ -158,7 +158,7 @@ RSpec.describe Legion::Extensions::Apollo::Runners::Knowledge do
         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::LLM::Embeddings).to receive(:generate)
+        allow(Legion::LLM::Call::Embeddings).to receive(:generate)
           .and_return({ vector: Array.new(1024, 0.0), model: 'test', provider: :ollama, dimensions: 1024, tokens: 0 })
 
         # Corroboration lookup chain
@@ -183,6 +183,15 @@ RSpec.describe Legion::Extensions::Apollo::Runners::Knowledge do
         expect(result[:corroborated]).to be false
       end
 
+      it 'defaults content_type to :observation when nil' do
+        expect(mock_entry_class).to receive(:create).with(
+          hash_including(content_type: 'observation')
+        ).and_return(mock_entry)
+        result = host.handle_ingest(content: 'gaia tick result', content_type: nil,
+                                    source_agent: 'gaia')
+        expect(result[:success]).to be true
+      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')
@@ -318,7 +327,7 @@ RSpec.describe Legion::Extensions::Apollo::Runners::Knowledge do
     context 'when Sequel raises an error' do
       before do
         stub_const('Legion::Data::Model::ApolloEntry', Class.new)
-        allow(Legion::LLM::Embeddings).to receive(:generate)
+        allow(Legion::LLM::Call::Embeddings).to receive(:generate)
           .and_return({ vector: Array.new(1024, 0.0), model: 'test', provider: :ollama, dimensions: 1024, tokens: 0 })
         allow(Legion::Data::Model::ApolloEntry).to receive(:where)
           .and_raise(Sequel::Error, 'connection lost')
@@ -348,9 +357,10 @@ RSpec.describe Legion::Extensions::Apollo::Runners::Knowledge do
         expect(logger).to have_received(:warn).with(/early-return: content is required/)
       end
 
-      it 'emits a warn log when content_type is nil' do
+      it 'does not emit a content_type warn when content_type is nil (defaults to :observation)' do
+        hide_const('Legion::Data::Model::ApolloEntry') if defined?(Legion::Data::Model::ApolloEntry)
         host.handle_ingest(content: 'something', content_type: nil)
-        expect(logger).to have_received(:warn).with(/early-return: content_type is required/)
+        expect(logger).not_to have_received(:warn).with(/content_type is required/)
       end
 
       it 'emits a warn log when apollo_data_not_available' do
@@ -395,7 +405,7 @@ RSpec.describe Legion::Extensions::Apollo::Runners::Knowledge do
       before do
         stub_const('Legion::Data::Model::ApolloEntry', mock_entry_class)
         stub_const('Legion::Data::Model::ApolloAccessLog', mock_access_log_class)
-        allow(Legion::LLM::Embeddings).to receive(:generate)
+        allow(Legion::LLM::Call::Embeddings).to receive(:generate)
           .and_return({ vector: Array.new(1024, 0.0), model: 'test', provider: :ollama, dimensions: 1024, tokens: 0 })
         allow(mock_entry_class).to receive(:db).and_return(mock_db)
         allow(mock_db).to receive(:fetch).and_return(double(all: sample_entries))
@@ -430,7 +440,7 @@ RSpec.describe Legion::Extensions::Apollo::Runners::Knowledge do
 
       before do
         stub_const('Legion::Data::Model::ApolloEntry', mock_entry_class)
-        allow(Legion::LLM::Embeddings).to receive(:generate)
+        allow(Legion::LLM::Call::Embeddings).to receive(:generate)
           .and_return({ vector: Array.new(1024, 0.0), model: 'test', provider: :ollama, dimensions: 1024, tokens: 0 })
         allow(mock_entry_class).to receive(:db).and_return(mock_db)
         allow(mock_db).to receive(:fetch).and_return(double(all: []))
@@ -463,7 +473,7 @@ RSpec.describe Legion::Extensions::Apollo::Runners::Knowledge do
       end
 
       it 'lists recent non-archived entries without generating an embedding' do
-        expect(Legion::LLM::Embeddings).not_to receive(:generate)
+        expect(Legion::LLM::Call::Embeddings).not_to receive(:generate)
 
         result = host.handle_query(query: 'x', limit: 50)
 
@@ -544,7 +554,7 @@ RSpec.describe Legion::Extensions::Apollo::Runners::Knowledge do
 
       before do
         stub_const('Legion::Data::Model::ApolloEntry', mock_entry_class)
-        allow(Legion::LLM::Embeddings).to receive(:generate)
+        allow(Legion::LLM::Call::Embeddings).to receive(:generate)
           .and_return({ vector: Array.new(1024, 0.0), model: 'test', provider: :ollama, dimensions: 1024, tokens: 0 })
         allow(mock_entry_class).to receive(:db).and_return(mock_db)
         allow(mock_db).to receive(:fetch).and_return(double(all: sample_entries))

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

@@ -17,7 +17,7 @@ RSpec.describe Legion::Extensions::Apollo::Runners::Request do
         { vector: Array.new(1024, 0.0), model: 'test', provider: :ollama, dimensions: 1024, tokens: 0 }
       end
     end
-    stub_const('Legion::LLM::Embeddings', embeddings_mod)
+    stub_const('Legion::LLM::Call::Embeddings', embeddings_mod)
   end
 
   describe '.data_required?' do
@@ -39,7 +39,7 @@ RSpec.describe Legion::Extensions::Apollo::Runners::Request do
       before do
         stub_const('Legion::Data::Model::ApolloEntry', mock_entry_class)
         stub_const('Legion::Data::Model::ApolloAccessLog', mock_access_log_class)
-        allow(Legion::LLM::Embeddings).to receive(:generate)
+        allow(Legion::LLM::Call::Embeddings).to receive(:generate)
           .and_return({ vector: Array.new(1024, 0.0), model: 'test', provider: :ollama, dimensions: 1024, tokens: 0 })
         allow(mock_entry_class).to receive(:db).and_return(mock_db)
         allow(mock_db).to receive(:fetch).and_return(double(all: sample_entries))
@@ -103,7 +103,7 @@ RSpec.describe Legion::Extensions::Apollo::Runners::Request do
 
       before do
         stub_const('Legion::Data::Model::ApolloEntry', mock_entry_class)
-        allow(Legion::LLM::Embeddings).to receive(:generate)
+        allow(Legion::LLM::Call::Embeddings).to receive(:generate)
           .and_return({ vector: Array.new(1024, 0.0), model: 'test', provider: :ollama, dimensions: 1024, tokens: 0 })
         allow(mock_entry_class).to receive(:db).and_return(mock_db)
         allow(mock_db).to receive(:fetch).and_return(double(all: []))
@@ -142,7 +142,7 @@ RSpec.describe Legion::Extensions::Apollo::Runners::Request do
         stub_const('Legion::Data::Model::ApolloEntry', mock_entry_class)
         stub_const('Legion::Data::Model::ApolloExpertise', mock_expertise_class)
         stub_const('Legion::Data::Model::ApolloAccessLog', mock_access_log_class)
-        allow(Legion::LLM::Embeddings).to receive(:generate)
+        allow(Legion::LLM::Call::Embeddings).to receive(:generate)
           .and_return({ vector: Array.new(1024, 0.0), model: 'test', provider: :ollama, dimensions: 1024, tokens: 0 })
         allow(mock_entry_class).to receive(:where).and_return(double(exclude: double(limit: double(each: nil), first: nil)))
         allow(mock_entry_class).to receive(:exclude)

data/spec/spec_helper.rb

@@ -52,6 +52,10 @@ module Legion
   end
 end
 
+require 'legion/extensions/apollo'
+
+Legion::Settings[:extensions][:apollo] = Legion::Extensions::Apollo.default_settings
+
 RSpec.configure do |config|
   config.example_status_persistence_file_path = '.rspec_status'
   config.disable_monkey_patching!

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: lex-apollo
 version: !ruby/object:Gem::Version
-  version: 0.4.21
+  version: 0.4.23
 platform: ruby
 authors:
 - Esity
@@ -174,6 +174,7 @@ files:
 - lib/legion/extensions/apollo/gaia_integration.rb
 - lib/legion/extensions/apollo/helpers/capability.rb
 - lib/legion/extensions/apollo/helpers/confidence.rb
+- lib/legion/extensions/apollo/helpers/data_models.rb
 - lib/legion/extensions/apollo/helpers/entity_watchdog.rb
 - lib/legion/extensions/apollo/helpers/graph_query.rb
 - lib/legion/extensions/apollo/helpers/similarity.rb