lex-identity 0.3.0 → 0.4.0

data/spec/legion/extensions/identity/runners/identity_spec.rb

@@ -0,0 +1,61 @@
+# frozen_string_literal: true
+
+require 'legion/extensions/identity/client'
+
+RSpec.describe Legion::Extensions::Identity::Runners::Identity do
+  let(:client) { Legion::Extensions::Identity::Client.new }
+
+  describe '#observe_behavior' do
+    it 'records a single observation' do
+      result = client.observe_behavior(dimension: :communication_cadence, value: 0.7)
+      expect(result[:recorded]).to be true
+      expect(result[:observation_count]).to eq(1)
+    end
+  end
+
+  describe '#observe_all' do
+    it 'records multiple observations' do
+      result = client.observe_all(observations: {
+                                    communication_cadence: 0.6,
+                                    vocabulary_patterns:   0.7,
+                                    emotional_response:    0.5
+                                  })
+      expect(result[:dimensions_observed].size).to eq(3)
+      expect(result[:observation_count]).to eq(3)
+    end
+  end
+
+  describe '#check_entropy' do
+    it 'returns entropy classification' do
+      result = client.check_entropy
+      expect(result[:entropy]).to be_between(0.0, 1.0)
+      expect(result).to have_key(:classification)
+      expect(result).to have_key(:trend)
+      expect(result).to have_key(:in_range)
+    end
+
+    it 'warns on high entropy observations' do
+      # Build baseline
+      20.times { client.observe_behavior(dimension: :communication_cadence, value: 0.5) }
+      # Check with very different observation
+      result = client.check_entropy(observations: { communication_cadence: 10.0 })
+      expect(result[:warning]).to eq(:possible_impersonation_or_drift) if result[:classification] == :high_entropy
+    end
+  end
+
+  describe '#identity_status' do
+    it 'returns model state' do
+      status = client.identity_status
+      expect(status).to have_key(:model)
+      expect(status).to have_key(:maturity)
+      expect(status).to have_key(:observation_count)
+    end
+  end
+
+  describe '#identity_maturity' do
+    it 'returns maturity level' do
+      result = client.identity_maturity
+      expect(result[:maturity]).to eq(:nascent)
+    end
+  end
+end

data/spec/local_persistence_spec.rb

@@ -0,0 +1,329 @@
+# frozen_string_literal: true
+
+# Local persistence spec for Legion::Extensions::Identity::Helpers::Fingerprint
+#
+# Strategy: stub Legion::Data::Local with a real in-memory Sequel SQLite database
+# when sequel + sqlite3 are available, otherwise use a double that records calls.
+# Either way, the Fingerprint save/load logic is exercised end-to-end.
+
+begin
+  require 'sequel'
+  require 'sqlite3'
+  SEQUEL_AVAILABLE = true
+rescue LoadError
+  SEQUEL_AVAILABLE = false
+end
+
+RSpec.describe Legion::Extensions::Identity::Helpers::Fingerprint, 'local persistence' do
+  # ---------------------------------------------------------------------------
+  # Helpers for setting up the in-memory DB (shared between contexts)
+  # ---------------------------------------------------------------------------
+
+  def build_in_memory_db
+    db = Sequel.sqlite
+    db.create_table(:identity_fingerprint) do
+      primary_key :id
+      String  :dimension,     null: false, unique: true
+      Float   :mean,          default: 0.0
+      Float   :variance,      default: 0.0
+      Integer :observations,  default: 0
+      DateTime :last_observed
+    end
+    db.create_table(:identity_meta) do
+      primary_key :id
+      Integer :observation_count, default: 0
+      String  :entropy_history,   text: true
+    end
+    db
+  end
+
+  def stub_local(db)
+    local_mod = Module.new do
+      define_singleton_method(:connection)  { db }
+      define_singleton_method(:connected?)  { true }
+    end
+    stub_const('Legion::Data', Module.new)
+    stub_const('Legion::Data::Local', local_mod)
+  end
+
+  # ---------------------------------------------------------------------------
+  # When Sequel + sqlite3 are available: full round-trip integration tests
+  # ---------------------------------------------------------------------------
+
+  if SEQUEL_AVAILABLE
+    context 'with an in-memory SQLite database' do
+      let(:db) { build_in_memory_db }
+
+      before { stub_local(db) }
+
+      describe '#save_to_local' do
+        it 'returns true on first save' do
+          fp = described_class.new
+          expect(fp.save_to_local).to be true
+        end
+
+        it 'persists all 6 dimension rows to identity_fingerprint' do
+          fp = described_class.new
+          fp.observe(:communication_cadence, 0.8)
+          fp.save_to_local
+
+          rows = db[:identity_fingerprint].all
+          expect(rows.size).to eq(6)
+        end
+
+        it 'persists updated mean for observed dimension' do
+          fp = described_class.new
+          10.times { fp.observe(:vocabulary_patterns, 0.9) }
+          fp.save_to_local
+
+          row = db[:identity_fingerprint].where(dimension: 'vocabulary_patterns').first
+          expect(row[:mean]).to be > 0.5
+          expect(row[:observations]).to eq(10)
+        end
+
+        it 'persists observation_count in identity_meta' do
+          fp = described_class.new
+          3.times { fp.observe(:communication_cadence, 0.6) }
+          fp.save_to_local
+
+          meta = db[:identity_meta].first
+          expect(meta[:observation_count]).to eq(3)
+        end
+
+        it 'persists entropy_history as JSON in identity_meta' do
+          fp = described_class.new
+          fp.current_entropy(communication_cadence: 0.5)
+          fp.current_entropy(vocabulary_patterns: 0.6)
+          fp.save_to_local
+
+          meta = db[:identity_meta].first
+          parsed = JSON.parse(meta[:entropy_history])
+          expect(parsed.size).to eq(2)
+          expect(parsed.first).to have_key('entropy')
+          expect(parsed.first).to have_key('at')
+        end
+
+        it 'updates existing rows on second save (upsert)' do
+          fp = described_class.new
+          fp.observe(:emotional_response, 0.3)
+          fp.save_to_local
+
+          # mutate and save again
+          5.times { fp.observe(:emotional_response, 0.9) }
+          fp.save_to_local
+
+          rows = db[:identity_fingerprint].where(dimension: 'emotional_response').all
+          expect(rows.size).to eq(1) # still one row, not two
+          expect(rows.first[:observations]).to eq(6)
+        end
+      end
+
+      describe '#load_from_local' do
+        it 'returns true when called with an empty DB' do
+          fp = described_class.new # load_from_local called in initialize
+          expect(fp.observation_count).to eq(0)
+        end
+
+        it 'restores model dimensions from DB rows' do
+          # Pre-seed DB directly
+          db[:identity_fingerprint].insert(
+            dimension: 'communication_cadence',
+            mean: 0.75, variance: 0.05, observations: 42,
+            last_observed: Time.now.utc
+          )
+
+          fp = described_class.new # triggers load_from_local
+          expect(fp.model[:communication_cadence][:mean]).to be_within(0.001).of(0.75)
+          expect(fp.model[:communication_cadence][:observations]).to eq(42)
+        end
+
+        it 'restores observation_count from identity_meta' do
+          db[:identity_meta].insert(observation_count: 57, entropy_history: '[]')
+
+          fp = described_class.new
+          expect(fp.observation_count).to eq(57)
+        end
+
+        it 'restores entropy_history from identity_meta JSON' do
+          history = [
+            { 'entropy' => 0.3, 'at' => Time.now.utc.iso8601 },
+            { 'entropy' => 0.4, 'at' => Time.now.utc.iso8601 }
+          ]
+          db[:identity_meta].insert(observation_count: 0, entropy_history: JSON.generate(history))
+
+          fp = described_class.new
+          expect(fp.entropy_history.size).to eq(2)
+          expect(fp.entropy_history.first[:entropy]).to be_within(0.001).of(0.3)
+          expect(fp.entropy_history.first[:at]).to be_a(Time)
+        end
+
+        it 'ignores DB rows for unknown dimensions' do
+          db[:identity_fingerprint].insert(
+            dimension: 'nonexistent_dimension',
+            mean: 0.9, variance: 0.1, observations: 5,
+            last_observed: nil
+          )
+
+          fp = described_class.new # must not raise
+          expect(fp.model.keys).to match_array(
+            %i[communication_cadence vocabulary_patterns emotional_response
+               decision_patterns contextual_consistency temporal_patterns]
+          )
+        end
+      end
+
+      describe 'full round-trip' do
+        it 'survives a save-then-load cycle with identical state' do
+          # Build state in first fingerprint instance
+          fp1 = described_class.new
+          12.times { fp1.observe(:communication_cadence, 0.7) }
+          8.times  { fp1.observe(:vocabulary_patterns,   0.6) }
+          fp1.current_entropy(communication_cadence: 0.65)
+          fp1.current_entropy(vocabulary_patterns: 0.55)
+          fp1.save_to_local
+
+          # Load into a fresh instance (DB already populated)
+          fp2 = described_class.new
+
+          expect(fp2.observation_count).to eq(fp1.observation_count)
+          expect(fp2.entropy_history.size).to eq(fp1.entropy_history.size)
+
+          dims = %i[communication_cadence vocabulary_patterns]
+          dims.each do |dim|
+            expect(fp2.model[dim][:mean]).to be_within(0.0001).of(fp1.model[dim][:mean])
+            expect(fp2.model[dim][:variance]).to be_within(0.0001).of(fp1.model[dim][:variance])
+            expect(fp2.model[dim][:observations]).to eq(fp1.model[dim][:observations])
+          end
+        end
+
+        it 'preserves maturity after round-trip' do
+          fp1 = described_class.new
+          15.times { fp1.observe(:decision_patterns, 0.5) }
+          expect(fp1.maturity).to eq(:developing)
+          fp1.save_to_local
+
+          fp2 = described_class.new
+          expect(fp2.maturity).to eq(:developing)
+        end
+
+        it 'preserves entropy trend direction after round-trip' do
+          fp1 = described_class.new
+          # Ascending entropy values — second half larger than first half
+          [0.1, 0.1, 0.1, 0.1, 0.7, 0.8, 0.9, 0.95, 0.98, 1.0].each do |e|
+            fp1.instance_variable_get(:@entropy_history) << { entropy: e, at: Time.now.utc }
+          end
+          fp1.save_to_local
+
+          fp2 = described_class.new
+          expect(fp2.entropy_history.map { |h| h[:entropy] }).to eq(
+            fp1.entropy_history.map { |h| h[:entropy] }
+          )
+        end
+      end
+    end
+
+  else
+    # ---------------------------------------------------------------------------
+    # Fallback: double-based tests when Sequel is not in the bundle
+    # ---------------------------------------------------------------------------
+
+    context 'when Sequel is not available (double-based fallback)' do
+      let(:fingerprint_rows) { {} }
+      let(:meta_rows)        { [] }
+
+      let(:fp_dataset) do
+        d = double('fingerprint_dataset')
+        allow(d).to receive(:where) { |args|
+          scoped = double('scoped_fp_dataset')
+          allow(scoped).to receive(:first) { fingerprint_rows[args[:dimension]] }
+          allow(scoped).to receive(:update) { |row|
+            fingerprint_rows[row[:dimension] || args[:dimension]] = row
+          }
+          scoped
+        }
+        allow(d).to receive(:insert) { |row| fingerprint_rows[row[:dimension]] = row }
+        allow(d).to receive(:each)   { |&block| fingerprint_rows.each_value(&block) }
+        allow(d).to receive(:first)  { fingerprint_rows.values.first }
+        d
+      end
+
+      let(:meta_dataset) do
+        d = double('meta_dataset')
+        allow(d).to receive(:first)  { meta_rows.first }
+        allow(d).to receive(:insert) { |row| meta_rows << row }
+        allow(d).to receive(:where) do
+          scoped = double('scoped_meta_dataset')
+          allow(scoped).to receive(:update) { |row| meta_rows[0] = meta_rows[0]&.merge(row) }
+          scoped
+        end
+        d
+      end
+
+      let(:db) do
+        d = double('Sequel::Database')
+        allow(d).to receive(:[]).with(:identity_fingerprint).and_return(fp_dataset)
+        allow(d).to receive(:[]).with(:identity_meta).and_return(meta_dataset)
+        d
+      end
+
+      before do
+        local_mod = Module.new do
+          define_singleton_method(:connection)  { nil } # overridden per example
+          define_singleton_method(:connected?)  { true }
+        end
+        stub_const('Legion::Data', Module.new)
+        stub_const('Legion::Data::Local', local_mod)
+        allow(Legion::Data::Local).to receive(:connection).and_return(db)
+      end
+
+      it 'calls insert on the fingerprint dataset during save_to_local' do
+        fp = described_class.new
+        expect(fp_dataset).to receive(:insert).at_least(:once)
+        fp.save_to_local
+      end
+
+      it 'calls insert on the meta dataset during save_to_local' do
+        fp = described_class.new
+        expect(meta_dataset).to receive(:insert).once
+        fp.save_to_local
+      end
+
+      it 'does not raise when local is unavailable (Legion::Data::Local not defined)' do
+        # Remove the stub so defined? check returns false
+        hide_const('Legion::Data::Local')
+        expect { described_class.new }.not_to raise_error
+      end
+    end
+  end
+
+  # ---------------------------------------------------------------------------
+  # Behaviour when Legion::Data::Local is not defined (always run)
+  # ---------------------------------------------------------------------------
+
+  describe 'when Legion::Data::Local is not available' do
+    before do
+      hide_const('Legion::Data::Local') if defined?(Legion::Data::Local)
+    end
+
+    it 'initialize completes without error' do
+      expect { described_class.new }.not_to raise_error
+    end
+
+    it 'save_to_local returns nil (guard short-circuits)' do
+      fp = described_class.new
+      expect(fp.save_to_local).to be_nil
+    end
+
+    it 'load_from_local returns nil (guard short-circuits)' do
+      fp = described_class.new
+      expect(fp.load_from_local).to be_nil
+    end
+
+    it 'model starts with fresh defaults' do
+      fp = described_class.new
+      expect(fp.model[:communication_cadence][:mean]).to eq(0.5)
+      expect(fp.observation_count).to eq(0)
+      expect(fp.entropy_history).to be_empty
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+require 'bundler/setup'
+
+# Stub framework classes not available outside the full Legion runtime
+module Legion
+  module Logging
+    def self.debug(_msg); end
+
+    def self.info(_msg); end
+
+    def self.warn(_msg); end
+
+    def self.error(_msg); end
+  end
+
+  module Extensions
+    module Actors
+      class Every; end # rubocop:disable Lint/EmptyClass
+    end
+  end
+end
+
+# Prevent re-require of actor base when identity.rb loads orphan_check
+$LOADED_FEATURES << 'legion/extensions/actors/every'
+
+require 'legion/extensions/identity'
+
+RSpec.configure do |config|
+  config.example_status_persistence_file_path = '.rspec_status'
+  config.disable_monkey_patching!
+  config.expect_with(:rspec) { |c| c.syntax = :expect }
+end

metadata

@@ -1,112 +1,85 @@
 --- !ruby/object:Gem::Specification
 name: lex-identity
 version: !ruby/object:Gem::Version
-  version: 0.3.0
+  version: 0.4.0
 platform: ruby
 authors:
-- LegionIO
+- Esity
 bindir: bin
 cert_chain: []
 date: 1980-01-02 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
-  name: faraday
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '2.0'
-  type: :runtime
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '2.0'
-- !ruby/object:Gem::Dependency
-  name: legion-cache
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: 1.3.0
-  type: :runtime
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: 1.3.0
-- !ruby/object:Gem::Dependency
-  name: legion-json
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: 1.2.1
-  type: :runtime
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: 1.2.1
-- !ruby/object:Gem::Dependency
-  name: legion-logging
+  name: sequel
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 1.5.3
-  type: :runtime
+        version: '5.70'
+  type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 1.5.3
+        version: '5.70'
 - !ruby/object:Gem::Dependency
-  name: legion-settings
+  name: sqlite3
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 1.3.14
-  type: :runtime
+        version: '2.0'
+  type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 1.3.14
-description: Base extension gem for shared behavior across LegionIO identity provider
-  extensions.
+        version: '2.0'
+description: Human partner identity modeling and behavioral entropy for brain-modeled
+  agentic AI
+email:
+- matthewdiverson@gmail.com
 executables: []
 extensions: []
 extra_rdoc_files: []
 files:
-- CHANGELOG.md
 - Gemfile
-- LICENSE
-- README.md
 - lex-identity.gemspec
 - lib/legion/extensions/identity.rb
-- lib/legion/extensions/identity/helpers/browser.rb
-- lib/legion/extensions/identity/helpers/callback_server.rb
-- lib/legion/extensions/identity/helpers/oauth.rb
-- lib/legion/extensions/identity/helpers/pkce.rb
-- lib/legion/extensions/identity/helpers/provider.rb
-- lib/legion/extensions/identity/runners/base/oauth.rb
+- lib/legion/extensions/identity/actors/credential_refresh.rb
+- lib/legion/extensions/identity/actors/orphan_check.rb
+- lib/legion/extensions/identity/client.rb
+- lib/legion/extensions/identity/helpers/dimensions.rb
+- lib/legion/extensions/identity/helpers/fingerprint.rb
+- lib/legion/extensions/identity/helpers/graph_client.rb
+- lib/legion/extensions/identity/helpers/graph_token.rb
+- lib/legion/extensions/identity/helpers/token_cache.rb
+- lib/legion/extensions/identity/helpers/vault_secrets.rb
+- lib/legion/extensions/identity/local_migrations/20260316000030_create_fingerprint.rb
+- lib/legion/extensions/identity/runners/entra.rb
+- lib/legion/extensions/identity/runners/identity.rb
 - lib/legion/extensions/identity/version.rb
-- spec/support/provider_contract.rb
+- spec/legion/extensions/identity/actors/orphan_check_spec.rb
+- spec/legion/extensions/identity/client_spec.rb
+- spec/legion/extensions/identity/helpers/dimensions_spec.rb
+- spec/legion/extensions/identity/helpers/fingerprint_spec.rb
+- spec/legion/extensions/identity/helpers/graph_client_spec.rb
+- spec/legion/extensions/identity/helpers/graph_token_spec.rb
+- spec/legion/extensions/identity/helpers/token_cache_spec.rb
+- spec/legion/extensions/identity/runners/entra_spec.rb
+- spec/legion/extensions/identity/runners/identity_spec.rb
+- spec/local_persistence_spec.rb
+- spec/spec_helper.rb
 homepage: https://github.com/LegionIO/lex-identity
 licenses:
 - MIT
 metadata:
   homepage_uri: https://github.com/LegionIO/lex-identity
   source_code_uri: https://github.com/LegionIO/lex-identity
-  documentation_uri: https://github.com/LegionIO/lex-identity/blob/main/README.md
-  changelog_uri: https://github.com/LegionIO/lex-identity/blob/main/CHANGELOG.md
+  documentation_uri: https://github.com/LegionIO/lex-identity
+  changelog_uri: https://github.com/LegionIO/lex-identity
   bug_tracker_uri: https://github.com/LegionIO/lex-identity/issues
   rubygems_mfa_required: 'true'
 rdoc_options: []
@@ -125,5 +98,5 @@ required_rubygems_version: !ruby/object:Gem::Requirement
 requirements: []
 rubygems_version: 3.6.9
 specification_version: 4
-summary: Shared LegionIO identity extension base
+summary: LEX Identity
 test_files: []

data/CHANGELOG.md

@@ -1,27 +0,0 @@
-# Changelog
-
-## [0.3.0] - 2026-11-09
-
-### Added
-- Explicit provider-neutral browser login combining PKCE, authorization, a state-correlated loopback callback, and token exchange.
-- A single-use callback listener with bounded reads/writes, request limits, optional fixed-port binding, and cleanup on every exit.
-- Callback security and lifecycle specs for invalid state, ambiguous parameters, provider denial, stalled clients, timeout, and listener disposal.
-
-### Changed
-- Moved reusable OAuth runners to `runners/base/oauth.rb` so generic endpoint and browser operations are not automatically exposed through extension API routes. Consumers must explicitly require the new path.
-
-## [0.2.0] - 2026-11-07
-
-### Added
-- Provider integration helpers for resolver registration, lease construction, and broker credential access using one provider name.
-- Optional PKCE generation and browser helpers.
-- Provider-neutral OAuth authorization, code exchange, refresh, and deadline-bounded device-code polling.
-- Reusable provider conformance examples covering the core resolver's metadata and resolution contracts.
-- Shared OAuth runner compatible with standard extension discovery; the base extension is not itself an identity provider or remotely invocable.
-
-## [0.1.0] - 2026-11-07
-
-### Added
-- Initial gem packaging, namespace, and version.
-- Standard actors, runners, helpers, and spec directories.
-- Shared CI/release workflow, dependency updates, and RuboCop/RSpec configuration.

data/LICENSE

@@ -1,21 +0,0 @@
-MIT License
-
-Copyright (c) 2026 LegionIO
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-SOFTWARE.