lex-identity 0.2.0

data/lib/legion/extensions/identity/runners/identity.rb

@@ -0,0 +1,86 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module Identity
+      module Runners
+        module Identity
+          include Legion::Extensions::Helpers::Lex if Legion::Extensions.const_defined?(:Helpers) &&
+                                                      Legion::Extensions::Helpers.const_defined?(:Lex)
+
+          def observe_behavior(dimension:, value:, **)
+            fingerprint = identity_fingerprint
+            fingerprint.observe(dimension, value)
+
+            Legion::Logging.debug "[identity] observe: dim=#{dimension} val=#{value.round(2)} " \
+                                  "obs=#{fingerprint.observation_count} maturity=#{fingerprint.maturity}"
+            {
+              dimension:         dimension,
+              recorded:          true,
+              observation_count: fingerprint.observation_count,
+              maturity:          fingerprint.maturity
+            }
+          end
+
+          def observe_all(observations:, **)
+            fingerprint = identity_fingerprint
+            fingerprint.observe_all(observations)
+
+            Legion::Logging.debug "[identity] observe_all: dims=#{observations.keys.join(',')} " \
+                                  "obs=#{fingerprint.observation_count} maturity=#{fingerprint.maturity}"
+            {
+              dimensions_observed: observations.keys,
+              observation_count:   fingerprint.observation_count,
+              maturity:            fingerprint.maturity
+            }
+          end
+
+          def check_entropy(observations: {}, **)
+            fingerprint = identity_fingerprint
+            entropy = fingerprint.current_entropy(observations)
+            classification = Helpers::Dimensions.classify_entropy(entropy)
+            trend = fingerprint.entropy_trend
+
+            result = {
+              entropy:        entropy,
+              classification: classification,
+              trend:          trend,
+              in_range:       Helpers::Dimensions::OPTIMAL_ENTROPY_RANGE.cover?(entropy)
+            }
+
+            case classification
+            when :high_entropy
+              result[:warning] = :possible_impersonation_or_drift
+              result[:action] = :enter_caution_mode
+              Legion::Logging.warn "[identity] high entropy detected: #{entropy.round(3)} trend=#{trend} - possible impersonation"
+            when :low_entropy
+              result[:warning] = :possible_automation
+              result[:action] = :trigger_verification
+              Legion::Logging.warn "[identity] low entropy detected: #{entropy.round(3)} trend=#{trend} - possible automation"
+            else
+              Legion::Logging.debug "[identity] entropy check: #{entropy.round(3)} classification=#{classification} trend=#{trend}"
+            end
+
+            result
+          end
+
+          def identity_status(**)
+            fingerprint = identity_fingerprint
+            Legion::Logging.debug "[identity] status: maturity=#{fingerprint.maturity} observations=#{fingerprint.observation_count}"
+            fingerprint.to_h
+          end
+
+          def identity_maturity(**)
+            { maturity: identity_fingerprint.maturity }
+          end
+
+          private
+
+          def identity_fingerprint
+            @identity_fingerprint ||= Helpers::Fingerprint.new
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module Identity
+      VERSION = '0.2.0'
+    end
+  end
+end

data/lib/legion/extensions/identity.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+require 'legion/extensions/identity/version'
+require 'legion/extensions/identity/helpers/dimensions'
+require 'legion/extensions/identity/helpers/fingerprint'
+require 'legion/extensions/identity/helpers/vault_secrets'
+require 'legion/extensions/identity/runners/identity'
+require 'legion/extensions/identity/runners/entra'
+require 'legion/extensions/identity/actors/orphan_check'
+
+module Legion
+  module Extensions
+    module Identity
+      extend Legion::Extensions::Core if Legion::Extensions.const_defined? :Core
+    end
+  end
+end
+
+if defined?(Legion::Data::Local)
+  Legion::Data::Local.register_migrations(
+    name: :identity,
+    path: File.join(__dir__, 'identity', 'local_migrations')
+  )
+end

data/spec/legion/extensions/identity/actors/orphan_check_spec.rb

@@ -0,0 +1,104 @@
+# frozen_string_literal: true
+
+# Stub the framework actor base class since legionio gem is not available in test
+module Legion
+  module Extensions
+    module Actors
+      class Every # rubocop:disable Lint/EmptyClass
+      end
+    end
+  end
+end
+
+# Intercept the require in the actor file so it doesn't fail
+$LOADED_FEATURES << 'legion/extensions/actors/every'
+
+require 'legion/extensions/identity/actors/orphan_check'
+
+RSpec.describe Legion::Extensions::Identity::Actor::OrphanCheck do
+  subject(:actor) { described_class.new }
+
+  describe 'ORPHAN_CHECK_INTERVAL' do
+    it 'is 14400 seconds (4 hours)' do
+      expect(described_class::ORPHAN_CHECK_INTERVAL).to eq(14_400)
+    end
+  end
+
+  describe '#runner_class' do
+    it 'returns the Entra module' do
+      expect(actor.runner_class).to eq(Legion::Extensions::Identity::Runners::Entra)
+    end
+  end
+
+  describe '#runner_function' do
+    it 'returns check_orphans' do
+      expect(actor.runner_function).to eq('check_orphans')
+    end
+  end
+
+  describe '#time' do
+    it 'returns 14400 seconds using the constant' do
+      expect(actor.time).to eq(Legion::Extensions::Identity::Actor::OrphanCheck::ORPHAN_CHECK_INTERVAL)
+    end
+
+    it 'returns 14400' do
+      expect(actor.time).to eq(14_400)
+    end
+  end
+
+  describe '#use_runner?' do
+    it 'returns false' do
+      expect(actor.use_runner?).to be false
+    end
+  end
+
+  describe '#check_subtask?' do
+    it 'returns false' do
+      expect(actor.check_subtask?).to be false
+    end
+  end
+
+  describe '#generate_task?' do
+    it 'returns false' do
+      expect(actor.generate_task?).to be false
+    end
+  end
+
+  describe '#enabled?' do
+    context 'when Legion::Data is not defined' do
+      it 'returns false' do
+        hide_const('Legion::Data') if defined?(Legion::Data)
+        expect(actor.enabled?).to be_falsey
+      end
+    end
+
+    context 'when Legion::Data is defined and data is connected' do
+      it 'returns truthy' do
+        stub_const('Legion::Data', Module.new)
+        stub_const('Legion::Settings', Class.new)
+        settings_double = { connected: true }
+        allow(Legion::Settings).to receive(:[]).with(:data).and_return(settings_double)
+        expect(actor.enabled?).to be_truthy
+      end
+    end
+
+    context 'when Legion::Data is defined but connected is false' do
+      it 'returns false' do
+        stub_const('Legion::Data', Module.new)
+        stub_const('Legion::Settings', Class.new)
+        settings_double = { connected: false }
+        allow(Legion::Settings).to receive(:[]).with(:data).and_return(settings_double)
+        expect(actor.enabled?).to be false
+      end
+    end
+
+    context 'when Legion::Settings raises an error' do
+      it 'returns false' do
+        stub_const('Legion::Data', Module.new)
+        stub_const('Legion::Settings', Class.new)
+        allow(Legion::Settings).to receive(:[]).with(:data).and_raise(StandardError)
+        expect(actor.enabled?).to be false
+      end
+    end
+  end
+end

data/spec/legion/extensions/identity/client_spec.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+require 'legion/extensions/identity/client'
+
+RSpec.describe Legion::Extensions::Identity::Client do
+  let(:client) { described_class.new }
+
+  it 'responds to identity runner methods' do
+    expect(client).to respond_to(:observe_behavior)
+    expect(client).to respond_to(:observe_all)
+    expect(client).to respond_to(:check_entropy)
+    expect(client).to respond_to(:identity_status)
+    expect(client).to respond_to(:identity_maturity)
+  end
+
+  it 'round-trips identity lifecycle' do
+    # Build identity
+    50.times do
+      client.observe_all(observations: {
+                           communication_cadence: 0.5 + (rand * 0.1),
+                           vocabulary_patterns:   0.6 + (rand * 0.1),
+                           emotional_response:    0.4 + (rand * 0.1)
+                         })
+    end
+
+    expect(client.identity_maturity[:maturity]).to eq(:established)
+
+    # Check entropy with consistent behavior
+    result = client.check_entropy(observations: { communication_cadence: 0.55 })
+    expect(result[:entropy]).to be_between(0.0, 1.0)
+  end
+end

data/spec/legion/extensions/identity/helpers/dimensions_spec.rb

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+RSpec.describe Legion::Extensions::Identity::Helpers::Dimensions do
+  describe '.new_identity_model' do
+    it 'creates a model with 6 dimensions' do
+      model = described_class.new_identity_model
+      expect(model.size).to eq(6)
+      described_class::IDENTITY_DIMENSIONS.each do |dim|
+        expect(model[dim][:mean]).to eq(0.5)
+      end
+    end
+  end
+
+  describe '.compute_entropy' do
+    it 'returns 0.5 for empty observations' do
+      model = described_class.new_identity_model
+      expect(described_class.compute_entropy({}, model)).to eq(0.5)
+    end
+
+    it 'returns low entropy for observations matching baseline' do
+      model = described_class.new_identity_model
+      model[:communication_cadence][:observations] = 50
+      obs = { communication_cadence: 0.5 }
+      entropy = described_class.compute_entropy(obs, model)
+      expect(entropy).to be < 0.3
+    end
+
+    it 'returns high entropy for observations diverging from baseline' do
+      model = described_class.new_identity_model
+      model[:communication_cadence][:observations] = 50
+      model[:communication_cadence][:variance] = 0.1
+      obs = { communication_cadence: 1.0 }
+      entropy = described_class.compute_entropy(obs, model)
+      expect(entropy).to be > 0.3
+    end
+  end
+
+  describe '.classify_entropy' do
+    it 'classifies high entropy' do
+      expect(described_class.classify_entropy(0.8)).to eq(:high_entropy)
+    end
+
+    it 'classifies low entropy' do
+      expect(described_class.classify_entropy(0.1)).to eq(:low_entropy)
+    end
+
+    it 'classifies normal entropy' do
+      expect(described_class.classify_entropy(0.5)).to eq(:normal)
+    end
+  end
+end

data/spec/legion/extensions/identity/helpers/fingerprint_spec.rb

@@ -0,0 +1,66 @@
+# frozen_string_literal: true
+
+RSpec.describe Legion::Extensions::Identity::Helpers::Fingerprint do
+  let(:fp) { described_class.new }
+
+  describe '#observe' do
+    it 'records observation for valid dimension' do
+      fp.observe(:communication_cadence, 0.7)
+      expect(fp.observation_count).to eq(1)
+    end
+
+    it 'ignores invalid dimensions' do
+      fp.observe(:nonexistent, 0.5)
+      expect(fp.observation_count).to eq(0)
+    end
+
+    it 'shifts mean toward observed values' do
+      original = fp.model[:vocabulary_patterns][:mean]
+      10.times { fp.observe(:vocabulary_patterns, 0.9) }
+      expect(fp.model[:vocabulary_patterns][:mean]).to be > original
+    end
+  end
+
+  describe '#observe_all' do
+    it 'records multiple dimensions at once' do
+      fp.observe_all(communication_cadence: 0.6, vocabulary_patterns: 0.7)
+      expect(fp.observation_count).to eq(2)
+    end
+  end
+
+  describe '#current_entropy' do
+    it 'computes entropy against model' do
+      entropy = fp.current_entropy(communication_cadence: 0.5)
+      expect(entropy).to be_between(0.0, 1.0)
+    end
+
+    it 'tracks entropy history' do
+      3.times { fp.current_entropy(communication_cadence: 0.5) }
+      expect(fp.entropy_history.size).to eq(3)
+    end
+  end
+
+  describe '#entropy_trend' do
+    it 'returns stable for insufficient data' do
+      expect(fp.entropy_trend).to eq(:stable)
+    end
+
+    it 'detects rising entropy' do
+      5.times { |i| fp.current_entropy(communication_cadence: 0.5 + (i * 0.1)) }
+      # Trend depends on actual computed values
+      trend = fp.entropy_trend(window: 5)
+      expect(%i[rising stable falling]).to include(trend)
+    end
+  end
+
+  describe '#maturity' do
+    it 'starts as nascent' do
+      expect(fp.maturity).to eq(:nascent)
+    end
+
+    it 'progresses to developing' do
+      15.times { fp.observe(:communication_cadence, 0.5) }
+      expect(fp.maturity).to eq(:developing)
+    end
+  end
+end