lex-apollo 0.3.3 → 0.3.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: e5f9f60cb9a67bc5d4cd35af051b1abe3251787d0da55ac092c1898942bd2144
-  data.tar.gz: 8b0cd86443469ae7a0d5d857a127f855cd0e68f8d967c94a727e8f166372e483
+  metadata.gz: e7d785a9fed9656eb22b307620a384f64e52646bca14728dc0de3ef2b1adb5bd
+  data.tar.gz: c64bcf1b75ee0ed43a747722a610c5cee8de823995d5f7455e31ae5c9174c56d
 SHA512:
-  metadata.gz: 3f239c19c6212f7c142aec1e0fe34aed651928f5a4c37acfcf54152d6719594f94b6ddb037bf48666eb93f9c747d341a477039e320e2e74fef17a8188519e0a9
-  data.tar.gz: 6227ef5fffa37ad570940591d390ac594d71f10a49de1e75a6ce568b075ac6c0293ba13478130eebbc366c6195b383327dab2b7400398bc2fe6f1f274f4b61ca
+  metadata.gz: 0ff89d33e4993dd8c71e392202c66add619ab04045fa674b5f8f0c4d891b727ca7401865d349c68bdc3a0344e1773db4f86651ed7e96ecbcaf0098a9d05cdbc9
+  data.tar.gz: 29b69744b9870bee8e1fbfc030652aede63a51c3a12cd02a3bc69bfc805b6267cf8045346cb37dc2565e1e103ae6f3b559972536b02f3a62dd4b6f12223361a5

data/CHANGELOG.md

@@ -1,5 +1,12 @@
 # Changelog
 
+## [0.3.4] - 2026-03-20
+
+### Added
+- `Helpers::EntityWatchdog`: regex-based entity detection for persons, services, repos, and configurable concepts
+- GAIA `post_tick_reflection` handler for passive entity detection (enabled via `apollo.entity_watchdog.enabled`)
+- Deduplication by type+value, configurable type filtering, and `link_or_create` for Apollo integration
+
 ## [0.3.3] - 2026-03-20
 
 ### Added

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

@@ -0,0 +1,94 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module Apollo
+      module Helpers
+        module EntityWatchdog
+          ENTITY_PATTERNS = {
+            person:  /\b[A-Z][a-z]+(?:\s[A-Z][a-z]+)+\b/,
+            service: %r{\bhttps?://[^\s]+\b},
+            repo:    %r{\b[a-zA-Z0-9_-]+/[a-zA-Z0-9_.-]+\b}
+          }.freeze
+
+          class << self
+            def detect_entities(text:, types: nil)
+              return [] if text.nil? || text.empty?
+
+              types = (types || default_types).map(&:to_sym)
+              entities = []
+
+              types.each do |type_sym|
+                pattern = type_sym == :concept ? concept_pattern : ENTITY_PATTERNS[type_sym]
+                next unless pattern
+
+                text.scan(pattern).each do |match|
+                  entities << { type: type_sym, value: match.strip, confidence: 0.5 }
+                end
+              end
+
+              entities.uniq { |e| [e[:type], e[:value].downcase] }
+            end
+
+            def link_or_create(entities:, source_context: nil)
+              return { success: true, linked: 0, created: 0 } if entities.nil? || entities.empty?
+
+              linked = 0
+              created = 0
+
+              entities.each do |entity|
+                existing = find_existing(entity)
+                if existing
+                  bump_confidence(existing, source_context)
+                  linked += 1
+                else
+                  create_candidate(entity, source_context)
+                  created += 1
+                end
+              end
+
+              { success: true, linked: linked, created: created }
+            end
+
+            def concept_pattern
+              keywords = if defined?(Legion::Settings)
+                           Legion::Settings.dig(:apollo, :entity_watchdog, :concept_keywords) || []
+                         else
+                           []
+                         end
+              return nil if keywords.empty?
+
+              Regexp.new("\\b(?:#{keywords.map { |k| Regexp.escape(k) }.join('|')})\\b", Regexp::IGNORECASE)
+            end
+
+            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
+            end
+
+            def find_existing(_entity)
+              return nil unless defined?(Runners::Knowledge) && respond_to?(:retrieve_relevant, true)
+
+              nil
+            end
+
+            def bump_confidence(_entry, _source_context)
+              # Increment retrieval confidence on existing Apollo entry
+            end
+
+            def create_candidate(entity, _source_context)
+              return unless defined?(Runners::Knowledge)
+
+              Legion::Logging.debug "[entity_watchdog] candidate: #{entity[:type]}=#{entity[:value]}" if defined?(Legion::Logging)
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -3,7 +3,7 @@
 module Legion
   module Extensions
     module Apollo
-      VERSION = '0.3.3'
+      VERSION = '0.3.4'
     end
   end
 end

data/lib/legion/extensions/apollo.rb

@@ -24,3 +24,20 @@ module Legion
     end
   end
 end
+
+# Entity watchdog on post_tick_reflection
+if defined?(Legion::Gaia::PhaseWiring) && begin
+  Legion::Settings.dig(:apollo, :entity_watchdog, :enabled)
+rescue StandardError
+  false
+end
+  require 'legion/extensions/apollo/helpers/entity_watchdog'
+  Legion::Gaia::PhaseWiring.register_handler(:post_tick_reflection) do |tick_results|
+    text = tick_results.is_a?(Hash) ? (tick_results[:content] || tick_results[:output] || '').to_s : tick_results.to_s
+    entities = Legion::Extensions::Apollo::Helpers::EntityWatchdog.detect_entities(text: text)
+    if entities.any?
+      Legion::Extensions::Apollo::Helpers::EntityWatchdog.link_or_create(entities:       entities,
+                                                                         source_context: tick_results[:tick_id])
+    end
+  end
+end

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

@@ -45,4 +45,29 @@ RSpec.describe Legion::Extensions::Apollo::GaiaIntegration do
       expect(result).to eq({ success: true })
     end
   end
+
+  describe 'entity watchdog phase handler' do
+    it 'detects entities from tick results' do
+      require 'legion/extensions/apollo/helpers/entity_watchdog'
+      tick_results = { content: 'Jane Doe deployed to https://api.example.com', tick_id: 'tick-1' }
+      entities = Legion::Extensions::Apollo::Helpers::EntityWatchdog.detect_entities(text: tick_results[:content])
+      expect(entities.size).to be >= 2
+    end
+
+    it 'links or creates entities from tick results' do
+      require 'legion/extensions/apollo/helpers/entity_watchdog'
+      tick_results = { content: 'Jane Doe at LegionIO/lex-mesh', tick_id: 'tick-2' }
+      entities = Legion::Extensions::Apollo::Helpers::EntityWatchdog.detect_entities(text: tick_results[:content])
+      result = Legion::Extensions::Apollo::Helpers::EntityWatchdog.link_or_create(
+        entities: entities, source_context: tick_results[:tick_id]
+      )
+      expect(result[:success]).to be true
+    end
+
+    it 'entry point has entity watchdog registration block' do
+      entry_point = File.read(File.expand_path('../../../../lib/legion/extensions/apollo.rb', __dir__))
+      expect(entry_point).to include('entity_watchdog')
+      expect(entry_point).to include('PhaseWiring.register_handler(:post_tick_reflection)')
+    end
+  end
 end

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

@@ -0,0 +1,64 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+require 'legion/extensions/apollo/helpers/entity_watchdog'
+
+RSpec.describe Legion::Extensions::Apollo::Helpers::EntityWatchdog do
+  describe '.detect_entities' do
+    it 'detects person names (capitalized multi-word)' do
+      entities = described_class.detect_entities(text: 'Talked to Jane Doe about the project')
+      person = entities.find { |e| e[:type] == :person }
+      expect(person).not_to be_nil
+      expect(person[:value]).to eq('Jane Doe')
+    end
+
+    it 'detects service URLs' do
+      entities = described_class.detect_entities(text: 'Deployed to https://api.example.com/v1')
+      service = entities.find { |e| e[:type] == :service }
+      expect(service).not_to be_nil
+      expect(service[:value]).to include('example.com')
+    end
+
+    it 'detects repo references' do
+      entities = described_class.detect_entities(text: 'Check LegionIO/lex-mesh for the code')
+      repo = entities.find { |e| e[:type] == :repo }
+      expect(repo).not_to be_nil
+      expect(repo[:value]).to eq('LegionIO/lex-mesh')
+    end
+
+    it 'detects concept keywords from settings' do
+      allow(described_class).to receive(:concept_pattern).and_return(/\b(?:kubernetes|terraform)\b/i)
+      entities = described_class.detect_entities(text: 'Using Terraform to deploy Kubernetes')
+      concepts = entities.select { |e| e[:type] == :concept }
+      expect(concepts.size).to eq(2)
+    end
+
+    it 'deduplicates entities by type and lowercase value' do
+      entities = described_class.detect_entities(text: 'Jane Doe met Jane Doe again')
+      persons = entities.select { |e| e[:type] == :person }
+      expect(persons.size).to eq(1)
+    end
+
+    it 'returns empty array for text with no entities' do
+      entities = described_class.detect_entities(text: 'nothing special here')
+      expect(entities).to be_empty
+    end
+
+    it 'filters by specified types' do
+      entities = described_class.detect_entities(
+        text:  'Jane Doe at https://example.com with LegionIO/lex-mesh',
+        types: [:person]
+      )
+      expect(entities.all? { |e| e[:type] == :person }).to be true
+    end
+  end
+
+  describe '.link_or_create' do
+    it 'returns counts for empty entities' do
+      result = described_class.link_or_create(entities: [])
+      expect(result[:success]).to be true
+      expect(result[:linked]).to eq(0)
+      expect(result[:created]).to eq(0)
+    end
+  end
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: lex-apollo
 version: !ruby/object:Gem::Version
-  version: 0.3.3
+  version: 0.3.4
 platform: ruby
 authors:
 - Esity
@@ -58,6 +58,7 @@ files:
 - lib/legion/extensions/apollo/gaia_integration.rb
 - lib/legion/extensions/apollo/helpers/confidence.rb
 - lib/legion/extensions/apollo/helpers/embedding.rb
+- lib/legion/extensions/apollo/helpers/entity_watchdog.rb
 - lib/legion/extensions/apollo/helpers/graph_query.rb
 - lib/legion/extensions/apollo/helpers/similarity.rb
 - lib/legion/extensions/apollo/runners/entity_extractor.rb
@@ -80,6 +81,7 @@ files:
 - spec/legion/extensions/apollo/gaia_integration_spec.rb
 - spec/legion/extensions/apollo/helpers/confidence_spec.rb
 - spec/legion/extensions/apollo/helpers/embedding_spec.rb
+- spec/legion/extensions/apollo/helpers/entity_watchdog_spec.rb
 - spec/legion/extensions/apollo/helpers/graph_query_spec.rb
 - spec/legion/extensions/apollo/helpers/similarity_spec.rb
 - spec/legion/extensions/apollo/runners/decay_cycle_spec.rb