lex-apollo 0.4.22 → 0.4.24

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

@@ -83,6 +83,26 @@ RSpec.describe Legion::Extensions::Apollo::Api do
       )
     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')
 

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

@@ -18,10 +18,10 @@ RSpec.describe Legion::Extensions::Apollo::Runners::Knowledge do
   before do
     embeddings_mod = Module.new do
       def self.generate(*, **)
-        { vector: Array.new(1024, 0.0), model: 'test', provider: :ollama, dimensions: 1024, tokens: 0 }
+        { vector: Array.new(1024, 0.1), 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,8 +158,8 @@ 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)
-          .and_return({ vector: Array.new(1024, 0.0), model: 'test', provider: :ollama, dimensions: 1024, tokens: 0 })
+        allow(Legion::LLM::Call::Embeddings).to receive(:generate)
+          .and_return({ vector: Array.new(1024, 0.1), model: 'test', provider: :ollama, dimensions: 1024, tokens: 0 })
 
         # Corroboration lookup chain
         allow(mock_entry_class).to receive(:where).and_return(double(exclude: double(limit: empty_dataset)))
@@ -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,8 +327,8 @@ 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)
-          .and_return({ vector: Array.new(1024, 0.0), model: 'test', provider: :ollama, dimensions: 1024, tokens: 0 })
+        allow(Legion::LLM::Call::Embeddings).to receive(:generate)
+          .and_return({ vector: Array.new(1024, 0.1), model: 'test', provider: :ollama, dimensions: 1024, tokens: 0 })
         allow(Legion::Data::Model::ApolloEntry).to receive(:where)
           .and_raise(Sequel::Error, 'connection lost')
       end
@@ -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,8 +405,8 @@ 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)
-          .and_return({ vector: Array.new(1024, 0.0), model: 'test', provider: :ollama, dimensions: 1024, tokens: 0 })
+        allow(Legion::LLM::Call::Embeddings).to receive(:generate)
+          .and_return({ vector: Array.new(1024, 0.1), 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))
         allow(mock_entry_class).to receive(:where).and_return(double(update: true))
@@ -430,8 +440,8 @@ 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)
-          .and_return({ vector: Array.new(1024, 0.0), model: 'test', provider: :ollama, dimensions: 1024, tokens: 0 })
+        allow(Legion::LLM::Call::Embeddings).to receive(:generate)
+          .and_return({ vector: Array.new(1024, 0.1), 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: []))
       end
@@ -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,8 +554,8 @@ 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)
-          .and_return({ vector: Array.new(1024, 0.0), model: 'test', provider: :ollama, dimensions: 1024, tokens: 0 })
+        allow(Legion::LLM::Call::Embeddings).to receive(:generate)
+          .and_return({ vector: Array.new(1024, 0.1), 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))
         allow(mock_entry_class).to receive(:where).and_return(double(update: true))

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

@@ -107,9 +107,9 @@ RSpec.describe Legion::Extensions::Apollo::Runners::Maintenance do
       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: [])))
+                                                  .and_return(double(exclude: double(limit: double(all: []))))
         allow(mock_entry_class).to receive(:where).with(status: 'confirmed')
-                                                  .and_return(double(exclude: double(all: [])))
+                                                  .and_return(double(exclude: double(limit: double(all: []))))
       end
 
       it 'returns zero promoted and scanned' do
@@ -136,9 +136,9 @@ RSpec.describe Legion::Extensions::Apollo::Runners::Maintenance 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])))
+                                                  .and_return(double(exclude: double(limit: double(all: [candidate]))))
         allow(mock_entry_class).to receive(:where).with(status: 'confirmed')
-                                                  .and_return(double(exclude: double(all: [confirmed_entry])))
+                                                  .and_return(double(exclude: double(limit: double(all: [confirmed_entry]))))
         allow(mock_relation_class).to receive(:create)
       end
 
@@ -174,9 +174,9 @@ RSpec.describe Legion::Extensions::Apollo::Runners::Maintenance 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])))
+                                                  .and_return(double(exclude: double(limit: double(all: [candidate]))))
         allow(mock_entry_class).to receive(:where).with(status: 'confirmed')
-                                                  .and_return(double(exclude: double(all: [confirmed_entry])))
+                                                  .and_return(double(exclude: double(limit: double(all: [confirmed_entry]))))
       end
 
       it 'does not promote even with different providers' do
@@ -198,9 +198,9 @@ RSpec.describe Legion::Extensions::Apollo::Runners::Maintenance do
       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])))
+                                                  .and_return(double(exclude: double(limit: double(all: [candidate]))))
         allow(mock_entry_class).to receive(:where).with(status: 'confirmed')
-                                                  .and_return(double(exclude: double(all: [confirmed_entry])))
+                                                  .and_return(double(exclude: double(limit: double(all: [confirmed_entry]))))
       end
 
       it 'does not promote' do

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

@@ -14,10 +14,10 @@ RSpec.describe Legion::Extensions::Apollo::Runners::Request do
 
     embeddings_mod = Module.new do
       def self.generate(*, **)
-        { vector: Array.new(1024, 0.0), model: 'test', provider: :ollama, dimensions: 1024, tokens: 0 }
+        { vector: Array.new(1024, 0.1), 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,8 +39,8 @@ 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)
-          .and_return({ vector: Array.new(1024, 0.0), model: 'test', provider: :ollama, dimensions: 1024, tokens: 0 })
+        allow(Legion::LLM::Call::Embeddings).to receive(:generate)
+          .and_return({ vector: Array.new(1024, 0.1), 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))
         allow(mock_entry_class).to receive(:where).and_return(double(update: true))
@@ -103,8 +103,8 @@ 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)
-          .and_return({ vector: Array.new(1024, 0.0), model: 'test', provider: :ollama, dimensions: 1024, tokens: 0 })
+        allow(Legion::LLM::Call::Embeddings).to receive(:generate)
+          .and_return({ vector: Array.new(1024, 0.1), 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: []))
         allow(mock_entry_class).to receive(:where).and_return(double(update: true))
@@ -142,8 +142,8 @@ 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)
-          .and_return({ vector: Array.new(1024, 0.0), model: 'test', provider: :ollama, dimensions: 1024, tokens: 0 })
+        allow(Legion::LLM::Call::Embeddings).to receive(:generate)
+          .and_return({ vector: Array.new(1024, 0.1), 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)
           .and_return(double(exclude: double(limit: double(all: []))))

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.22
+  version: 0.4.24
 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