lex-agentic-executive 0.1.0

data/spec/legion/extensions/agentic/executive/autopilot/helpers/routine_spec.rb

@@ -0,0 +1,133 @@
+# frozen_string_literal: true
+
+RSpec.describe Legion::Extensions::Agentic::Executive::Autopilot::Helpers::Routine do
+  subject(:routine) { described_class.new(pattern: 'check_email') }
+
+  describe '#initialize' do
+    it 'assigns a UUID id' do
+      expect(routine.id).to match(/\A[0-9a-f-]{36}\z/)
+    end
+
+    it 'stores pattern' do
+      expect(routine.pattern).to eq('check_email')
+    end
+
+    it 'defaults domain to :routine' do
+      expect(routine.domain).to eq(:routine)
+    end
+
+    it 'defaults familiarity to 0.0' do
+      expect(routine.familiarity).to eq(0.0)
+    end
+
+    it 'clamps familiarity' do
+      high = described_class.new(pattern: 'x', familiarity: 5.0)
+      expect(high.familiarity).to eq(1.0)
+    end
+
+    it 'validates domain' do
+      bad = described_class.new(pattern: 'x', domain: :nonexistent)
+      expect(bad.domain).to eq(:unknown)
+    end
+
+    it 'initializes execution_count to 0' do
+      expect(routine.execution_count).to eq(0)
+    end
+  end
+
+  describe '#execute!' do
+    it 'increments execution_count' do
+      routine.execute!
+      expect(routine.execution_count).to eq(1)
+    end
+
+    it 'increases familiarity on success' do
+      routine.execute!(success: true)
+      expect(routine.familiarity).to be > 0.0
+    end
+
+    it 'decreases familiarity on failure' do
+      familiar = described_class.new(pattern: 'x', familiarity: 0.5)
+      familiar.execute!(success: false)
+      expect(familiar.familiarity).to be < 0.5
+    end
+
+    it 'tracks success count' do
+      routine.execute!(success: true)
+      expect(routine.success_count).to eq(1)
+    end
+
+    it 'tracks failure count' do
+      routine.execute!(success: false)
+      expect(routine.failure_count).to eq(1)
+    end
+
+    it 'updates last_executed_at' do
+      routine.execute!
+      expect(routine.last_executed_at).to be_a(Time)
+    end
+  end
+
+  describe '#decay!' do
+    it 'reduces familiarity' do
+      familiar = described_class.new(pattern: 'x', familiarity: 0.5)
+      familiar.decay!
+      expect(familiar.familiarity).to be < 0.5
+    end
+
+    it 'clamps at 0.0' do
+      routine.decay!
+      expect(routine.familiarity).to eq(0.0)
+    end
+  end
+
+  describe '#autopilot_ready?' do
+    it 'is false for new routine' do
+      expect(routine.autopilot_ready?).to be false
+    end
+
+    it 'is true for highly familiar routine' do
+      expert = described_class.new(pattern: 'x', familiarity: 0.8)
+      expect(expert.autopilot_ready?).to be true
+    end
+  end
+
+  describe '#novel?' do
+    it 'is true for new routine' do
+      expect(routine.novel?).to be true
+    end
+
+    it 'is false for familiar routine' do
+      familiar = described_class.new(pattern: 'x', familiarity: 0.5)
+      expect(familiar.novel?).to be false
+    end
+  end
+
+  describe '#success_rate' do
+    it 'returns 0.0 with no executions' do
+      expect(routine.success_rate).to eq(0.0)
+    end
+
+    it 'returns correct rate' do
+      routine.execute!(success: true)
+      routine.execute!(success: false)
+      expect(routine.success_rate).to eq(0.5)
+    end
+  end
+
+  describe '#familiarity_label' do
+    it 'returns :novel for new routine' do
+      expect(routine.familiarity_label).to eq(:novel)
+    end
+  end
+
+  describe '#to_h' do
+    it 'includes all fields' do
+      hash = routine.to_h
+      expect(hash).to include(
+        :id, :pattern, :domain, :familiarity, :familiarity_label,
+        :autopilot_ready, :novel, :execution_count, :success_rate
+      )
+    end
+  end
+end

data/spec/legion/extensions/agentic/executive/autopilot/runners_spec.rb

@@ -0,0 +1,108 @@
+# frozen_string_literal: true
+
+RSpec.describe Legion::Extensions::Agentic::Executive::Autopilot::Runners::CognitiveAutopilot do
+  let(:engine) { Legion::Extensions::Agentic::Executive::Autopilot::Helpers::AutopilotEngine.new }
+  let(:runner) do
+    obj = Object.new
+    obj.extend(described_class)
+    obj.instance_variable_set(:@default_engine, engine)
+    obj
+  end
+
+  describe '#register_routine' do
+    it 'returns success with routine hash' do
+      result = runner.register_routine(pattern: 'check_logs', engine: engine)
+      expect(result[:success]).to be true
+      expect(result[:routine][:pattern]).to eq('check_logs')
+    end
+  end
+
+  describe '#execute_routine' do
+    it 'returns success with mode and energy' do
+      routine = engine.register_routine(pattern: 'test')
+      result = runner.execute_routine(routine_id: routine.id, engine: engine)
+      expect(result[:success]).to be true
+      expect(result[:mode]).to be_a(Symbol)
+      expect(result[:energy]).to be_a(Float)
+    end
+
+    it 'returns failure for unknown routine' do
+      result = runner.execute_routine(routine_id: 'bad', engine: engine)
+      expect(result[:success]).to be false
+    end
+  end
+
+  describe '#switch_to_deliberate' do
+    it 'returns success when switching' do
+      engine.switch_to_autopilot!
+      result = runner.switch_to_deliberate(engine: engine)
+      expect(result[:success]).to be true
+      expect(result[:mode]).to eq(:deliberate)
+    end
+
+    it 'returns failure when already deliberate' do
+      result = runner.switch_to_deliberate(engine: engine)
+      expect(result[:success]).to be false
+    end
+  end
+
+  describe '#switch_to_autopilot' do
+    it 'returns success' do
+      result = runner.switch_to_autopilot(engine: engine)
+      expect(result[:success]).to be true
+      expect(result[:mode]).to eq(:autopilot)
+    end
+  end
+
+  describe '#rest' do
+    it 'returns success with energy' do
+      result = runner.rest(engine: engine)
+      expect(result[:success]).to be true
+      expect(result[:energy]).to be_a(Float)
+    end
+  end
+
+  describe '#decay_all' do
+    it 'returns success' do
+      result = runner.decay_all(engine: engine)
+      expect(result[:success]).to be true
+    end
+  end
+
+  describe '#autopilot_routines' do
+    it 'returns list' do
+      engine.register_routine(pattern: 'x', familiarity: 0.9)
+      result = runner.autopilot_routines(engine: engine)
+      expect(result[:count]).to eq(1)
+    end
+  end
+
+  describe '#novel_routines' do
+    it 'returns list' do
+      engine.register_routine(pattern: 'x', familiarity: 0.1)
+      result = runner.novel_routines(engine: engine)
+      expect(result[:count]).to eq(1)
+    end
+  end
+
+  describe '#get_routine' do
+    it 'returns routine by id' do
+      routine = engine.register_routine(pattern: 'test')
+      result = runner.get_routine(routine_id: routine.id, engine: engine)
+      expect(result[:success]).to be true
+    end
+
+    it 'returns failure for unknown' do
+      result = runner.get_routine(routine_id: 'bad', engine: engine)
+      expect(result[:success]).to be false
+    end
+  end
+
+  describe '#autopilot_status' do
+    it 'returns comprehensive status' do
+      result = runner.autopilot_status(engine: engine)
+      expect(result[:success]).to be true
+      expect(result[:current_mode]).to eq(:deliberate)
+    end
+  end
+end

data/spec/legion/extensions/agentic/executive/chunking/client_spec.rb

@@ -0,0 +1,67 @@
+# frozen_string_literal: true
+
+require 'legion/extensions/agentic/executive/chunking/client'
+
+RSpec.describe Legion::Extensions::Agentic::Executive::Chunking::Client do
+  let(:client) { described_class.new }
+
+  it 'responds to all runner methods' do
+    %i[add_item create_chunk merge_chunks load_to_working_memory
+       unload_from_working_memory working_memory_status decay_all
+       reinforce_chunk chunking_report strongest_chunks unchunked_items].each do |method|
+      expect(client).to respond_to(method)
+    end
+  end
+
+  it 'maintains state across calls using internal engine' do
+    client.add_item(content: 'pawn structure')
+    client.add_item(content: 'knight outpost')
+    report = client.chunking_report
+    expect(report[:report][:total_items]).to eq(2)
+  end
+
+  it 'runs a full chunking workflow' do
+    r1 = client.add_item(content: 'e4 e5', domain: :chess)
+    r2 = client.add_item(content: 'Nf3 Nc6', domain: :chess)
+    r3 = client.add_item(content: 'Bb5', domain: :chess)
+
+    chunk = client.create_chunk(
+      label:    'Ruy Lopez opening',
+      item_ids: [r1[:item_id], r2[:item_id], r3[:item_id]]
+    )
+    expect(chunk[:success]).to be true
+
+    loaded = client.load_to_working_memory(chunk_id: chunk[:chunk_id])
+    expect(loaded[:success]).to be true
+    expect(loaded[:working_memory_size]).to eq(1)
+
+    status = client.working_memory_status
+    expect(status[:size]).to eq(1)
+    expect(status[:load]).to be > 0.0
+
+    report = client.chunking_report
+    expect(report[:report][:chunking_efficiency]).to eq(1.0)
+    expect(report[:report][:unchunked_items]).to eq(0)
+  end
+
+  it 'supports merge of two chunks into a hierarchy' do
+    ra = client.add_item(content: 'opening theory')[:item_id]
+    rb = client.add_item(content: 'endgame theory')[:item_id]
+    ca = client.create_chunk(label: 'Opening', item_ids: [ra])[:chunk_id]
+    cb = client.create_chunk(label: 'Endgame', item_ids: [rb])[:chunk_id]
+
+    merged = client.merge_chunks(chunk_ids: [ca, cb], label: 'Chess Theory')
+    expect(merged[:success]).to be true
+    expect(merged[:chunk][:hierarchical]).to be true
+  end
+
+  it 'reports unchunked items correctly' do
+    client.add_item(content: 'orphan item')
+    r2 = client.add_item(content: 'grouped item')[:item_id]
+    client.create_chunk(label: 'group', item_ids: [r2])
+
+    result = client.unchunked_items
+    expect(result[:items].size).to eq(1)
+    expect(result[:items].first[:content]).to eq('orphan item')
+  end
+end

data/spec/legion/extensions/agentic/executive/chunking/helpers/chunk_spec.rb

@@ -0,0 +1,187 @@
+# frozen_string_literal: true
+
+RSpec.describe Legion::Extensions::Agentic::Executive::Chunking::Helpers::Chunk do
+  let(:chunk) { described_class.new(label: 'chess opening') }
+
+  describe '#initialize' do
+    it 'assigns a uuid id' do
+      expect(chunk.id).to match(/\A[0-9a-f-]{36}\z/)
+    end
+
+    it 'stores label' do
+      expect(chunk.label).to eq('chess opening')
+    end
+
+    it 'starts with empty item_ids' do
+      expect(chunk.item_ids).to be_empty
+    end
+
+    it 'starts with empty sub_chunk_ids' do
+      expect(chunk.sub_chunk_ids).to be_empty
+    end
+
+    it 'starts with DEFAULT_COHERENCE' do
+      expect(chunk.coherence).to eq(Legion::Extensions::Agentic::Executive::Chunking::Helpers::Constants::DEFAULT_COHERENCE)
+    end
+
+    it 'starts with recall_strength of 0.8' do
+      expect(chunk.recall_strength).to eq(0.8)
+    end
+
+    it 'starts with access_count of 0' do
+      expect(chunk.access_count).to eq(0)
+    end
+
+    it 'pre-populates item_ids from constructor' do
+      c = described_class.new(label: 'test', item_ids: %w[a b c])
+      expect(c.item_ids).to eq(%w[a b c])
+    end
+
+    it 'does not share item_ids reference' do
+      ids = %w[a b]
+      c = described_class.new(label: 'test', item_ids: ids)
+      ids << 'c'
+      expect(c.item_ids.size).to eq(2)
+    end
+  end
+
+  describe '#add_item!' do
+    it 'adds item_id to item_ids' do
+      chunk.add_item!(item_id: 'abc')
+      expect(chunk.item_ids).to include('abc')
+    end
+
+    it 'does not add duplicates' do
+      chunk.add_item!(item_id: 'abc')
+      chunk.add_item!(item_id: 'abc')
+      expect(chunk.item_ids.count('abc')).to eq(1)
+    end
+  end
+
+  describe '#remove_item!' do
+    before { chunk.add_item!(item_id: 'abc') }
+
+    it 'removes item_id' do
+      chunk.remove_item!(item_id: 'abc')
+      expect(chunk.item_ids).not_to include('abc')
+    end
+  end
+
+  describe '#add_sub_chunk!' do
+    it 'adds sub_chunk_id' do
+      chunk.add_sub_chunk!(chunk_id: 'sub-1')
+      expect(chunk.sub_chunk_ids).to include('sub-1')
+    end
+
+    it 'does not add duplicates' do
+      chunk.add_sub_chunk!(chunk_id: 'sub-1')
+      chunk.add_sub_chunk!(chunk_id: 'sub-1')
+      expect(chunk.sub_chunk_ids.count('sub-1')).to eq(1)
+    end
+  end
+
+  describe '#reinforce!' do
+    it 'increments access_count' do
+      chunk.reinforce!
+      expect(chunk.access_count).to eq(1)
+    end
+
+    it 'boosts coherence' do
+      original = chunk.coherence
+      chunk.reinforce!
+      expect(chunk.coherence).to be > original
+    end
+
+    it 'boosts recall_strength' do
+      original = chunk.recall_strength
+      chunk.reinforce!
+      expect(chunk.recall_strength).to be > original
+    end
+
+    it 'caps coherence at 1.0' do
+      20.times { chunk.reinforce! }
+      expect(chunk.coherence).to eq(1.0)
+    end
+
+    it 'caps recall_strength at 1.0' do
+      20.times { chunk.reinforce! }
+      expect(chunk.recall_strength).to eq(1.0)
+    end
+  end
+
+  describe '#decay!' do
+    it 'reduces recall_strength' do
+      original = chunk.recall_strength
+      chunk.decay!
+      expect(chunk.recall_strength).to be < original
+    end
+
+    it 'reduces coherence' do
+      original = chunk.coherence
+      chunk.decay!
+      expect(chunk.coherence).to be < original
+    end
+
+    it 'floors recall_strength at 0.0' do
+      100.times { chunk.decay! }
+      expect(chunk.recall_strength).to eq(0.0)
+    end
+  end
+
+  describe '#size' do
+    it 'returns count of item_ids' do
+      chunk.add_item!(item_id: 'a')
+      chunk.add_item!(item_id: 'b')
+      expect(chunk.size).to eq(2)
+    end
+  end
+
+  describe '#hierarchical?' do
+    it 'returns false when no sub_chunks' do
+      expect(chunk.hierarchical?).to be false
+    end
+
+    it 'returns true when sub_chunks exist' do
+      chunk.add_sub_chunk!(chunk_id: 'child')
+      expect(chunk.hierarchical?).to be true
+    end
+  end
+
+  describe '#coherence_label' do
+    it 'returns :loosely_chunked for default coherence (0.5)' do
+      expect(chunk.coherence_label).to eq(:loosely_chunked)
+    end
+  end
+
+  describe '#recall_label' do
+    it 'returns :instant for high recall_strength (0.8)' do
+      expect(chunk.recall_label).to eq(:instant)
+    end
+  end
+
+  describe '#size_label' do
+    it 'returns :micro for empty chunk' do
+      expect(chunk.size_label).to eq(:micro)
+    end
+
+    it 'returns :large for 7+ items' do
+      7.times { |i| chunk.add_item!(item_id: "item-#{i}") }
+      expect(chunk.size_label).to eq(:large)
+    end
+  end
+
+  describe '#to_h' do
+    it 'includes all expected keys' do
+      h = chunk.to_h
+      expected = %i[id label item_ids sub_chunk_ids coherence recall_strength
+                    access_count created_at size hierarchical coherence_label
+                    recall_label size_label]
+      expect(h.keys).to include(*expected)
+    end
+
+    it 'rounds coherence to 10 decimal places' do
+      chunk.reinforce!
+      expect(chunk.to_h[:coherence]).to eq(chunk.coherence.round(10))
+    end
+  end
+end