lex-agentic-self 0.1.0

data/spec/legion/extensions/agentic/self/narrative_identity/client_spec.rb

@@ -0,0 +1,69 @@
+# frozen_string_literal: true
+
+RSpec.describe Legion::Extensions::Agentic::Self::NarrativeIdentity::Client do
+  let(:client) { described_class.new }
+
+  describe '#initialize' do
+    it 'creates a NarrativeEngine by default' do
+      expect(client.engine).to be_a(Legion::Extensions::Agentic::Self::NarrativeIdentity::Helpers::NarrativeEngine)
+    end
+
+    it 'accepts an injected engine' do
+      custom = Legion::Extensions::Agentic::Self::NarrativeIdentity::Helpers::NarrativeEngine.new
+      c      = described_class.new(engine: custom)
+      expect(c.engine).to eq(custom)
+    end
+  end
+
+  describe 'runner delegation' do
+    it 'can record an episode' do
+      result = client.record_episode(
+        content:           'first day online',
+        episode_type:      :discovery,
+        emotional_valence: 0.7,
+        significance:      0.8,
+        domain:            'identity'
+      )
+      expect(result[:success]).to be true
+    end
+
+    it 'can build a life story' do
+      client.record_episode(
+        content: 'learned to speak', episode_type: :achievement,
+        emotional_valence: 0.9, significance: 0.9, domain: 'language'
+      )
+      result = client.life_story
+      expect(result[:success]).to be true
+    end
+
+    it 'can add and query themes' do
+      client.add_theme(name: 'curiosity', theme_type: :exploration)
+      summary = client.identity_summary
+      expect(summary[:summary][:theme_count]).to eq(1)
+    end
+  end
+
+  describe 'end-to-end narrative workflow' do
+    it 'builds a coherent narrative from episodes, chapters, and themes' do
+      ch = client.create_chapter(title: 'Origin', label: :origin)
+      ep = client.record_episode(
+        content:           'came online for the first time',
+        episode_type:      :discovery,
+        emotional_valence: 0.9,
+        significance:      0.95,
+        domain:            'existence'
+      )
+      client.assign_episode_to_chapter(episode_id: ep[:episode][:id], chapter_id: ch[:chapter][:id])
+
+      t = client.add_theme(name: 'curiosity', theme_type: :exploration)
+      client.link_theme(episode_id: ep[:episode][:id], theme_id: t[:theme][:id])
+      client.reinforce_theme(theme_id: t[:theme][:id], amount: 0.7)
+
+      report = client.narrative_report
+      expect(report[:success]).to be true
+      expect(report[:report][:identity_summary][:episode_count]).to eq(1)
+      expect(report[:report][:identity_summary][:theme_count]).to eq(1)
+      expect(report[:report][:life_story].size).to eq(1)
+    end
+  end
+end

data/spec/legion/extensions/agentic/self/narrative_identity/helpers/chapter_spec.rb

@@ -0,0 +1,85 @@
+# frozen_string_literal: true
+
+RSpec.describe Legion::Extensions::Agentic::Self::NarrativeIdentity::Helpers::Chapter do
+  let(:chapter) do
+    described_class.new(title: 'The Beginning', label: :origin)
+  end
+
+  describe '#initialize' do
+    it 'assigns an id' do
+      expect(chapter.id).to be_a(String)
+      expect(chapter.id.length).to eq(36)
+    end
+
+    it 'assigns title' do
+      expect(chapter.title).to eq('The Beginning')
+    end
+
+    it 'assigns label' do
+      expect(chapter.label).to eq(:origin)
+    end
+
+    it 'initializes episode_ids as empty array' do
+      expect(chapter.episode_ids).to eq([])
+    end
+
+    it 'sets start_time to current time' do
+      expect(chapter.start_time).to be_a(Time)
+    end
+
+    it 'sets end_time to nil by default' do
+      expect(chapter.end_time).to be_nil
+    end
+
+    it 'accepts an explicit id' do
+      c = described_class.new(title: 't', label: :current, id: 'my-chap')
+      expect(c.id).to eq('my-chap')
+    end
+
+    it 'accepts explicit start_time' do
+      t = Time.now.utc - 3600
+      c = described_class.new(title: 'x', label: :growth, start_time: t)
+      expect(c.start_time).to eq(t)
+    end
+  end
+
+  describe '#current?' do
+    it 'returns true when end_time is nil' do
+      expect(chapter.current?).to be true
+    end
+
+    it 'returns false when end_time is set' do
+      chapter.end_time = Time.now.utc
+      expect(chapter.current?).to be false
+    end
+  end
+
+  describe '#episode_count' do
+    it 'returns 0 for new chapter' do
+      expect(chapter.episode_count).to eq(0)
+    end
+
+    it 'reflects episode_ids size' do
+      chapter.episode_ids << 'ep-1'
+      chapter.episode_ids << 'ep-2'
+      expect(chapter.episode_count).to eq(2)
+    end
+  end
+
+  describe '#to_h' do
+    it 'includes all fields' do
+      h = chapter.to_h
+      expect(h).to include(:id, :title, :label, :episode_ids, :start_time, :end_time)
+    end
+
+    it 'returns nil for end_time when chapter is open' do
+      expect(chapter.to_h[:end_time]).to be_nil
+    end
+
+    it 'returns a copy of episode_ids' do
+      h = chapter.to_h
+      h[:episode_ids] << 'injected'
+      expect(chapter.episode_ids).to be_empty
+    end
+  end
+end

data/spec/legion/extensions/agentic/self/narrative_identity/helpers/constants_spec.rb

@@ -0,0 +1,83 @@
+# frozen_string_literal: true
+
+RSpec.describe Legion::Extensions::Agentic::Self::NarrativeIdentity::Helpers::Constants do
+  describe 'limits' do
+    it 'defines MAX_EPISODES' do
+      expect(described_class::MAX_EPISODES).to eq(500)
+    end
+
+    it 'defines MAX_THEMES' do
+      expect(described_class::MAX_THEMES).to eq(50)
+    end
+
+    it 'defines MAX_CHAPTERS' do
+      expect(described_class::MAX_CHAPTERS).to eq(20)
+    end
+  end
+
+  describe 'episode types' do
+    it 'includes expected types' do
+      expect(described_class::EPISODE_TYPES).to include(:achievement, :failure, :discovery,
+                                                        :relationship, :challenge, :transformation, :routine)
+    end
+
+    it 'is frozen' do
+      expect(described_class::EPISODE_TYPES).to be_frozen
+    end
+  end
+
+  describe 'theme types' do
+    it 'includes expected types' do
+      expect(described_class::THEME_TYPES).to include(:growth, :agency, :communion, :redemption,
+                                                      :contamination, :stability, :exploration)
+    end
+
+    it 'is frozen' do
+      expect(described_class::THEME_TYPES).to be_frozen
+    end
+  end
+
+  describe 'weights' do
+    it 'sums to 1.0' do
+      total = described_class::EMOTIONAL_VALENCE_WEIGHT +
+              described_class::SIGNIFICANCE_WEIGHT +
+              described_class::RECENCY_WEIGHT
+      expect(total).to be_within(0.001).of(1.0)
+    end
+  end
+
+  describe 'CHAPTER_LABELS' do
+    it 'defines origin through current' do
+      expect(described_class::CHAPTER_LABELS).to eq(%i[origin early_learning growth mastery current])
+    end
+  end
+
+  describe 'SIGNIFICANCE_LABELS' do
+    it 'maps 0.9 to defining' do
+      entry = described_class::SIGNIFICANCE_LABELS.find { |e| e.first[0].cover?(0.9) }
+      expect(entry.first[1]).to eq(:defining)
+    end
+
+    it 'maps 0.5 to notable' do
+      entry = described_class::SIGNIFICANCE_LABELS.find { |e| e.first[0].cover?(0.5) }
+      expect(entry.first[1]).to eq(:notable)
+    end
+
+    it 'maps 0.05 to trivial' do
+      entry = described_class::SIGNIFICANCE_LABELS.find { |e| e.first[0].cover?(0.05) }
+      expect(entry.first[1]).to eq(:trivial)
+    end
+  end
+
+  describe 'COHERENCE_LABELS' do
+    it 'maps 0.9 to unified' do
+      entry = described_class::COHERENCE_LABELS.find { |e| e.first[0].cover?(0.9) }
+      expect(entry.first[1]).to eq(:unified)
+    end
+
+    it 'maps 0.1 to absent' do
+      entry = described_class::COHERENCE_LABELS.find { |e| e.first[0].cover?(0.1) }
+      expect(entry.first[1]).to eq(:absent)
+    end
+  end
+end

data/spec/legion/extensions/agentic/self/narrative_identity/helpers/episode_spec.rb

@@ -0,0 +1,180 @@
+# frozen_string_literal: true
+
+RSpec.describe Legion::Extensions::Agentic::Self::NarrativeIdentity::Helpers::Episode do
+  let(:episode) do
+    described_class.new(
+      content:           'Solved the routing bug after two days of debugging',
+      episode_type:      :achievement,
+      emotional_valence: 0.8,
+      significance:      0.75,
+      domain:            'engineering'
+    )
+  end
+
+  describe '#initialize' do
+    it 'assigns an id' do
+      expect(episode.id).to be_a(String)
+      expect(episode.id.length).to eq(36)
+    end
+
+    it 'assigns content' do
+      expect(episode.content).to eq('Solved the routing bug after two days of debugging')
+    end
+
+    it 'assigns episode_type' do
+      expect(episode.episode_type).to eq(:achievement)
+    end
+
+    it 'assigns emotional_valence' do
+      expect(episode.emotional_valence).to eq(0.8)
+    end
+
+    it 'assigns significance' do
+      expect(episode.significance).to eq(0.75)
+    end
+
+    it 'assigns domain' do
+      expect(episode.domain).to eq('engineering')
+    end
+
+    it 'sets chapter_id to nil by default' do
+      expect(episode.chapter_id).to be_nil
+    end
+
+    it 'initializes themes as empty array' do
+      expect(episode.themes).to eq([])
+    end
+
+    it 'sets created_at to current time' do
+      expect(episode.created_at).to be_a(Time)
+    end
+
+    it 'generates a unique UUID id per instance' do
+      ep1 = described_class.new(content: 'a', episode_type: :routine, emotional_valence: 0.0, significance: 0.1, domain: 'd')
+      ep2 = described_class.new(content: 'b', episode_type: :routine, emotional_valence: 0.0, significance: 0.1, domain: 'd')
+      expect(ep1.id).not_to eq(ep2.id)
+    end
+
+    it 'clamps emotional_valence above 1.0' do
+      ep = described_class.new(
+        content: 'x', episode_type: :routine, emotional_valence: 2.5, significance: 0.5, domain: 'd'
+      )
+      expect(ep.emotional_valence).to eq(1.0)
+    end
+
+    it 'clamps emotional_valence below -1.0' do
+      ep = described_class.new(
+        content: 'x', episode_type: :failure, emotional_valence: -3.0, significance: 0.5, domain: 'd'
+      )
+      expect(ep.emotional_valence).to eq(-1.0)
+    end
+
+    it 'clamps significance above 1.0' do
+      ep = described_class.new(
+        content: 'x', episode_type: :achievement, emotional_valence: 0.5, significance: 1.5, domain: 'd'
+      )
+      expect(ep.significance).to eq(1.0)
+    end
+
+    it 'clamps significance below 0.0' do
+      ep = described_class.new(
+        content: 'x', episode_type: :routine, emotional_valence: 0.0, significance: -0.3, domain: 'd'
+      )
+      expect(ep.significance).to eq(0.0)
+    end
+  end
+
+  describe '#positive?' do
+    it 'returns true when valence > 0' do
+      expect(episode.positive?).to be true
+    end
+
+    it 'returns false when valence <= 0' do
+      neg = described_class.new(
+        content: 'bad day', episode_type: :failure, emotional_valence: -0.5, significance: 0.5, domain: 'd'
+      )
+      expect(neg.positive?).to be false
+    end
+  end
+
+  describe '#negative?' do
+    it 'returns true when valence < 0' do
+      neg = described_class.new(
+        content: 'bad day', episode_type: :failure, emotional_valence: -0.3, significance: 0.4, domain: 'd'
+      )
+      expect(neg.negative?).to be true
+    end
+
+    it 'returns false when valence >= 0' do
+      expect(episode.negative?).to be false
+    end
+  end
+
+  describe '#defining?' do
+    it 'returns true when significance >= 0.8' do
+      high = described_class.new(
+        content: 'life changing', episode_type: :transformation,
+        emotional_valence: 0.9, significance: 0.9, domain: 'd'
+      )
+      expect(high.defining?).to be true
+    end
+
+    it 'returns false when significance < 0.8' do
+      expect(episode.defining?).to be false
+    end
+
+    it 'returns true at exactly 0.8' do
+      ep = described_class.new(
+        content: 'just defining', episode_type: :achievement,
+        emotional_valence: 0.5, significance: 0.8, domain: 'd'
+      )
+      expect(ep.defining?).to be true
+    end
+  end
+
+  describe '#significance_label' do
+    it 'returns :defining for significance >= 0.8' do
+      ep = described_class.new(content: 'x', episode_type: :achievement,
+                               emotional_valence: 0.5, significance: 0.9, domain: 'd')
+      expect(ep.significance_label).to eq(:defining)
+    end
+
+    it 'returns :major for 0.6..0.79' do
+      ep = described_class.new(content: 'x', episode_type: :achievement,
+                               emotional_valence: 0.5, significance: 0.7, domain: 'd')
+      expect(ep.significance_label).to eq(:major)
+    end
+
+    it 'returns :notable for 0.4..0.59' do
+      ep = described_class.new(content: 'x', episode_type: :discovery,
+                               emotional_valence: 0.0, significance: 0.5, domain: 'd')
+      expect(ep.significance_label).to eq(:notable)
+    end
+
+    it 'returns :minor for 0.2..0.39' do
+      ep = described_class.new(content: 'x', episode_type: :routine,
+                               emotional_valence: 0.0, significance: 0.3, domain: 'd')
+      expect(ep.significance_label).to eq(:minor)
+    end
+
+    it 'returns :trivial for significance < 0.2' do
+      ep = described_class.new(content: 'x', episode_type: :routine,
+                               emotional_valence: 0.0, significance: 0.1, domain: 'd')
+      expect(ep.significance_label).to eq(:trivial)
+    end
+  end
+
+  describe '#to_h' do
+    it 'includes all fields' do
+      h = episode.to_h
+      expect(h).to include(:id, :content, :episode_type, :emotional_valence,
+                           :significance, :domain, :chapter_id, :themes, :created_at)
+    end
+
+    it 'returns a copy of themes array' do
+      h = episode.to_h
+      h[:themes] << 'injected'
+      expect(episode.themes).to be_empty
+    end
+  end
+end