lex-apollo 0.4.21 → 0.4.23

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 31dc882a8d5fd761bceaba21ff853a3d3dd898df9d4377464b72b110d306af0a
-  data.tar.gz: 8dcfd2bc7c2557b298f3d503cc94b07e5a78b5a9777789f724dede41b9d0efdb
+  metadata.gz: af5cbbe35e69f28430c0c4d2862294024e465b79a7fdba279bb50562bc0d81d4
+  data.tar.gz: d2cf12984c06eb60752f7202935649a411377ca141e20d719d2faa2ec4c05b3b
 SHA512:
-  metadata.gz: 5e066b3c62555b4866bfe99d6bed13a034e2b6b23f613ae7906e8eaebee90ecb2f9dd937a5e928dd8337af8945bfba9a1528deb4d3200eb82b8a92b081b6cf59
-  data.tar.gz: dd1d625f4efc30df8951ee80db9ee0cfc1c25137bae5d8571dd09265bd5eec79add3482eba3cc88d77f43b052994597577abe634080cd995eb4dc0db7601458e
+  metadata.gz: a2bf398b3f6df58ec0e84f810f7ba4e48e68991c88f95ae8e5614ba4510ae7ab9be3994dc757f34138073797cb2af99c795d532f4e24dc9fb2f09ffa0b18d13f
+  data.tar.gz: fad944b5457ef0574bb53b1d88251d5d4dce1a70b3cbe8ffadb25b3938877a0170cd36adbf41705d066d84f7036043914efa6b7473db5999daf24badde8a7f5d

data/CHANGELOG.md

@@ -1,5 +1,18 @@
 # Changelog
 
+## [0.4.23] - 2026-05-06
+
+### Fixed
+- Apollo data model access now prefers the namespaced `Legion::Data::Model::Apollo::*` classes introduced by the legion-data schema cleanup while retaining fallback compatibility with the legacy `ApolloEntry`, `ApolloRelation`, `ApolloAccessLog`, and `ApolloExpertise` constants.
+
+### Changed
+- Apollo defaults are now declared directly in `Apollo.default_settings`, and Apollo helpers, runners, actors, and API paths use `Legion::Logging::Helper`, `Legion::Settings::Helper`, and `Legion::JSON` helper methods instead of direct logging/settings/JSON calls.
+
+## [0.4.22] - 2026-04-28
+
+### Fixed
+- `/api/apollo/stats` now returns the health UI metrics Interlink expects: `recent_24h`, `avg_confidence`, and a synthesized `by_status["active"]` count for non-archived entries. This keeps the Knowledge Health cards populated instead of rendering missing values. Fixes #16.
+
 ## [0.4.21] - 2026-04-27
 
 ### Changed

data/lib/legion/extensions/apollo/actors/corroboration_checker.rb

@@ -8,9 +8,11 @@ module Legion
     module Apollo
       module Actor
         class CorroborationChecker < Legion::Extensions::Actors::Every
+          include Legion::Settings::Helper
+
           def runner_class    = Legion::Extensions::Apollo::Runners::Maintenance
           def runner_function = 'check_corroboration'
-          def time            = (defined?(Legion::Settings) && Legion::Settings.dig(:apollo, :actors, :corroboration_interval)) || 900
+          def time            = settings[:actors][:corroboration_interval]
           def run_now?        = false
           def use_runner?     = false
           def check_subtask?  = false

data/lib/legion/extensions/apollo/actors/decay.rb

@@ -8,9 +8,11 @@ module Legion
     module Apollo
       module Actor
         class Decay < Legion::Extensions::Actors::Every
+          include Legion::Settings::Helper
+
           def runner_class    = Legion::Extensions::Apollo::Runners::Maintenance
           def runner_function = 'run_decay_cycle'
-          def time            = (defined?(Legion::Settings) && Legion::Settings.dig(:apollo, :actors, :decay_interval)) || 3600
+          def time            = settings[:actors][:decay_interval]
           def run_now?        = false
           def use_runner?     = false
           def check_subtask?  = false

data/lib/legion/extensions/apollo/actors/entity_watchdog.rb

@@ -11,6 +11,7 @@ module Legion
         class EntityWatchdog < Legion::Extensions::Actors::Every
           include Legion::Extensions::Apollo::Runners::Knowledge
           include Legion::Extensions::Apollo::Runners::EntityExtractor
+          include Legion::Settings::Helper
 
           DEDUP_THRESHOLD_DEFAULT   = 0.92
           TASK_LOG_LOOKBACK_SECONDS = 300
@@ -18,7 +19,7 @@ module Legion
 
           def runner_class    = self.class
           def runner_function = 'scan_and_ingest'
-          def time            = (defined?(Legion::Settings) && Legion::Settings.dig(:apollo, :actors, :entity_watchdog_interval)) || 120
+          def time            = settings[:actors][:entity_watchdog_interval]
           def run_now?        = false
           def use_runner?     = false
           def check_subtask?  = false
@@ -28,7 +29,7 @@ module Legion
             defined?(Legion::Extensions::Apollo::Runners::EntityExtractor) &&
               Legion.const_defined?(:Transport, false)
           rescue StandardError => e
-            log.warn("EntityWatchdog enabled? check failed: #{e.message}")
+            handle_exception(e, level: :warn, operation: 'apollo.entity_watchdog.enabled')
             false
           end
 
@@ -64,8 +65,8 @@ module Legion
           def recent_task_log_texts
             return [] unless defined?(Legion::Data) && defined?(Legion::Data::Model::TaskLog)
 
-            lookback = (defined?(Legion::Settings) && Legion::Settings.dig(:apollo, :entity_watchdog, :lookback_seconds)) || TASK_LOG_LOOKBACK_SECONDS
-            log_limit = (defined?(Legion::Settings) && Legion::Settings.dig(:apollo, :entity_watchdog, :log_limit)) || TASK_LOG_LIMIT
+            lookback = settings[:entity_watchdog][:lookback_seconds]
+            log_limit = settings[:entity_watchdog][:log_limit]
             cutoff = Time.now - lookback
             logs = Legion::Data::Model::TaskLog
                    .where { created_at >= cutoff }
@@ -76,7 +77,7 @@ module Legion
             log.debug("EntityWatchdog recent_task_log_texts lookback=#{lookback} limit=#{log_limit} raw=#{logs.size} unique=#{texts.size}")
             texts
           rescue StandardError => e
-            log.warn("EntityWatchdog recent_task_log_texts failed: #{e.message}")
+            handle_exception(e, level: :warn, operation: 'apollo.entity_watchdog.recent_task_log_texts')
             []
           end
 
@@ -93,7 +94,7 @@ module Legion
             distance = closest[:distance].to_f
             distance <= (1.0 - dedup_similarity_threshold)
           rescue StandardError => e
-            log.warn("EntityWatchdog entity_exists_in_apollo? failed: #{e.message}")
+            handle_exception(e, level: :warn, operation: 'apollo.entity_watchdog.entity_exists_in_apollo')
             false
           end
 
@@ -113,27 +114,15 @@ module Legion
           end
 
           def entity_types
-            if defined?(Legion::Settings)
-              types = Legion::Settings.dig(:apollo, :entity_watchdog, :types)
-              return Array(types).map(&:to_s) if types
-            end
-            %w[person service repository concept]
+            Array(settings[:entity_watchdog][:types]).map(&:to_s)
           end
 
           def min_entity_confidence
-            if defined?(Legion::Settings)
-              val = Legion::Settings.dig(:apollo, :entity_watchdog, :min_confidence)
-              return val.to_f if val
-            end
-            0.7
+            settings[:entity_watchdog][:min_confidence].to_f
           end
 
           def dedup_similarity_threshold
-            if defined?(Legion::Settings)
-              val = Legion::Settings.dig(:apollo, :entity_watchdog, :dedup_threshold)
-              return val.to_f if val
-            end
-            DEDUP_THRESHOLD_DEFAULT
+            settings[:entity_watchdog][:dedup_threshold].to_f
           end
         end
       end

data/lib/legion/extensions/apollo/actors/expertise_aggregator.rb

@@ -8,9 +8,11 @@ module Legion
     module Apollo
       module Actor
         class ExpertiseAggregator < Legion::Extensions::Actors::Every
+          include Legion::Settings::Helper
+
           def runner_class    = Legion::Extensions::Apollo::Runners::Expertise
           def runner_function = 'aggregate'
-          def time            = (defined?(Legion::Settings) && Legion::Settings.dig(:apollo, :actors, :expertise_interval)) || 1800
+          def time            = settings[:actors][:expertise_interval]
           def run_now?        = false
           def use_runner?     = false
           def check_subtask?  = false

data/lib/legion/extensions/apollo/actors/gas_subscriber.rb

@@ -17,7 +17,7 @@ module Legion
             defined?(Legion::Extensions::Apollo::Runners::Gas) &&
               Legion.const_defined?(:Transport, false)
           rescue StandardError => e
-            log.warn("GasSubscriber enabled? check failed: #{e.message}")
+            handle_exception(e, level: :warn, operation: 'apollo.gas_subscriber.enabled')
             false
           end
 

data/lib/legion/extensions/apollo/actors/ingest.rb

@@ -16,7 +16,7 @@ module Legion
             defined?(Legion::Extensions::Apollo::Runners::Knowledge) &&
               Legion.const_defined?(:Transport, false)
           rescue StandardError => e
-            log.warn("Ingest enabled? check failed: #{e.message}")
+            handle_exception(e, level: :warn, operation: 'apollo.ingest.enabled')
             false
           end
         end

data/lib/legion/extensions/apollo/actors/query_responder.rb

@@ -16,7 +16,7 @@ module Legion
             defined?(Legion::Extensions::Apollo::Runners::Knowledge) &&
               Legion.const_defined?(:Transport, false)
           rescue StandardError => e
-            log.warn("QueryResponder enabled? check failed: #{e.message}")
+            handle_exception(e, level: :warn, operation: 'apollo.query_responder.enabled')
             false
           end
         end

data/lib/legion/extensions/apollo/actors/writeback_store.rb

@@ -17,7 +17,7 @@ module Legion
               Legion.const_defined?(:Transport, false) &&
               Helpers::Capability.apollo_write_enabled?
           rescue StandardError => e
-            log.warn("WritebackStore enabled? check failed: #{e.message}")
+            handle_exception(e, level: :warn, operation: 'apollo.writeback_store.enabled')
             false
           end
         end

data/lib/legion/extensions/apollo/actors/writeback_vectorize.rb

@@ -15,7 +15,7 @@ module Legion
           def handle_vectorize(payload)
             payload = symbolize(payload)
             log.debug("WritebackVectorize handle_vectorize content_length=#{payload[:content].to_s.length} content_type=#{payload[:content_type] || 'nil'}")
-            result = Legion::LLM::Embeddings.generate(text: payload[:content])
+            result = Legion::LLM::Call::Embeddings.generate(text: payload[:content])
             vector = result.is_a?(Hash) ? result[:vector] : result
             embedding = vector.is_a?(Array) && vector.any? ? vector : Array.new(1024, 0.0)
             log.debug("WritebackVectorize embedding_dimensions=#{embedding.length} vector_generated=#{vector.is_a?(Array) && vector.any?}")
@@ -41,7 +41,7 @@ module Legion
           def enabled? # rubocop:disable Legion/Extension/ActorEnabledSideEffects
             Legion.const_defined?(:Transport, false) && Helpers::Capability.can_embed?
           rescue StandardError => e
-            log.warn("WritebackVectorize enabled? check failed: #{e.message}")
+            handle_exception(e, level: :warn, operation: 'apollo.writeback_vectorize.enabled')
             false
           end
 

data/lib/legion/extensions/apollo/api.rb

@@ -1,7 +1,9 @@
 # frozen_string_literal: true
 
 require 'sinatra/base' unless defined?(Sinatra)
-require 'json'
+require 'legion/logging'
+require 'legion/json'
+require 'legion/extensions/apollo/helpers/data_models'
 
 module Legion
   module Extensions
@@ -9,18 +11,53 @@ module Legion
       class Api < Sinatra::Base
         set :host_authorization, permitted: :any
 
+        class << self
+          def stats_payload(now: Time.now)
+            return { error: 'apollo_data_not_available' } unless Helpers::DataModels.apollo_entry_available?
+
+            entries = Helpers::DataModels.apollo_entry
+            by_status = grouped_counts(entries, :status)
+            by_status['active'] = entries.exclude(status: 'archived').count
+
+            stats = {
+              total_entries:   entries.count,
+              recent_24h:      entries.where { created_at >= (now - 86_400) }.count,
+              avg_confidence:  average_confidence(entries),
+              by_status:       by_status,
+              by_content_type: grouped_counts(entries, :content_type)
+            }
+            stats[:total_relations] = Helpers::DataModels.apollo_relation.count if Helpers::DataModels.apollo_relation_available?
+            stats
+          end
+
+          private
+
+          def grouped_counts(entries, column)
+            entries.group_and_count(column).all.to_h { |row| [row[column].to_s, row[:count]] }
+          end
+
+          def average_confidence(entries)
+            avg = entries.avg(:confidence)
+            avg&.to_f&.round(3)
+          end
+        end
+
         before do
           content_type :json
         end
 
         helpers do
+          include Legion::Logging::Helper
+          include Legion::JSON::Helper
+
           def json_body
             body = request.body.read
             return {} if body.empty?
 
-            ::JSON.parse(body, symbolize_names: true)
-          rescue ::JSON::ParserError => e
-            halt 400, { error: "invalid JSON: #{e.message}" }.to_json
+            json_parse(body)
+          rescue Legion::JSON::ParseError => e
+            handle_exception(e, level: :warn, operation: 'apollo.api.json_body')
+            halt 400, json_dump(error: "invalid JSON: #{e.message}")
           end
 
           def runner
@@ -42,14 +79,14 @@ module Legion
 
         # Health check
         get '/api/apollo/health' do
-          available = defined?(Legion::Data::Model::ApolloEntry) ? true : false
-          { status: available ? 'ok' : 'degraded', data_available: available }.to_json
+          available = Helpers::DataModels.apollo_entry_available?
+          json_dump(status: available ? 'ok' : 'degraded', data_available: available)
         end
 
         # Query knowledge (semantic search)
         post '/api/apollo/query' do
           req = json_body
-          halt 400, { error: 'query is required' }.to_json unless req[:query]
+          halt 400, json_dump(error: 'query is required') unless req[:query]
 
           query_options = {
             query:          req[:query],
@@ -63,14 +100,14 @@ module Legion
 
           result = runner.handle_query(**query_options)
           status result[:success] ? 200 : 500
-          result.to_json
+          json_dump(result)
         end
 
         # Ingest knowledge
         post '/api/apollo/ingest' do
           req = json_body
-          halt 400, { error: 'content is required' }.to_json unless req[:content]
-          halt 400, { error: 'content_type is required' }.to_json unless req[:content_type]
+          halt 400, json_dump(error: 'content is required') unless req[:content]
+          halt 400, json_dump(error: 'content_type is required') unless req[:content_type]
 
           result = runner.handle_ingest(
             content:          req[:content],
@@ -83,13 +120,13 @@ module Legion
             context:          req[:context] || {}
           )
           status result[:success] ? 201 : 500
-          result.to_json
+          json_dump(result)
         end
 
         # Graph traversal
         post '/api/apollo/traverse' do
           req = json_body
-          halt 400, { error: 'entry_id is required' }.to_json unless req[:entry_id]
+          halt 400, json_dump(error: 'entry_id is required') unless req[:entry_id]
 
           result = runner.handle_traverse(
             entry_id:       req[:entry_id],
@@ -98,13 +135,13 @@ module Legion
             agent_id:       req[:agent_id] || 'api'
           )
           status result[:success] ? 200 : 500
-          result.to_json
+          json_dump(result)
         end
 
         # Retrieve relevant (GAIA-compatible)
         post '/api/apollo/retrieve' do
           req = json_body
-          halt 400, { error: 'query is required' }.to_json unless req[:query]
+          halt 400, json_dump(error: 'query is required') unless req[:query]
 
           result = runner.retrieve_relevant(
             query:          req[:query],
@@ -114,7 +151,7 @@ module Legion
             domain:         req[:domain]
           )
           status result[:success] ? 200 : 500
-          result.to_json
+          json_dump(result)
         end
 
         # Deprecate entry
@@ -123,35 +160,24 @@ module Legion
             entry_id: params[:id],
             reason:   json_body[:reason] || 'deprecated via API'
           )
-          result.to_json
+          json_dump(result)
         end
 
         # Domains at risk — must be declared before /:agent_id to avoid routing conflict
         get '/api/apollo/expertise/at-risk' do
           result = expertise_runner.domains_at_risk
-          result.to_json
+          json_dump(result)
         end
 
         # Expertise for an agent
         get '/api/apollo/expertise/:agent_id' do
           result = expertise_runner.agent_profile(agent_id: params[:agent_id])
-          result.to_json
+          json_dump(result)
         end
 
         # Statistics
         get '/api/apollo/stats' do
-          stats = {}
-          if defined?(Legion::Data::Model::ApolloEntry)
-            stats[:total_entries] = Legion::Data::Model::ApolloEntry.count
-            stats[:by_status]     = Legion::Data::Model::ApolloEntry.group_and_count(:status).all
-                                                                    .to_h { |r| [r[:status], r[:count]] }
-            stats[:by_content_type] = Legion::Data::Model::ApolloEntry.group_and_count(:content_type).all
-                                                                      .to_h { |r| [r[:content_type], r[:count]] }
-            stats[:total_relations] = Legion::Data::Model::ApolloRelation.count if defined?(Legion::Data::Model::ApolloRelation)
-          else
-            stats[:error] = 'apollo_data_not_available'
-          end
-          stats.to_json
+          json_dump(self.class.stats_payload)
         end
       end
     end

data/lib/legion/extensions/apollo/gaia_integration.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require_relative 'helpers/data_models'
+
 module Legion
   module Extensions
     module Apollo
@@ -27,13 +29,13 @@ module Legion
           end
 
           def handle_mesh_departure(agent_id:)
-            return nil unless defined?(Legion::Data::Model::ApolloExpertise)
+            return nil unless Helpers::DataModels.apollo_expertise_available?
 
-            sole_expert_domains = Legion::Data::Model::ApolloExpertise
-                                  .where(agent_id: agent_id)
-                                  .all
-                                  .select { |e| sole_expert?(e.domain, agent_id) }
-                                  .map(&:domain)
+            sole_expert_domains = Helpers::DataModels.apollo_expertise
+                                                     .where(agent_id: agent_id)
+                                                     .all
+                                                     .select { |e| sole_expert?(e.domain, agent_id) }
+                                                     .map(&:domain)
 
             return nil if sole_expert_domains.empty?
 
@@ -48,12 +50,12 @@ module Legion
           private
 
           def sole_expert?(domain, agent_id)
-            return false unless defined?(Legion::Data::Model::ApolloExpertise)
+            return false unless Helpers::DataModels.apollo_expertise_available?
 
-            count = Legion::Data::Model::ApolloExpertise
-                    .where(domain: domain)
-                    .exclude(agent_id: agent_id)
-                    .count
+            count = Helpers::DataModels.apollo_expertise
+                                       .where(domain: domain)
+                                       .exclude(agent_id: agent_id)
+                                       .count
             count.zero?
           end
         end

data/lib/legion/extensions/apollo/helpers/capability.rb

@@ -5,20 +5,19 @@ module Legion
     module Apollo
       module Helpers
         module Capability
+          extend Legion::Logging::Helper
+          extend Legion::Settings::Helper
+
           EMBEDDING_MODELS = %w[mxbai-embed-large bge-large snowflake-arctic-embed].freeze
 
           module_function
 
-          def log
-            Legion::Logging
-          end
-
           def can_embed?
             return false unless defined?(Legion::LLM) && Legion::LLM.started?
 
             ollama_embedding_available? || cloud_embedding_configured?
           rescue StandardError => e
-            log.warn("Apollo Capability.can_embed? failed: #{e.message}")
+            handle_exception(e, level: :warn, operation: 'apollo.capability.can_embed')
             false
           end
 
@@ -28,14 +27,14 @@ module Legion
 
             check_db_write_privilege
           rescue StandardError => e
-            log.warn("Apollo Capability.can_write? failed: #{e.message}")
+            handle_exception(e, level: :warn, operation: 'apollo.capability.can_write')
             false
           end
 
           def apollo_write_enabled?
-            Legion::Settings.dig(:data, :apollo_write) == true
+            settings[:data][:apollo_write] == true
           rescue StandardError => e
-            log.warn("Apollo Capability.apollo_write_enabled? failed: #{e.message}")
+            handle_exception(e, level: :warn, operation: 'apollo.capability.apollo_write_enabled')
             false
           end
 
@@ -44,16 +43,16 @@ module Legion
 
             EMBEDDING_MODELS.any? { |m| Legion::LLM::Discovery::Ollama.model_available?(m) }
           rescue StandardError => e
-            log.warn("Apollo Capability.ollama_embedding_available? failed: #{e.message}")
+            handle_exception(e, level: :warn, operation: 'apollo.capability.ollama_embedding_available')
             false
           end
 
           def cloud_embedding_configured?
-            provider = Legion::Settings.dig(:apollo, :embedding, :provider)
-            model = Legion::Settings.dig(:apollo, :embedding, :model)
+            provider = settings[:embedding][:provider]
+            model = settings[:embedding][:model]
             !provider.nil? && !model.nil?
           rescue StandardError => e
-            log.warn("Apollo Capability.cloud_embedding_configured? failed: #{e.message}")
+            handle_exception(e, level: :warn, operation: 'apollo.capability.cloud_embedding_configured')
             false
           end
 
@@ -64,7 +63,7 @@ module Legion
                                                   .fetch("SELECT has_table_privilege(current_user, 'apollo_entries', 'INSERT') AS can_insert")
                                                   .first[:can_insert] == true
           rescue StandardError => e
-            log.warn("Apollo Capability.check_db_write_privilege failed: #{e.message}")
+            handle_exception(e, level: :warn, operation: 'apollo.capability.check_db_write_privilege')
             @apollo_write_privilege = false
           end
 

data/lib/legion/extensions/apollo/helpers/confidence.rb

@@ -5,6 +5,9 @@ module Legion
     module Apollo
       module Helpers
         module Confidence
+          extend Legion::Logging::Helper
+          extend Legion::Settings::Helper
+
           INITIAL_CONFIDENCE = 0.5
           CORROBORATION_BOOST = 0.3
           RETRIEVAL_BOOST = 0.02
@@ -21,16 +24,10 @@ module Legion
 
           module_function
 
-          def log
-            Legion::Logging
-          end
-
           def apollo_setting(*keys, default:)
-            return default unless defined?(Legion::Settings) && !Legion::Settings[:apollo].nil?
-
-            Legion::Settings[:apollo].dig(*keys) || default
+            settings.dig(*keys)
           rescue StandardError => e
-            log.warn("Apollo Confidence.apollo_setting failed: #{e.message}")
+            handle_exception(e, level: :warn, operation: 'apollo.confidence.apollo_setting', keys: keys)
             default
           end
 

data/lib/legion/extensions/apollo/helpers/data_models.rb

@@ -0,0 +1,61 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module Apollo
+      module Helpers
+        module DataModels
+          class << self
+            def apollo_entry
+              namespaced_apollo_model(:Entry) || legacy_model(:ApolloEntry)
+            end
+
+            def apollo_relation
+              namespaced_apollo_model(:Relation) || legacy_model(:ApolloRelation)
+            end
+
+            def apollo_access_log
+              namespaced_apollo_model(:AccessLog) || legacy_model(:ApolloAccessLog)
+            end
+
+            def apollo_expertise
+              namespaced_apollo_model(:Expertise) || legacy_model(:ApolloExpertise)
+            end
+
+            def apollo_entry_available?
+              !apollo_entry.nil?
+            end
+
+            def apollo_relation_available?
+              !apollo_relation.nil?
+            end
+
+            def apollo_access_log_available?
+              !apollo_access_log.nil?
+            end
+
+            def apollo_expertise_available?
+              !apollo_expertise.nil?
+            end
+
+            private
+
+            def namespaced_apollo_model(name)
+              return nil unless defined?(Legion::Data::Model::Apollo)
+              return nil unless Legion::Data::Model::Apollo.const_defined?(name, false)
+
+              Legion::Data::Model::Apollo.const_get(name, false)
+            end
+
+            def legacy_model(name)
+              return nil unless defined?(Legion::Data::Model)
+              return nil unless Legion::Data::Model.const_defined?(name, false)
+
+              Legion::Data::Model.const_get(name, false)
+            end
+          end
+        end
+      end
+    end
+  end
+end