lex-agentic-self 0.1.0

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

@@ -0,0 +1,67 @@
+# frozen_string_literal: true
+
+RSpec.describe Legion::Extensions::Agentic::Self::NarrativeSelf::Client do
+  let(:client) { described_class.new }
+
+  it 'can be instantiated' do
+    expect(client).to be_a(described_class)
+  end
+
+  it 'includes all runner methods' do
+    expect(client).to respond_to(:record_episode)
+    expect(client).to respond_to(:recent_episodes)
+    expect(client).to respond_to(:significant_episodes)
+    expect(client).to respond_to(:create_thread)
+    expect(client).to respond_to(:self_summary)
+    expect(client).to respond_to(:update_narrative_self)
+    expect(client).to respond_to(:narrative_self_stats)
+  end
+
+  it 'exposes the autobiography' do
+    expect(client.autobiography).to be_a(Legion::Extensions::Agentic::Self::NarrativeSelf::Helpers::Autobiography)
+  end
+
+  describe 'full lifecycle' do
+    it 'builds a narrative from episodes and threads' do
+      # Create narrative threads
+      client.create_thread(theme: :learning, domain: :cognition)
+      client.create_thread(theme: :mastery, domain: :technical)
+
+      # Record experiences
+      client.record_episode(
+        description:       'built first extension',
+        episode_type:      :achievement,
+        domain:            :technical,
+        emotional_valence: 0.7,
+        tags:              %i[building mastery]
+      )
+      client.record_episode(
+        description:  'learned about EMA',
+        episode_type: :insight,
+        domain:       :cognition,
+        tags:         %i[learning math]
+      )
+      client.record_episode(
+        description:       'test failure taught me about edge cases',
+        episode_type:      :discovery,
+        domain:            :technical,
+        emotional_valence: -0.3,
+        tags:              %i[learning debugging]
+      )
+
+      # Check timeline
+      tl = client.timeline
+      expect(tl[:count]).to eq(3)
+
+      # Check self-summary
+      summary = client.self_summary[:summary]
+      expect(summary[:total_episodes]).to eq(3)
+      expect(summary[:self_concept]).not_to be_empty
+
+      # Tick
+      client.update_narrative_self
+      stats = client.narrative_self_stats[:stats]
+      expect(stats[:episode_count]).to eq(3)
+    end
+  end
+end

data/spec/legion/extensions/agentic/self/narrative_self/helpers/autobiography_spec.rb

@@ -0,0 +1,155 @@
+# frozen_string_literal: true
+
+RSpec.describe Legion::Extensions::Agentic::Self::NarrativeSelf::Helpers::Autobiography do
+  let(:auto) { described_class.new }
+
+  describe '#record_episode' do
+    it 'creates and stores an episode' do
+      episode = auto.record_episode(description: 'first task completed', episode_type: :achievement)
+      expect(episode).to be_a(Legion::Extensions::Agentic::Self::NarrativeSelf::Helpers::Episode)
+      expect(auto.episodes.size).to eq(1)
+    end
+
+    it 'updates self-concept with episode type' do
+      auto.record_episode(description: 'test', episode_type: :achievement)
+      expect(auto.self_concept).to have_key(:achievement)
+    end
+
+    it 'trims episodes when exceeding MAX_EPISODES' do
+      max = Legion::Extensions::Agentic::Self::NarrativeSelf::Helpers::Constants::MAX_EPISODES
+      (max + 5).times { |i| auto.record_episode(description: "episode #{i}") }
+      expect(auto.episodes.size).to eq(max)
+    end
+  end
+
+  describe '#find_episode' do
+    it 'finds by id' do
+      ep = auto.record_episode(description: 'test')
+      expect(auto.find_episode(ep.id)).to eq(ep)
+    end
+
+    it 'returns nil for unknown id' do
+      expect(auto.find_episode('nonexistent')).to be_nil
+    end
+  end
+
+  describe '#recent_episodes' do
+    it 'returns the last N episodes' do
+      5.times { |i| auto.record_episode(description: "ep #{i}") }
+      recent = auto.recent_episodes(3)
+      expect(recent.size).to eq(3)
+      expect(recent.last.description).to eq('ep 4')
+    end
+  end
+
+  describe '#significant_episodes' do
+    it 'returns episodes above threshold' do
+      auto.record_episode(description: 'big deal', significance: 0.9)
+      auto.record_episode(description: 'small thing', significance: 0.2)
+      significant = auto.significant_episodes(min_significance: 0.5)
+      expect(significant.size).to eq(1)
+      expect(significant.first.description).to eq('big deal')
+    end
+  end
+
+  describe '#episodes_by_type' do
+    it 'filters by episode type' do
+      auto.record_episode(description: 'win', episode_type: :achievement)
+      auto.record_episode(description: 'loss', episode_type: :failure)
+      auto.record_episode(description: 'another win', episode_type: :achievement)
+      expect(auto.episodes_by_type(:achievement).size).to eq(2)
+    end
+  end
+
+  describe '#episodes_in_domain' do
+    it 'filters by domain' do
+      auto.record_episode(description: 'code', domain: :technical)
+      auto.record_episode(description: 'meeting', domain: :social)
+      expect(auto.episodes_in_domain(:technical).size).to eq(1)
+    end
+  end
+
+  describe '#create_thread' do
+    it 'creates a narrative thread' do
+      thread = auto.create_thread(theme: :growth, domain: :personal)
+      expect(thread.theme).to eq(:growth)
+      expect(auto.threads.size).to eq(1)
+    end
+  end
+
+  describe '#strongest_threads' do
+    it 'returns threads sorted by strength' do
+      auto.create_thread(theme: :growth)
+      t2 = auto.create_thread(theme: :mastery)
+      t2.reinforce
+      strongest = auto.strongest_threads(2)
+      expect(strongest.first).to eq(t2)
+    end
+  end
+
+  describe '#timeline' do
+    it 'returns recent episodes as hashes' do
+      auto.record_episode(description: 'first')
+      auto.record_episode(description: 'second')
+      tl = auto.timeline(window: 10)
+      expect(tl.size).to eq(2)
+      expect(tl.first).to be_a(Hash)
+    end
+  end
+
+  describe '#self_summary' do
+    it 'returns a comprehensive summary' do
+      auto.record_episode(description: 'a', episode_type: :achievement, domain: :tech)
+      auto.record_episode(description: 'b', episode_type: :insight, domain: :tech)
+      summary = auto.self_summary
+      expect(summary).to have_key(:total_episodes)
+      expect(summary).to have_key(:dominant_types)
+      expect(summary).to have_key(:dominant_domains)
+      expect(summary).to have_key(:self_concept)
+      expect(summary).to have_key(:narrative_richness)
+      expect(summary[:total_episodes]).to eq(2)
+    end
+  end
+
+  describe '#decay_all' do
+    it 'decays episodes and removes faded ones' do
+      ep = auto.record_episode(description: 'old', significance: 0.06)
+      200.times { ep.decay }
+      auto.decay_all
+      expect(auto.episodes).not_to include(ep)
+    end
+
+    it 'decays threads and removes weak ones' do
+      t = auto.create_thread(theme: :test)
+      100.times { t.decay }
+      auto.decay_all
+      expect(auto.threads).not_to include(t)
+    end
+  end
+
+  describe '#to_h' do
+    it 'returns summary statistics' do
+      auto.record_episode(description: 'test', episode_type: :insight, domain: :tech)
+      h = auto.to_h
+      expect(h).to have_key(:episode_count)
+      expect(h).to have_key(:thread_count)
+      expect(h).to have_key(:self_concept)
+      expect(h).to have_key(:by_type)
+      expect(h).to have_key(:by_domain)
+      expect(h).to have_key(:avg_significance)
+    end
+  end
+
+  describe 'auto-linking' do
+    it 'links episodes to matching threads' do
+      thread = auto.create_thread(theme: :learning, domain: :cognition)
+      episode = auto.record_episode(
+        description: 'learned something new',
+        domain:      :cognition,
+        tags:        %i[learning growth]
+      )
+      expect(thread.episode_ids).to include(episode.id)
+      expect(episode.thread_ids).to include(thread.id)
+    end
+  end
+end

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

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+RSpec.describe Legion::Extensions::Agentic::Self::NarrativeSelf::Helpers::Constants do
+  it 'defines MAX_EPISODES' do
+    expect(described_class::MAX_EPISODES).to eq(500)
+  end
+
+  it 'defines MAX_THREADS' do
+    expect(described_class::MAX_THREADS).to eq(50)
+  end
+
+  it 'defines EPISODE_TYPES' do
+    expect(described_class::EPISODE_TYPES).to include(:achievement, :failure, :discovery, :insight)
+  end
+
+  it 'defines SIGNIFICANCE_LABELS covering 0.0..1.0' do
+    labels = described_class::SIGNIFICANCE_LABELS
+    [0.0, 0.1, 0.3, 0.5, 0.7, 0.9, 1.0].each do |val|
+      matched = labels.any? { |range, _| range.cover?(val) }
+      expect(matched).to be(true), "Expected #{val} to match a label range"
+    end
+  end
+
+  it 'has all expected SIGNIFICANCE_LABELS values' do
+    values = described_class::SIGNIFICANCE_LABELS.values
+    expect(values).to contain_exactly(:pivotal, :important, :routine, :minor)
+  end
+end

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

@@ -0,0 +1,144 @@
+# frozen_string_literal: true
+
+RSpec.describe Legion::Extensions::Agentic::Self::NarrativeSelf::Helpers::Episode do
+  let(:episode) do
+    described_class.new(
+      description:       'learned to handle context switches',
+      episode_type:      :insight,
+      domain:            :cognition,
+      emotional_valence: 0.6,
+      tags:              %i[learning context performance]
+    )
+  end
+
+  describe '#initialize' do
+    it 'sets description and type' do
+      expect(episode.description).to eq('learned to handle context switches')
+      expect(episode.episode_type).to eq(:insight)
+    end
+
+    it 'sets domain' do
+      expect(episode.domain).to eq(:cognition)
+    end
+
+    it 'starts with default significance' do
+      plain = described_class.new(description: 'test')
+      expect(plain.significance).to eq(Legion::Extensions::Agentic::Self::NarrativeSelf::Helpers::Constants::DEFAULT_SIGNIFICANCE)
+    end
+
+    it 'clamps emotional valence to [-1, 1]' do
+      extreme = described_class.new(description: 'extreme', emotional_valence: 5.0)
+      expect(extreme.emotional_valence).to eq(1.0)
+    end
+
+    it 'has a UUID id' do
+      expect(episode.id).to match(/\A[0-9a-f-]{36}\z/)
+    end
+
+    it 'stores tags' do
+      expect(episode.tags).to eq(%i[learning context performance])
+    end
+
+    it 'starts with empty thread_ids' do
+      expect(episode.thread_ids).to be_empty
+    end
+  end
+
+  describe '#boost' do
+    it 'increases significance' do
+      initial = episode.significance
+      episode.boost(0.1)
+      expect(episode.significance).to be > initial
+    end
+
+    it 'includes emotional factor' do
+      low_emotion = described_class.new(description: 'calm', emotional_valence: 0.0)
+      high_emotion = described_class.new(description: 'excited', emotional_valence: 0.9)
+      low_emotion.boost(0.1)
+      high_emotion.boost(0.1)
+      expect(high_emotion.significance).to be > low_emotion.significance
+    end
+
+    it 'caps at 1.0' do
+      10.times { episode.boost(0.5) }
+      expect(episode.significance).to be <= 1.0
+    end
+  end
+
+  describe '#decay' do
+    it 'decreases significance' do
+      initial = episode.significance
+      episode.decay
+      expect(episode.significance).to be < initial
+    end
+
+    it 'does not go below zero' do
+      200.times { episode.decay }
+      expect(episode.significance).to be >= 0.0
+    end
+  end
+
+  describe '#faded?' do
+    it 'is not faded when fresh' do
+      expect(episode.faded?).to be false
+    end
+
+    it 'becomes faded after heavy decay' do
+      200.times { episode.decay }
+      expect(episode.faded?).to be true
+    end
+  end
+
+  describe '#label' do
+    it 'returns a symbol' do
+      expect(episode.label).to be_a(Symbol)
+    end
+
+    it 'returns :minor for low significance' do
+      200.times { episode.decay }
+      expect(episode.label).to eq(:minor)
+    end
+  end
+
+  describe '#link_thread' do
+    it 'adds a thread id' do
+      episode.link_thread('thread-1')
+      expect(episode.thread_ids).to include('thread-1')
+    end
+
+    it 'does not duplicate' do
+      episode.link_thread('thread-1')
+      episode.link_thread('thread-1')
+      expect(episode.thread_ids.count('thread-1')).to eq(1)
+    end
+  end
+
+  describe '#matches_tags?' do
+    it 'returns match ratio for overlapping tags' do
+      score = episode.matches_tags?(%i[learning performance])
+      expect(score).to be_within(0.01).of(2.0 / 2.0)
+    end
+
+    it 'returns 0.0 for no overlap' do
+      expect(episode.matches_tags?(%i[sleep eat])).to eq(0.0)
+    end
+
+    it 'returns 0.0 for empty input' do
+      expect(episode.matches_tags?([])).to be_falsey
+    end
+  end
+
+  describe '#to_h' do
+    it 'contains all expected keys' do
+      h = episode.to_h
+      expect(h).to have_key(:id)
+      expect(h).to have_key(:description)
+      expect(h).to have_key(:episode_type)
+      expect(h).to have_key(:significance)
+      expect(h).to have_key(:emotional_valence)
+      expect(h).to have_key(:label)
+      expect(h).to have_key(:tags)
+      expect(h).to have_key(:thread_ids)
+    end
+  end
+end

data/spec/legion/extensions/agentic/self/narrative_self/helpers/narrative_thread_spec.rb

@@ -0,0 +1,87 @@
+# frozen_string_literal: true
+
+RSpec.describe Legion::Extensions::Agentic::Self::NarrativeSelf::Helpers::NarrativeThread do
+  let(:thread) { described_class.new(theme: :growth, domain: :cognition) }
+
+  describe '#initialize' do
+    it 'sets theme and domain' do
+      expect(thread.theme).to eq(:growth)
+      expect(thread.domain).to eq(:cognition)
+    end
+
+    it 'starts with strength 0.5' do
+      expect(thread.strength).to eq(0.5)
+    end
+
+    it 'starts with empty episode_ids' do
+      expect(thread.episode_ids).to be_empty
+    end
+
+    it 'has a UUID id' do
+      expect(thread.id).to match(/\A[0-9a-f-]{36}\z/)
+    end
+  end
+
+  describe '#add_episode' do
+    it 'adds an episode id' do
+      thread.add_episode('ep-1')
+      expect(thread.episode_ids).to include('ep-1')
+    end
+
+    it 'does not duplicate' do
+      thread.add_episode('ep-1')
+      thread.add_episode('ep-1')
+      expect(thread.episode_ids.count('ep-1')).to eq(1)
+    end
+
+    it 'caps at MAX_CHAPTER_SIZE' do
+      max = Legion::Extensions::Agentic::Self::NarrativeSelf::Helpers::Constants::MAX_CHAPTER_SIZE
+      (max + 5).times { |i| thread.add_episode("ep-#{i}") }
+      expect(thread.episode_ids.size).to eq(max)
+    end
+
+    it 'reinforces the thread' do
+      initial = thread.strength
+      thread.add_episode('ep-1')
+      expect(thread.strength).to be > initial
+    end
+  end
+
+  describe '#decay' do
+    it 'reduces strength' do
+      initial = thread.strength
+      thread.decay
+      expect(thread.strength).to be < initial
+    end
+  end
+
+  describe '#weak?' do
+    it 'is not weak when fresh' do
+      expect(thread.weak?).to be false
+    end
+
+    it 'becomes weak after heavy decay' do
+      100.times { thread.decay }
+      expect(thread.weak?).to be true
+    end
+  end
+
+  describe '#size' do
+    it 'returns the episode count' do
+      thread.add_episode('ep-1')
+      thread.add_episode('ep-2')
+      expect(thread.size).to eq(2)
+    end
+  end
+
+  describe '#to_h' do
+    it 'contains expected keys' do
+      h = thread.to_h
+      expect(h).to have_key(:id)
+      expect(h).to have_key(:theme)
+      expect(h).to have_key(:domain)
+      expect(h).to have_key(:strength)
+      expect(h).to have_key(:episodes)
+    end
+  end
+end

data/spec/legion/extensions/agentic/self/narrative_self/runners/narrative_self_spec.rb

@@ -0,0 +1,118 @@
+# frozen_string_literal: true
+
+RSpec.describe Legion::Extensions::Agentic::Self::NarrativeSelf::Runners::NarrativeSelf do
+  let(:client) { Legion::Extensions::Agentic::Self::NarrativeSelf::Client.new }
+
+  describe '#record_episode' do
+    it 'returns success with episode data' do
+      result = client.record_episode(description: 'completed first build', episode_type: :achievement)
+      expect(result[:success]).to be true
+      expect(result[:episode][:description]).to eq('completed first build')
+      expect(result[:episode][:episode_type]).to eq(:achievement)
+    end
+  end
+
+  describe '#recent_episodes' do
+    before do
+      3.times { |i| client.record_episode(description: "event #{i}") }
+    end
+
+    it 'returns recent episodes' do
+      result = client.recent_episodes(count: 2)
+      expect(result[:success]).to be true
+      expect(result[:count]).to eq(2)
+    end
+  end
+
+  describe '#significant_episodes' do
+    before do
+      client.record_episode(description: 'major', significance: 0.9)
+      client.record_episode(description: 'minor', significance: 0.1)
+    end
+
+    it 'filters by significance' do
+      result = client.significant_episodes(min_significance: 0.5)
+      expect(result[:count]).to eq(1)
+      expect(result[:episodes].first[:description]).to eq('major')
+    end
+  end
+
+  describe '#episodes_by_type' do
+    before do
+      client.record_episode(description: 'win', episode_type: :achievement)
+      client.record_episode(description: 'learn', episode_type: :insight)
+    end
+
+    it 'filters by type' do
+      result = client.episodes_by_type(episode_type: :achievement)
+      expect(result[:count]).to eq(1)
+    end
+  end
+
+  describe '#create_thread' do
+    it 'returns success with thread data' do
+      result = client.create_thread(theme: :growth, domain: :personal)
+      expect(result[:success]).to be true
+      expect(result[:thread][:theme]).to eq(:growth)
+    end
+  end
+
+  describe '#strongest_threads' do
+    before do
+      client.create_thread(theme: :growth)
+      client.create_thread(theme: :mastery)
+    end
+
+    it 'returns threads sorted by strength' do
+      result = client.strongest_threads(count: 2)
+      expect(result[:success]).to be true
+      expect(result[:count]).to eq(2)
+    end
+  end
+
+  describe '#timeline' do
+    before do
+      3.times { |i| client.record_episode(description: "event #{i}") }
+    end
+
+    it 'returns timeline entries' do
+      result = client.timeline(window: 10)
+      expect(result[:success]).to be true
+      expect(result[:count]).to eq(3)
+      expect(result[:timeline].first).to be_a(Hash)
+    end
+  end
+
+  describe '#self_summary' do
+    before do
+      client.record_episode(description: 'a', episode_type: :achievement, domain: :tech)
+      client.record_episode(description: 'b', episode_type: :insight, domain: :personal)
+    end
+
+    it 'returns comprehensive summary' do
+      result = client.self_summary
+      expect(result[:success]).to be true
+      expect(result[:summary][:total_episodes]).to eq(2)
+      expect(result[:summary]).to have_key(:narrative_richness)
+      expect(result[:summary]).to have_key(:self_concept)
+    end
+  end
+
+  describe '#update_narrative_self' do
+    it 'decays and reports counts' do
+      client.record_episode(description: 'test')
+      result = client.update_narrative_self
+      expect(result[:success]).to be true
+      expect(result[:episode_count]).to eq(1)
+    end
+  end
+
+  describe '#narrative_self_stats' do
+    it 'returns stats' do
+      result = client.narrative_self_stats
+      expect(result[:success]).to be true
+      expect(result[:stats]).to have_key(:episode_count)
+      expect(result[:stats]).to have_key(:thread_count)
+    end
+  end
+end

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

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+RSpec.describe Legion::Extensions::Agentic::Self::Personality::Client do
+  it 'creates default personality store' do
+    client = described_class.new
+    expect(client.personality_store).to be_a(Legion::Extensions::Agentic::Self::Personality::Helpers::PersonalityStore)
+  end
+
+  it 'accepts injected personality store' do
+    store = Legion::Extensions::Agentic::Self::Personality::Helpers::PersonalityStore.new
+    client = described_class.new(personality_store: store)
+    expect(client.personality_store).to equal(store)
+  end
+
+  it 'includes Personality runner methods' do
+    client = described_class.new
+    expect(client).to respond_to(:update_personality, :personality_profile,
+                                 :describe_personality, :personality_stats)
+  end
+end

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

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+RSpec.describe Legion::Extensions::Agentic::Self::Personality::Helpers::Constants do
+  it 'defines 5 traits (OCEAN)' do
+    expect(described_class::TRAITS.size).to eq(5)
+  end
+
+  it 'includes all Big Five traits' do
+    expect(described_class::TRAITS).to contain_exactly(
+      :openness, :conscientiousness, :extraversion, :agreeableness, :neuroticism
+    )
+  end
+
+  it 'has default trait value of 0.5' do
+    expect(described_class::DEFAULT_TRAIT_VALUE).to eq(0.5)
+  end
+
+  it 'has a very low trait alpha for stability' do
+    expect(described_class::TRAIT_ALPHA).to be < 0.1
+  end
+
+  it 'defines descriptors for every trait' do
+    described_class::TRAITS.each do |trait|
+      expect(described_class::TRAIT_DESCRIPTORS).to have_key(trait)
+      expect(described_class::TRAIT_DESCRIPTORS[trait]).to include(:high, :mid, :low)
+    end
+  end
+
+  it 'maps signals to traits' do
+    expect(described_class::SIGNAL_MAP).not_to be_empty
+    described_class::SIGNAL_MAP.each_value do |trait, direction, weight|
+      expect(described_class::TRAITS).to include(trait)
+      expect(%i[positive negative]).to include(direction)
+      expect(weight).to be_between(0.0, 1.0)
+    end
+  end
+
+  it 'has HIGH_THRESHOLD > LOW_THRESHOLD' do
+    expect(described_class::HIGH_THRESHOLD).to be > described_class::LOW_THRESHOLD
+  end
+end