lex-agentic-integration 0.1.0

data/spec/legion/extensions/agentic/integration/zeitgeist/helpers/zeitgeist_engine_spec.rb

@@ -0,0 +1,163 @@
+# frozen_string_literal: true
+
+RSpec.describe Legion::Extensions::Agentic::Integration::Zeitgeist::Helpers::ZeitgeistEngine do
+  subject(:engine) { described_class.new }
+
+  def ingest(domain: :curiosity, subsystem: :emotion, intensity: 0.5, valence: 0.0)
+    engine.ingest(source_subsystem: subsystem, domain: domain, intensity: intensity, valence: valence)
+  end
+
+  describe '#ingest' do
+    it 'returns a CognitiveSignal' do
+      signal = ingest
+      expect(signal).to be_a(Legion::Extensions::Agentic::Integration::Zeitgeist::Helpers::CognitiveSignal)
+    end
+
+    it 'accumulates signals' do
+      3.times { ingest }
+      expect(engine.signals.size).to eq(3)
+    end
+
+    it 'caps signals at MAX_SIGNALS' do
+      stub_const('Legion::Extensions::Agentic::Integration::Zeitgeist::Helpers::Constants::MAX_SIGNALS', 3)
+      4.times { ingest }
+      expect(engine.signals.size).to eq(3)
+    end
+  end
+
+  describe '#dominant_themes' do
+    it 'returns empty array with no signals' do
+      expect(engine.dominant_themes).to eq([])
+    end
+
+    it 'returns themes sorted by weight descending' do
+      3.times { ingest(domain: :threat, intensity: 0.9) }
+      ingest(domain: :curiosity, intensity: 0.1)
+      themes = engine.dominant_themes
+      expect(themes.first[:domain]).to eq(:threat)
+    end
+
+    it 'respects limit parameter' do
+      %i[threat curiosity creativity social abstract].each { |d| ingest(domain: d) }
+      themes = engine.dominant_themes(limit: 3)
+      expect(themes.size).to eq(3)
+    end
+  end
+
+  describe '#collective_mood' do
+    it 'returns 0.0 with no signals' do
+      expect(engine.collective_mood).to eq(0.0)
+    end
+
+    it 'returns positive mood for positive valence signals' do
+      3.times { ingest(valence: 0.8, intensity: 1.0) }
+      expect(engine.collective_mood).to be > 0.0
+    end
+
+    it 'returns negative mood for negative valence signals' do
+      3.times { ingest(valence: -0.8, intensity: 1.0) }
+      expect(engine.collective_mood).to be < 0.0
+    end
+
+    it 'is weighted by intensity' do
+      ingest(valence: 1.0, intensity: 0.9)
+      ingest(valence: -1.0, intensity: 0.1)
+      expect(engine.collective_mood).to be > 0.0
+    end
+  end
+
+  describe '#cognitive_convergence' do
+    it 'returns 1.0 with no signals' do
+      expect(engine.cognitive_convergence).to eq(1.0)
+    end
+
+    it 'returns 1.0 with single subsystem' do
+      3.times { ingest(domain: :curiosity, subsystem: :emotion) }
+      expect(engine.cognitive_convergence).to eq(1.0)
+    end
+
+    it 'returns high convergence when subsystems agree on domain' do
+      3.times { ingest(domain: :threat, subsystem: :emotion, intensity: 0.9) }
+      3.times { ingest(domain: :threat, subsystem: :prediction, intensity: 0.9) }
+      3.times { ingest(domain: :threat, subsystem: :memory, intensity: 0.9) }
+      expect(engine.cognitive_convergence).to be > 0.5
+    end
+
+    it 'returns low convergence when subsystems disagree' do
+      3.times { ingest(domain: :threat, subsystem: :emotion, intensity: 0.9) }
+      3.times { ingest(domain: :creativity, subsystem: :prediction, intensity: 0.9) }
+      3.times { ingest(domain: :social, subsystem: :memory, intensity: 0.9) }
+      expect(engine.cognitive_convergence).to be < 0.7
+    end
+  end
+
+  describe '#rising_domains' do
+    it 'returns empty with insufficient signals' do
+      expect(engine.rising_domains).to eq([])
+    end
+
+    it 'identifies rising domains' do
+      constants = Legion::Extensions::Agentic::Integration::Zeitgeist::Helpers::Constants
+      (constants::WINDOW_SIZE / 2).times { ingest(domain: :curiosity, intensity: 0.1) }
+      (constants::WINDOW_SIZE / 2).times { ingest(domain: :curiosity, intensity: 0.9) }
+      rising = engine.rising_domains
+      domains = rising.map { |d| d[:domain] }
+      expect(domains).to include(:curiosity)
+    end
+  end
+
+  describe '#falling_domains' do
+    it 'returns empty with insufficient signals' do
+      expect(engine.falling_domains).to eq([])
+    end
+
+    it 'identifies falling domains' do
+      constants = Legion::Extensions::Agentic::Integration::Zeitgeist::Helpers::Constants
+      (constants::WINDOW_SIZE / 2).times { ingest(domain: :anxiety, intensity: 0.9) }
+      (constants::WINDOW_SIZE / 2).times { ingest(domain: :anxiety, intensity: 0.1) }
+      falling = engine.falling_domains
+      domains = falling.map { |d| d[:domain] }
+      expect(domains).to include(:anxiety)
+    end
+  end
+
+  describe '#divergence_alert?' do
+    it 'returns false when convergence is high' do
+      3.times { ingest(domain: :threat, subsystem: :emotion) }
+      3.times { ingest(domain: :threat, subsystem: :prediction) }
+      expect(engine.divergence_alert?).to be false
+    end
+  end
+
+  describe '#zeitgeist_report' do
+    before do
+      3.times { ingest(domain: :threat, subsystem: :emotion, intensity: 0.8, valence: -0.6) }
+      2.times { ingest(domain: :curiosity, subsystem: :prediction, intensity: 0.4, valence: 0.3) }
+    end
+
+    it 'returns a complete report hash' do
+      report = engine.zeitgeist_report
+      expect(report.keys).to include(
+        :signal_count, :dominant_themes, :collective_mood, :mood_label,
+        :convergence, :convergence_label, :momentum, :momentum_label,
+        :rising_domains, :falling_domains, :divergence_alert, :trend_window
+      )
+    end
+
+    it 'includes signal count' do
+      expect(engine.zeitgeist_report[:signal_count]).to eq(5)
+    end
+
+    it 'includes a mood label' do
+      expect(engine.zeitgeist_report[:mood_label]).to be_a(Symbol)
+    end
+
+    it 'includes a convergence label' do
+      expect(engine.zeitgeist_report[:convergence_label]).to be_a(Symbol)
+    end
+
+    it 'includes a momentum label' do
+      expect(engine.zeitgeist_report[:momentum_label]).to be_a(Symbol).or be_nil
+    end
+  end
+end

data/spec/legion/extensions/agentic/integration/zeitgeist/runners/cognitive_zeitgeist_spec.rb

@@ -0,0 +1,165 @@
+# frozen_string_literal: true
+
+RSpec.describe Legion::Extensions::Agentic::Integration::Zeitgeist::Runners::CognitiveZeitgeist do
+  let(:client) { Legion::Extensions::Agentic::Integration::Zeitgeist::Helpers::Client.new }
+  let(:engine) { Legion::Extensions::Agentic::Integration::Zeitgeist::Helpers::ZeitgeistEngine.new }
+
+  def ingest(domain: :curiosity, subsystem: :emotion, intensity: 0.5, valence: 0.0)
+    client.ingest_signal(source_subsystem: subsystem, domain: domain,
+                         intensity: intensity, valence: valence, engine: engine)
+  end
+
+  describe '#ingest_signal' do
+    it 'returns success true' do
+      result = client.ingest_signal(source_subsystem: :emotion, domain: :curiosity)
+      expect(result[:success]).to be true
+    end
+
+    it 'returns signal hash' do
+      result = client.ingest_signal(source_subsystem: :emotion, domain: :curiosity)
+      expect(result[:signal]).to be_a(Hash)
+      expect(result[:signal][:domain]).to eq(:curiosity)
+    end
+
+    it 'accepts injected engine' do
+      result = ingest(domain: :threat, intensity: 0.9)
+      expect(result[:success]).to be true
+      expect(engine.signals.size).to eq(1)
+    end
+
+    it 'uses default intensity when not provided' do
+      result = client.ingest_signal(source_subsystem: :emotion, domain: :social)
+      constants = Legion::Extensions::Agentic::Integration::Zeitgeist::Helpers::Constants
+      expect(result[:signal][:intensity]).to eq(constants::DEFAULT_INTENSITY)
+    end
+  end
+
+  describe '#zeitgeist_report' do
+    before do
+      3.times { ingest(domain: :threat, subsystem: :emotion, intensity: 0.8, valence: -0.5) }
+    end
+
+    it 'returns success true' do
+      result = client.zeitgeist_report(engine: engine)
+      expect(result[:success]).to be true
+    end
+
+    it 'includes signal_count' do
+      result = client.zeitgeist_report(engine: engine)
+      expect(result[:signal_count]).to eq(3)
+    end
+
+    it 'includes dominant_themes' do
+      result = client.zeitgeist_report(engine: engine)
+      expect(result[:dominant_themes]).to be_an(Array)
+    end
+
+    it 'includes mood_label' do
+      result = client.zeitgeist_report(engine: engine)
+      expect(result[:mood_label]).to be_a(Symbol)
+    end
+  end
+
+  describe '#collective_mood' do
+    it 'returns success true' do
+      result = client.collective_mood(engine: engine)
+      expect(result[:success]).to be true
+    end
+
+    it 'returns mood value' do
+      expect(client.collective_mood(engine: engine)[:mood]).to be_a(Float)
+    end
+
+    it 'returns mood_label' do
+      ingest(domain: :threat, valence: -0.9, intensity: 1.0)
+      result = client.collective_mood(engine: engine)
+      expect(result[:mood_label]).to be_a(Symbol)
+    end
+  end
+
+  describe '#cognitive_convergence' do
+    it 'returns success true' do
+      result = client.cognitive_convergence(engine: engine)
+      expect(result[:success]).to be true
+    end
+
+    it 'returns convergence value' do
+      expect(client.cognitive_convergence(engine: engine)[:convergence]).to be_a(Float)
+    end
+
+    it 'returns convergence_label' do
+      result = client.cognitive_convergence(engine: engine)
+      expect(result[:convergence_label]).to be_a(Symbol)
+    end
+
+    it 'returns divergence_alert boolean' do
+      result = client.cognitive_convergence(engine: engine)
+      expect(result[:divergence_alert]).to be(true).or be(false)
+    end
+  end
+
+  describe '#dominant_themes' do
+    it 'returns success true' do
+      result = client.dominant_themes(engine: engine)
+      expect(result[:success]).to be true
+    end
+
+    it 'returns themes array and count' do
+      ingest(domain: :curiosity)
+      result = client.dominant_themes(engine: engine)
+      expect(result[:themes]).to be_an(Array)
+      expect(result[:count]).to eq(result[:themes].size)
+    end
+
+    it 'respects limit' do
+      %i[threat curiosity creativity social abstract routine].each do |d|
+        ingest(domain: d)
+      end
+      result = client.dominant_themes(limit: 2, engine: engine)
+      expect(result[:count]).to eq(2)
+    end
+  end
+
+  describe '#rising_domains' do
+    it 'returns success true' do
+      result = client.rising_domains(engine: engine)
+      expect(result[:success]).to be true
+    end
+
+    it 'returns domains array with count' do
+      result = client.rising_domains(engine: engine)
+      expect(result[:domains]).to be_an(Array)
+      expect(result[:count]).to eq(result[:domains].size)
+    end
+  end
+
+  describe '#falling_domains' do
+    it 'returns success true' do
+      result = client.falling_domains(engine: engine)
+      expect(result[:success]).to be true
+    end
+
+    it 'returns domains array with count' do
+      result = client.falling_domains(engine: engine)
+      expect(result[:domains]).to be_an(Array)
+    end
+  end
+
+  describe '#trend_window_status' do
+    it 'returns success true' do
+      result = client.trend_window_status(engine: engine)
+      expect(result[:success]).to be true
+    end
+
+    it 'includes trend_window hash' do
+      result = client.trend_window_status(engine: engine)
+      expect(result[:trend_window]).to be_a(Hash)
+    end
+
+    it 'includes momentum_label' do
+      ingest
+      result = client.trend_window_status(engine: engine)
+      expect(result[:momentum_label]).to be_a(Symbol).or be_nil
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+require 'bundler/setup'
+
+module Legion
+  module Logging
+    def self.debug(_msg); end
+    def self.info(_msg); end
+    def self.warn(_msg); end
+    def self.error(_msg); end
+    def self.fatal(_msg); end
+  end
+
+  module Extensions
+    module Core
+      def self.extended(_base); end
+    end
+
+    module Helpers
+      module Lex
+        def self.included(_base); end
+      end
+    end
+  end
+end
+
+# rubocop:disable Lint/EmptyClass, Style/OneClassPerFile
+module Legion
+  module Extensions
+    module Actors
+      class Every; end
+      class Once; end
+    end
+  end
+end
+$LOADED_FEATURES << 'legion/extensions/actors/every'
+$LOADED_FEATURES << 'legion/extensions/actors/once'
+# rubocop:enable Lint/EmptyClass, Style/OneClassPerFile
+
+require 'legion/extensions/agentic/integration'
+
+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