lex-apollo 0.4.22 → 0.4.24

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

@@ -12,9 +12,8 @@ module Legion
           }.freeze
 
           class << self
-            def log
-              Legion::Logging
-            end
+            include Legion::Logging::Helper
+            include Legion::Settings::Helper
 
             def detect_entities(text:, types: nil)
               return [] if text.nil? || text.empty?
@@ -23,11 +22,13 @@ module Legion
               entities = []
 
               types.each do |type_sym|
-                pattern = type_sym == :concept ? concept_pattern : ENTITY_PATTERNS[type_sym]
+                entity_type = type_sym == :repository ? :repo : type_sym
+                pattern = entity_type == :concept ? concept_pattern : ENTITY_PATTERNS[entity_type]
                 next unless pattern
 
                 text.scan(pattern).each do |match|
-                  entities << { type: type_sym, value: match.strip, confidence: Confidence.apollo_setting(:entity_watchdog, :detect_confidence, default: 0.5) }
+                  entities << { type: entity_type, value: match.strip,
+confidence: Confidence.apollo_setting(:entity_watchdog, :detect_confidence, default: 0.5) }
                 end
               end
 
@@ -55,11 +56,7 @@ module Legion
             end
 
             def concept_pattern
-              keywords = if defined?(Legion::Settings)
-                           Legion::Settings.dig(:apollo, :entity_watchdog, :concept_keywords) || []
-                         else
-                           []
-                         end
+              keywords = settings[:entity_watchdog][:concept_keywords]
               return nil if keywords.empty?
 
               Regexp.new("\\b(?:#{keywords.map { |k| Regexp.escape(k) }.join('|')})\\b", Regexp::IGNORECASE)
@@ -68,11 +65,7 @@ module Legion
             private
 
             def default_types
-              if defined?(Legion::Settings)
-                Legion::Settings.dig(:apollo, :entity_watchdog, :types) || %w[person service repo concept]
-              else
-                %w[person service repo concept]
-              end
+              settings[:entity_watchdog][:types]
             end
 
             def find_existing(_entity)

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

@@ -7,11 +7,10 @@ module Legion
     module Apollo
       module Helpers
         module Similarity
-          module_function
+          extend Legion::Logging::Helper
+          extend Legion::JSON::Helper
 
-          def log
-            Legion::Logging
-          end
+          module_function
 
           def cosine_similarity(vec_a:, vec_b:, **)
             vec_a = parse_vector(vec_a)
@@ -30,9 +29,9 @@ module Legion
             return vec if vec.is_a?(Array)
             return nil unless vec.is_a?(String)
 
-            ::JSON.parse(vec)
+            json_parse(vec)
           rescue StandardError => e
-            log.warn("Apollo Similarity.parse_vector failed: #{e.message}")
+            handle_exception(e, level: :warn, operation: 'apollo.similarity.parse_vector')
             nil
           end
 

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

@@ -8,16 +8,15 @@ module Legion
     module Apollo
       module Helpers
         module Writeback
+          extend Legion::Logging::Helper
+          extend Legion::Settings::Helper
+
           RESEARCH_TOOLS = %w[read_file search_files search_content run_command].freeze
           MAX_CONTENT_LENGTH = 4000
           MIN_CONTENT_LENGTH = 50
 
           module_function
 
-          def log
-            Legion::Logging
-          end
-
           def evaluate_and_route(request:, response:, enrichments: {})
             return unless writeback_enabled?
             return unless should_capture?(request, response, enrichments)
@@ -25,7 +24,7 @@ module Legion
             payload = build_payload(request: request, response: response)
             route_payload(payload)
           rescue StandardError => e
-            log.warn("apollo writeback failed: #{e.message}")
+            handle_exception(e, level: :warn, operation: 'apollo.writeback.evaluate_and_route')
           end
 
           def should_capture?(_request, response, enrichments)
@@ -68,7 +67,7 @@ module Legion
             can_write = Helpers::Capability.can_write?
 
             if can_embed
-              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
               payload[:embedding] = vector.is_a?(Array) && vector.any? ? vector : Array.new(1024, 0.0)
             end
@@ -87,7 +86,7 @@ module Legion
               Runners::Knowledge.handle_ingest(**payload)
             end
           rescue StandardError => e
-            log.warn("apollo direct write failed, falling back to transport: #{e.message}")
+            handle_exception(e, level: :warn, operation: 'apollo.writeback.write_directly')
             publish_to_transport(payload, has_embedding: !payload[:embedding].nil?)
           end
 
@@ -98,20 +97,20 @@ module Legion
               **payload, has_embedding: has_embedding
             ).publish
           rescue StandardError => e
-            log.warn("apollo writeback publish failed: #{e.message}")
+            handle_exception(e, level: :warn, operation: 'apollo.writeback.publish_to_transport')
           end
 
           def writeback_enabled?
-            Legion::Settings.dig(:apollo, :writeback, :enabled) != false
+            settings[:writeback][:enabled] != false
           rescue StandardError => e
-            log.warn("Apollo Writeback.writeback_enabled? failed: #{e.message}")
+            handle_exception(e, level: :warn, operation: 'apollo.writeback.writeback_enabled')
             true
           end
 
           def min_content_length
-            Legion::Settings.dig(:apollo, :writeback, :min_content_length) || MIN_CONTENT_LENGTH
+            settings[:writeback][:min_content_length]
           rescue StandardError => e
-            log.warn("Apollo Writeback.min_content_length failed: #{e.message}")
+            handle_exception(e, level: :warn, operation: 'apollo.writeback.min_content_length')
             MIN_CONTENT_LENGTH
           end
 
@@ -132,7 +131,7 @@ module Legion
 
             request.caller.dig(:requested_by, :identity) || 'unknown'
           rescue StandardError => e
-            log.warn("Apollo Writeback.extract_identity failed: #{e.message}")
+            handle_exception(e, level: :warn, operation: 'apollo.writeback.extract_identity')
             'unknown'
           end
 
@@ -142,7 +141,7 @@ module Legion
             user_msgs = Array(request.messages).select { |m| m[:role] == 'user' || m['role'] == 'user' }
             (user_msgs.last || {})[:content] || ''
           rescue StandardError => e
-            log.warn("Apollo Writeback.extract_user_query failed: #{e.message}")
+            handle_exception(e, level: :warn, operation: 'apollo.writeback.extract_user_query')
             ''
           end
 

data/lib/legion/extensions/apollo/runners/expertise.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require_relative '../helpers/data_models'
+
 module Legion
   module Extensions
     module Apollo
@@ -18,15 +20,15 @@ module Legion
           end
 
           def aggregate(**)
-            unless defined?(Legion::Data::Model::ApolloEntry)
+            unless Helpers::DataModels.apollo_entry_available?
               log.warn('Apollo Expertise.aggregate skipped: apollo_data_not_available')
               return { success: false, error: 'apollo_data_not_available' }
             end
 
-            entries = Legion::Data::Model::ApolloEntry
-                      .select(:source_agent, :tags, :confidence)
-                      .exclude(source_agent: nil)
-                      .all
+            entries = Helpers::DataModels.apollo_entry
+                                         .select(:source_agent, :tags, :confidence)
+                                         .exclude(source_agent: nil)
+                                         .all
             log.debug("Apollo Expertise.aggregate entries=#{entries.size}")
 
             agent_set = Set.new
@@ -58,13 +60,13 @@ module Legion
           def upsert_expertise_group(group)
             count = group[:confidences].size
             proficiency = expertise_proficiency(group[:confidences])
-            existing = Legion::Data::Model::ApolloExpertise
-                       .where(agent_id: group[:agent_id], domain: group[:domain]).first
+            existing = Helpers::DataModels.apollo_expertise
+                                          .where(agent_id: group[:agent_id], domain: group[:domain]).first
 
             if existing
               existing.update(proficiency: proficiency, entry_count: count, last_active_at: Time.now)
             else
-              Legion::Data::Model::ApolloExpertise.create(
+              Helpers::DataModels.apollo_expertise.create(
                 agent_id: group[:agent_id], domain: group[:domain],
                 proficiency: proficiency, entry_count: count, last_active_at: Time.now
               )

data/lib/legion/extensions/apollo/runners/gas.rb

@@ -6,7 +6,11 @@ module Legion
       module Runners
         module Gas
           include Legion::Extensions::Helpers::Lex if defined?(Legion::Extensions::Helpers::Lex)
+          include Legion::Logging::Helper
+          include Legion::JSON::Helper
           extend Legion::Extensions::Helpers::Lex if defined?(Legion::Extensions::Helpers::Lex)
+          extend Legion::Logging::Helper
+          extend Legion::JSON::Helper
 
           RELATION_TYPES = %w[
             similar_to contradicts depends_on causes
@@ -20,7 +24,7 @@ module Legion
           module_function
 
           def json_load(str)
-            ::JSON.parse(str, symbolize_names: true)
+            json_parse(str)
           end
 
           def relate_confidence_gate = Helpers::Confidence.apollo_setting(:gas, :relate_confidence_gate, default: RELATE_CONFIDENCE_GATE)
@@ -56,7 +60,7 @@ module Legion
             log.info("GAS process complete facts=#{result[:facts]} entities=#{result[:entities]} relations=#{result[:relations]} synthesis=#{result[:synthesis]} anticipations=#{result[:anticipations]}") # rubocop:disable Layout/LineLength
             result
           rescue StandardError => e
-            log.error("GAS pipeline error: #{e.message}")
+            handle_exception(e, level: :error, operation: 'apollo.gas.process')
             { phases_completed: 0, error: e.message }
           end
 
@@ -88,7 +92,7 @@ module Legion
             log.debug("GAS phase_extract success=#{result[:success]} entities=#{entities.size}")
             entities
           rescue StandardError => e
-            log.warn("GAS phase_extract failed: #{e.message}")
+            handle_exception(e, level: :warn, operation: 'apollo.gas.phase_extract')
             []
           end
 
@@ -131,7 +135,7 @@ module Legion
             log.debug("GAS phase_synthesize synthesis=#{synthesis.size}")
             synthesis
           rescue StandardError => e
-            log.warn("GAS phase_synthesize failed: #{e.message}")
+            handle_exception(e, level: :warn, operation: 'apollo.gas.phase_synthesize')
             []
           end
 
@@ -155,7 +159,7 @@ module Legion
               )
               deposited += 1
             rescue StandardError => e
-              log.warn("GAS deposit error: #{e.message}")
+              handle_exception(e, level: :warn, operation: 'apollo.gas.phase_deposit_fact')
             end
             log.info("GAS phase_deposit deposited=#{deposited} facts=#{facts.size}")
             { deposited: deposited }
@@ -176,7 +180,7 @@ module Legion
             log.debug("GAS phase_anticipate anticipations=#{anticipations.size}")
             anticipations
           rescue StandardError => e
-            log.warn("GAS phase_anticipate failed: #{e.message}")
+            handle_exception(e, level: :warn, operation: 'apollo.gas.phase_anticipate')
             []
           end
 
@@ -188,7 +192,7 @@ module Legion
               result = Runners::Knowledge.retrieve_relevant(query: fact[:content], limit: lim, min_confidence: min_conf)
               entries.concat(result[:entries]) if result[:success] && result[:entries]&.any?
             rescue StandardError => e
-              log.warn("GAS fetch_similar_entries failed for fact: #{e.message}")
+              handle_exception(e, level: :warn, operation: 'apollo.gas.fetch_similar_entries')
               next
             end
             unique = entries.uniq { |e| e[:id] }
@@ -204,11 +208,11 @@ module Legion
               { from_content: fact[:content], to_id: entry[:id], relation_type: 'similar_to', confidence: fb_conf }
             end
           rescue StandardError => e
-            log.warn("GAS classify_relation failed: #{e.message}")
+            handle_exception(e, level: :warn, operation: 'apollo.gas.classify_relation')
             { from_content: fact[:content], to_id: entry[:id], relation_type: 'similar_to', confidence: fallback_confidence }
           end
 
-          def llm_classify_relation(fact, entry)
+          def llm_classify_relation(fact, entry) # rubocop:disable Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
             prompt = <<~PROMPT
               Classify the relationship between these two knowledge entries.
               Valid types: #{RELATION_TYPES.join(', ')}
@@ -241,9 +245,13 @@ module Legion
               phase:   'gas_relate'
             )
 
-            content = result.respond_to?(:message) ? result.message[:content] : result.to_s
-            parsed = json_load(content)
-            rels = parsed.is_a?(Hash) ? (parsed[:relations] || parsed['relations'] || []) : []
+            rels = if result.is_a?(Hash) && result[:data].is_a?(Hash)
+                     result[:data][:relations] || result.dig(:data, 'relations') || []
+                   else
+                     content = result.respond_to?(:message) ? result.message[:content] : result.to_s
+                     parsed = json_load(content)
+                     parsed.is_a?(Hash) ? (parsed[:relations] || parsed['relations'] || []) : []
+                   end
             best = rels.max_by { |r| r[:confidence] || r['confidence'] || 0 }
 
             return fallback_relation(fact, entry) unless best
@@ -254,7 +262,7 @@ module Legion
 
             { from_content: fact[:content], to_id: entry[:id], relation_type: rtype, confidence: conf }
           rescue StandardError => e
-            log.warn("GAS llm_classify_relation failed: #{e.message}")
+            handle_exception(e, level: :warn, operation: 'apollo.gas.llm_classify_relation')
             fallback_relation(fact, entry)
           end
 
@@ -298,13 +306,17 @@ module Legion
               phase:   'gas_synthesize'
             )
 
-            content = result.respond_to?(:message) ? result.message[:content] : result.to_s
-            parsed = json_load(content)
-            items = parsed.is_a?(Hash) ? (parsed[:synthesis] || parsed['synthesis'] || []) : []
+            items = if result.is_a?(Hash) && result[:data].is_a?(Hash)
+                      result[:data][:synthesis] || result.dig(:data, 'synthesis') || []
+                    else
+                      content = result.respond_to?(:message) ? result.message[:content] : result.to_s
+                      parsed = json_load(content)
+                      parsed.is_a?(Hash) ? (parsed[:synthesis] || parsed['synthesis'] || []) : []
+                    end
 
             items.map { |item| build_synthesis_entry(item, facts) }
           rescue StandardError => e
-            log.warn("GAS llm_synthesize failed: #{e.message}")
+            handle_exception(e, level: :warn, operation: 'apollo.gas.llm_synthesize')
             []
           end
 
@@ -354,9 +366,13 @@ module Legion
               phase:   'gas_anticipate'
             )
 
-            content = result.respond_to?(:message) ? result.message[:content] : result.to_s
-            parsed = json_load(content)
-            questions = parsed.is_a?(Hash) ? (parsed[:questions] || parsed['questions'] || []) : []
+            questions = if result.is_a?(Hash) && result[:data].is_a?(Hash)
+                          result[:data][:questions] || result.dig(:data, 'questions') || []
+                        else
+                          content = result.respond_to?(:message) ? result.message[:content] : result.to_s
+                          parsed = json_load(content)
+                          parsed.is_a?(Hash) ? (parsed[:questions] || parsed['questions'] || []) : []
+                        end
             questions = questions.first(max_anticipations)
 
             questions.map do |q|
@@ -364,7 +380,7 @@ module Legion
               { question: q }
             end
           rescue StandardError => e
-            log.warn("GAS llm_anticipate failed: #{e.message}")
+            handle_exception(e, level: :warn, operation: 'apollo.gas.llm_anticipate')
             []
           end
 
@@ -377,14 +393,14 @@ module Legion
               confidence: fallback_confidence
             )
           rescue StandardError => e
-            log.warn("GAS promote_to_pattern_store failed: #{e.message}")
+            handle_exception(e, level: :warn, operation: 'apollo.gas.promote_to_pattern_store')
             nil
           end
 
           def llm_available?
             defined?(Legion::LLM::Pipeline::GaiaCaller)
           rescue StandardError => e
-            log.warn("GAS llm_available? check failed: #{e.message}")
+            handle_exception(e, level: :warn, operation: 'apollo.gas.llm_available')
             false
           end
 
@@ -422,9 +438,13 @@ module Legion
               phase:   'gas_comprehend'
             )
 
-            content = result.respond_to?(:message) ? result.message[:content] : result.to_s
-            parsed = json_load(content)
-            facts_array = parsed.is_a?(Hash) ? (parsed[:facts] || parsed['facts'] || []) : Array(parsed)
+            facts_array = if result.is_a?(Hash) && result[:data].is_a?(Hash)
+                            result[:data][:facts] || result.dig(:data, 'facts') || []
+                          else
+                            content = result.respond_to?(:message) ? result.message[:content] : result.to_s
+                            parsed = json_load(content)
+                            parsed.is_a?(Hash) ? (parsed[:facts] || parsed['facts'] || []) : Array(parsed)
+                          end
             facts_array.map do |f|
               {
                 content:      f[:content] || f['content'],
@@ -432,7 +452,7 @@ module Legion
               }
             end
           rescue StandardError => e
-            log.warn("GAS llm_comprehend failed: #{e.message}")
+            handle_exception(e, level: :warn, operation: 'apollo.gas.llm_comprehend')
             mechanical_comprehend(messages, response)
           end
         end