lex-apollo 0.2.0

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

@@ -0,0 +1,109 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+require 'legion/extensions/apollo/helpers/confidence'
+
+RSpec.describe Legion::Extensions::Apollo::Helpers::Confidence do
+  describe 'constants' do
+    it 'defines INITIAL_CONFIDENCE' do
+      expect(described_class::INITIAL_CONFIDENCE).to eq(0.5)
+    end
+
+    it 'defines CORROBORATION_BOOST' do
+      expect(described_class::CORROBORATION_BOOST).to eq(0.3)
+    end
+
+    it 'defines RETRIEVAL_BOOST' do
+      expect(described_class::RETRIEVAL_BOOST).to eq(0.02)
+    end
+
+    it 'defines HOURLY_DECAY_FACTOR' do
+      expect(described_class::HOURLY_DECAY_FACTOR).to eq(0.998)
+    end
+
+    it 'defines DECAY_THRESHOLD' do
+      expect(described_class::DECAY_THRESHOLD).to eq(0.1)
+    end
+
+    it 'defines CORROBORATION_SIMILARITY_THRESHOLD' do
+      expect(described_class::CORROBORATION_SIMILARITY_THRESHOLD).to eq(0.9)
+    end
+
+    it 'defines WRITE_CONFIDENCE_GATE' do
+      expect(described_class::WRITE_CONFIDENCE_GATE).to eq(0.6)
+    end
+
+    it 'defines WRITE_NOVELTY_GATE' do
+      expect(described_class::WRITE_NOVELTY_GATE).to eq(0.3)
+    end
+
+    it 'defines STALE_DAYS' do
+      expect(described_class::STALE_DAYS).to eq(90)
+    end
+  end
+
+  describe '.apply_decay' do
+    it 'multiplies confidence by HOURLY_DECAY_FACTOR' do
+      result = described_class.apply_decay(confidence: 1.0)
+      expect(result).to eq(0.998)
+    end
+
+    it 'accepts a custom factor' do
+      result = described_class.apply_decay(confidence: 1.0, factor: 0.5)
+      expect(result).to eq(0.5)
+    end
+
+    it 'clamps to 0.0 minimum' do
+      result = described_class.apply_decay(confidence: 0.001, factor: 0.001)
+      expect(result).to be >= 0.0
+    end
+  end
+
+  describe '.apply_retrieval_boost' do
+    it 'adds RETRIEVAL_BOOST to confidence' do
+      result = described_class.apply_retrieval_boost(confidence: 0.5)
+      expect(result).to eq(0.52)
+    end
+
+    it 'clamps to 1.0 maximum' do
+      result = described_class.apply_retrieval_boost(confidence: 0.99)
+      expect(result).to eq(1.0)
+    end
+  end
+
+  describe '.apply_corroboration_boost' do
+    it 'adds CORROBORATION_BOOST to confidence' do
+      result = described_class.apply_corroboration_boost(confidence: 0.5)
+      expect(result).to eq(0.8)
+    end
+
+    it 'clamps to 1.0 maximum' do
+      result = described_class.apply_corroboration_boost(confidence: 0.9)
+      expect(result).to eq(1.0)
+    end
+  end
+
+  describe '.decayed?' do
+    it 'returns true when confidence below threshold' do
+      expect(described_class.decayed?(confidence: 0.05)).to be true
+    end
+
+    it 'returns false when confidence at or above threshold' do
+      expect(described_class.decayed?(confidence: 0.1)).to be false
+    end
+  end
+
+  describe '.meets_write_gate?' do
+    it 'returns true when both gates met' do
+      expect(described_class.meets_write_gate?(confidence: 0.7, novelty: 0.4)).to be true
+    end
+
+    it 'returns false when confidence below gate' do
+      expect(described_class.meets_write_gate?(confidence: 0.5, novelty: 0.4)).to be false
+    end
+
+    it 'returns false when novelty below gate' do
+      expect(described_class.meets_write_gate?(confidence: 0.7, novelty: 0.2)).to be false
+    end
+  end
+end

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

@@ -0,0 +1,68 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+require 'legion/extensions/apollo/helpers/embedding'
+
+RSpec.describe Legion::Extensions::Apollo::Helpers::Embedding do
+  describe '.generate' do
+    context 'when Legion::LLM is not defined' do
+      before do
+        hide_const('Legion::LLM') if defined?(Legion::LLM)
+      end
+
+      it 'returns a zero vector of the correct dimension' do
+        result = described_class.generate(text: 'hello world')
+        expect(result).to eq(Array.new(1536, 0.0))
+        expect(result.size).to eq(1536)
+      end
+    end
+
+    context 'when Legion::LLM is defined but not started' do
+      before do
+        stub_const('Legion::LLM', Module.new { def self.started? = false })
+      end
+
+      it 'returns a zero vector' do
+        result = described_class.generate(text: 'hello world')
+        expect(result).to eq(Array.new(1536, 0.0))
+      end
+    end
+
+    context 'when Legion::LLM is available and started' do
+      let(:mock_embedding) { Array.new(1536) { rand(-1.0..1.0) } }
+
+      before do
+        llm = Module.new do
+          define_method(:started?) { true }
+          define_method(:embed) { |_text:| nil }
+          extend self
+        end
+        stub_const('Legion::LLM', llm)
+        allow(Legion::LLM).to receive(:embed).and_return(mock_embedding)
+      end
+
+      it 'returns the embedding from LLM' do
+        result = described_class.generate(text: 'hello world')
+        expect(result).to eq(mock_embedding)
+        expect(Legion::LLM).to have_received(:embed).with(text: 'hello world')
+      end
+    end
+
+    context 'when Legion::LLM returns invalid embedding' do
+      before do
+        llm = Module.new do
+          define_method(:started?) { true }
+          define_method(:embed) { |_text:| nil }
+          extend self
+        end
+        stub_const('Legion::LLM', llm)
+        allow(Legion::LLM).to receive(:embed).and_return([0.1, 0.2])
+      end
+
+      it 'returns a zero vector as fallback' do
+        result = described_class.generate(text: 'hello world')
+        expect(result).to eq(Array.new(1536, 0.0))
+      end
+    end
+  end
+end

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

@@ -0,0 +1,69 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+require 'legion/extensions/apollo/helpers/graph_query'
+
+RSpec.describe Legion::Extensions::Apollo::Helpers::GraphQuery do
+  describe 'constants' do
+    it 'defines SPREAD_FACTOR' do
+      expect(described_class::SPREAD_FACTOR).to eq(0.6)
+    end
+
+    it 'defines DEFAULT_DEPTH' do
+      expect(described_class::DEFAULT_DEPTH).to eq(2)
+    end
+
+    it 'defines MIN_ACTIVATION' do
+      expect(described_class::MIN_ACTIVATION).to eq(0.1)
+    end
+  end
+
+  describe '.build_traversal_sql' do
+    it 'returns SQL string with entry_id placeholder' do
+      sql = described_class.build_traversal_sql(depth: 2)
+      expect(sql).to include('apollo_entries')
+      expect(sql).to include('apollo_relations')
+      expect(sql).to include('WITH RECURSIVE')
+      expect(sql).to include('$entry_id')
+    end
+
+    it 'includes relation type filter when specified' do
+      sql = described_class.build_traversal_sql(depth: 2, relation_types: %w[causes depends_on])
+      expect(sql).to include("'causes'")
+      expect(sql).to include("'depends_on'")
+    end
+
+    it 'respects custom depth' do
+      sql = described_class.build_traversal_sql(depth: 3)
+      expect(sql).to include('g.depth < 3')
+    end
+
+    it 'applies spread factor and min activation' do
+      sql = described_class.build_traversal_sql(depth: 2)
+      expect(sql).to include('0.6')
+      expect(sql).to include('0.1')
+    end
+  end
+
+  describe '.build_semantic_search_sql' do
+    it 'returns SQL with vector placeholder' do
+      sql = described_class.build_semantic_search_sql(limit: 5, min_confidence: 0.3)
+      expect(sql).to include('apollo_entries')
+      expect(sql).to include('$embedding')
+      expect(sql).to include('<=>')
+      expect(sql).to include('LIMIT 5')
+    end
+
+    it 'includes status filter' do
+      sql = described_class.build_semantic_search_sql(limit: 10, statuses: %w[confirmed])
+      expect(sql).to include("'confirmed'")
+    end
+
+    it 'includes tag filter when specified' do
+      sql = described_class.build_semantic_search_sql(limit: 10, tags: %w[vault dns])
+      expect(sql).to include("'vault'")
+      expect(sql).to include("'dns'")
+      expect(sql).to include('&&')
+    end
+  end
+end

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

@@ -0,0 +1,58 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+require 'legion/extensions/apollo/helpers/similarity'
+
+RSpec.describe Legion::Extensions::Apollo::Helpers::Similarity do
+  describe '.cosine_similarity' do
+    it 'returns 1.0 for identical vectors' do
+      vec = [1.0, 0.0, 0.0]
+      expect(described_class.cosine_similarity(vec_a: vec, vec_b: vec)).to be_within(0.001).of(1.0)
+    end
+
+    it 'returns 0.0 for orthogonal vectors' do
+      vec_a = [1.0, 0.0]
+      vec_b = [0.0, 1.0]
+      expect(described_class.cosine_similarity(vec_a: vec_a, vec_b: vec_b)).to be_within(0.001).of(0.0)
+    end
+
+    it 'returns correct similarity for known vectors' do
+      vec_a = [1.0, 2.0, 3.0]
+      vec_b = [4.0, 5.0, 6.0]
+      expect(described_class.cosine_similarity(vec_a: vec_a, vec_b: vec_b)).to be_within(0.001).of(0.9746)
+    end
+
+    it 'returns 0.0 for zero vectors' do
+      vec_a = [0.0, 0.0]
+      vec_b = [1.0, 1.0]
+      expect(described_class.cosine_similarity(vec_a: vec_a, vec_b: vec_b)).to eq(0.0)
+    end
+  end
+
+  describe '.above_corroboration_threshold?' do
+    it 'returns true when similarity exceeds threshold' do
+      expect(described_class.above_corroboration_threshold?(similarity: 0.95)).to be true
+    end
+
+    it 'returns false when similarity below threshold' do
+      expect(described_class.above_corroboration_threshold?(similarity: 0.85)).to be false
+    end
+  end
+
+  describe '.classify_match' do
+    it 'returns :corroboration for high similarity same type' do
+      result = described_class.classify_match(similarity: 0.95, same_content_type: true)
+      expect(result).to eq(:corroboration)
+    end
+
+    it 'returns :contradiction for high similarity with contradicts relation' do
+      result = described_class.classify_match(similarity: 0.95, same_content_type: true, contradicts: true)
+      expect(result).to eq(:contradiction)
+    end
+
+    it 'returns :novel for low similarity' do
+      result = described_class.classify_match(similarity: 0.5, same_content_type: true)
+      expect(result).to eq(:novel)
+    end
+  end
+end

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

@@ -0,0 +1,111 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+require 'legion/extensions/apollo/runners/expertise'
+
+RSpec.describe Legion::Extensions::Apollo::Runners::Expertise do
+  let(:runner) do
+    obj = Object.new
+    obj.extend(described_class)
+    obj
+  end
+
+  describe '#get_expertise' do
+    it 'returns an expertise query payload' do
+      result = runner.get_expertise(domain: 'vault')
+      expect(result[:action]).to eq(:expertise_query)
+      expect(result[:domain]).to eq('vault')
+      expect(result[:min_proficiency]).to eq(0.0)
+    end
+  end
+
+  describe '#domains_at_risk' do
+    it 'returns an at-risk query payload' do
+      result = runner.domains_at_risk(min_agents: 2)
+      expect(result[:action]).to eq(:domains_at_risk)
+      expect(result[:min_agents]).to eq(2)
+    end
+  end
+
+  describe '#agent_profile' do
+    it 'returns a profile query payload' do
+      result = runner.agent_profile(agent_id: 'worker-1')
+      expect(result[:action]).to eq(:agent_profile)
+      expect(result[:agent_id]).to eq('worker-1')
+    end
+  end
+
+  describe '#aggregate' do
+    let(:host) { Object.new.extend(described_class) }
+
+    context 'when Apollo data is not available' do
+      before { hide_const('Legion::Data::Model::ApolloEntry') if defined?(Legion::Data::Model::ApolloEntry) }
+
+      it 'returns a structured error' do
+        result = host.aggregate
+        expect(result[:success]).to be false
+        expect(result[:error]).to eq('apollo_data_not_available')
+      end
+    end
+
+    context 'when entries exist' do
+      let(:mock_entry_class) { double('ApolloEntry') }
+      let(:mock_expertise_class) { double('ApolloExpertise') }
+      let(:entries) do
+        [
+          double('e1', source_agent: 'agent-1', tags: ['ruby'], confidence: 0.8),
+          double('e2', source_agent: 'agent-1', tags: ['ruby'], confidence: 0.6),
+          double('e3', source_agent: 'agent-2', tags: ['python'], confidence: 0.9)
+        ]
+      end
+
+      before do
+        stub_const('Legion::Data::Model::ApolloEntry', mock_entry_class)
+        stub_const('Legion::Data::Model::ApolloExpertise', mock_expertise_class)
+        allow(mock_entry_class).to receive(:select).and_return(double(exclude: double(all: entries)))
+        allow(mock_expertise_class).to receive(:where).and_return(double(first: nil))
+        allow(mock_expertise_class).to receive(:create)
+      end
+
+      it 'returns agent and domain counts' do
+        result = host.aggregate
+        expect(result[:success]).to be true
+        expect(result[:agents]).to eq(2)
+        expect(result[:domains]).to eq(2)
+      end
+
+      it 'creates expertise records' do
+        expect(mock_expertise_class).to receive(:create).twice
+        host.aggregate
+      end
+
+      it 'computes proficiency using log2 formula' do
+        # agent-1 ruby: avg=0.7, count=2, proficiency = 0.7 * log2(3) = 0.7 * 1.585 = 1.109 -> capped at 1.0
+        expect(mock_expertise_class).to receive(:create).with(
+          hash_including(agent_id: 'agent-1', domain: 'ruby', proficiency: 1.0)
+        )
+        # agent-2 python: avg=0.9, count=1, proficiency = 0.9 * log2(2) = 0.9 * 1.0 = 0.9
+        expect(mock_expertise_class).to receive(:create).with(
+          hash_including(agent_id: 'agent-2', domain: 'python', proficiency: 0.9)
+        )
+        host.aggregate
+      end
+    end
+
+    context 'when no entries exist' do
+      let(:mock_entry_class) { double('ApolloEntry') }
+
+      before do
+        stub_const('Legion::Data::Model::ApolloEntry', mock_entry_class)
+        allow(mock_entry_class).to receive(:select).and_return(double(exclude: double(all: [])))
+      end
+
+      it 'returns zero counts' do
+        result = host.aggregate
+        expect(result[:success]).to be true
+        expect(result[:agents]).to eq(0)
+        expect(result[:domains]).to eq(0)
+      end
+    end
+  end
+end