lex-cognitive-chunking 0.1.0

data/spec/legion/extensions/cognitive_chunking/runners/cognitive_chunking_spec.rb

@@ -0,0 +1,169 @@
+# frozen_string_literal: true
+
+require 'legion/extensions/cognitive_chunking/client'
+
+RSpec.describe Legion::Extensions::CognitiveChunking::Runners::CognitiveChunking do
+  let(:engine) { Legion::Extensions::CognitiveChunking::Helpers::ChunkingEngine.new }
+  let(:client) { Legion::Extensions::CognitiveChunking::Client.new }
+
+  def add_items_to(target_engine, count)
+    count.times.map { |i| target_engine.add_item(content: "item #{i}")[:item_id] }
+  end
+
+  describe '#add_item' do
+    it 'returns success' do
+      result = client.add_item(content: 'knight fork', domain: :chess)
+      expect(result[:success]).to be true
+    end
+
+    it 'accepts injected engine' do
+      result = client.add_item(content: 'test', engine: engine)
+      expect(result[:success]).to be true
+      expect(engine.items.size).to eq(1)
+    end
+
+    it 'returns item_id' do
+      result = client.add_item(content: 'fork threat')
+      expect(result[:item_id]).to be_a(String)
+    end
+  end
+
+  describe '#create_chunk' do
+    let(:item_ids) { add_items_to(engine, 3) }
+
+    it 'creates a chunk via injected engine' do
+      result = client.create_chunk(label: 'chess tactics', item_ids: item_ids, engine: engine)
+      expect(result[:success]).to be true
+    end
+
+    it 'returns chunk_id' do
+      result = client.create_chunk(label: 'tactics', item_ids: item_ids, engine: engine)
+      expect(result[:chunk_id]).to be_a(String)
+    end
+
+    it 'fails for empty item_ids' do
+      result = client.create_chunk(label: 'empty', item_ids: [], engine: engine)
+      expect(result[:success]).to be false
+    end
+  end
+
+  describe '#merge_chunks' do
+    let(:item_ids_a) { add_items_to(engine, 2) }
+    let(:item_ids_b) { add_items_to(engine, 2) }
+    let(:chunk_a_id) { engine.create_chunk(label: 'A', item_ids: item_ids_a)[:chunk_id] }
+    let(:chunk_b_id) { engine.create_chunk(label: 'B', item_ids: item_ids_b)[:chunk_id] }
+
+    it 'merges two chunks' do
+      result = client.merge_chunks(chunk_ids: [chunk_a_id, chunk_b_id], label: 'AB', engine: engine)
+      expect(result[:success]).to be true
+    end
+
+    it 'marks parent as hierarchical' do
+      result = client.merge_chunks(chunk_ids: [chunk_a_id, chunk_b_id], label: 'AB', engine: engine)
+      parent = engine.chunks[result[:chunk_id]]
+      expect(parent.hierarchical?).to be true
+    end
+  end
+
+  describe '#load_to_working_memory' do
+    let(:item_id) { engine.add_item(content: 'wm item')[:item_id] }
+    let(:chunk_id) { engine.create_chunk(label: 'wm', item_ids: [item_id])[:chunk_id] }
+
+    it 'loads chunk to working memory' do
+      result = client.load_to_working_memory(chunk_id: chunk_id, engine: engine)
+      expect(result[:success]).to be true
+    end
+
+    it 'returns working_memory_size' do
+      result = client.load_to_working_memory(chunk_id: chunk_id, engine: engine)
+      expect(result[:working_memory_size]).to eq(1)
+    end
+  end
+
+  describe '#unload_from_working_memory' do
+    let(:item_id) { engine.add_item(content: 'unload item')[:item_id] }
+    let(:chunk_id) { engine.create_chunk(label: 'unload', item_ids: [item_id])[:chunk_id] }
+
+    before { engine.load_to_working_memory(chunk_id: chunk_id) }
+
+    it 'unloads chunk from working memory' do
+      result = client.unload_from_working_memory(chunk_id: chunk_id, engine: engine)
+      expect(result[:success]).to be true
+      expect(engine.working_memory).not_to include(chunk_id)
+    end
+  end
+
+  describe '#working_memory_status' do
+    it 'returns success with capacity info' do
+      result = client.working_memory_status(engine: engine)
+      expect(result[:success]).to be true
+      expect(result[:capacity]).to eq(7)
+    end
+
+    it 'returns a capacity label' do
+      result = client.working_memory_status(engine: engine)
+      expect(result[:label]).to be_a(Symbol)
+    end
+
+    it 'reports not overloaded for empty working memory' do
+      result = client.working_memory_status(engine: engine)
+      expect(result[:overloaded]).to be false
+    end
+  end
+
+  describe '#decay_all' do
+    it 'returns success' do
+      result = client.decay_all(engine: engine)
+      expect(result[:success]).to be true
+    end
+
+    it 'decays chunks in the engine' do
+      id = engine.add_item(content: 'decay me')[:item_id]
+      cid = engine.create_chunk(label: 'decay', item_ids: [id])[:chunk_id]
+      before_recall = engine.chunks[cid].recall_strength
+      client.decay_all(engine: engine)
+      expect(engine.chunks[cid].recall_strength).to be < before_recall
+    end
+  end
+
+  describe '#reinforce_chunk' do
+    let(:item_id) { engine.add_item(content: 'reinforce')[:item_id] }
+    let(:chunk_id) { engine.create_chunk(label: 'r', item_ids: [item_id])[:chunk_id] }
+
+    it 'returns success' do
+      result = client.reinforce_chunk(chunk_id: chunk_id, engine: engine)
+      expect(result[:success]).to be true
+    end
+
+    it 'boosts the chunk recall' do
+      before_recall = engine.chunks[chunk_id].recall_strength
+      client.reinforce_chunk(chunk_id: chunk_id, engine: engine)
+      expect(engine.chunks[chunk_id].recall_strength).to be > before_recall
+    end
+  end
+
+  describe '#chunking_report' do
+    it 'returns success with report' do
+      result = client.chunking_report(engine: engine)
+      expect(result[:success]).to be true
+      expect(result[:report]).to have_key(:total_items)
+    end
+  end
+
+  describe '#strongest_chunks' do
+    it 'returns success with chunks array' do
+      result = client.strongest_chunks(engine: engine)
+      expect(result[:success]).to be true
+      expect(result[:chunks]).to be_an(Array)
+    end
+  end
+
+  describe '#unchunked_items' do
+    it 'returns success with items array' do
+      engine.add_item(content: 'free item')
+      result = client.unchunked_items(engine: engine)
+      expect(result[:success]).to be true
+      expect(result[:items].size).to eq(1)
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,20 @@
+# 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
+  end
+end
+
+require 'legion/extensions/cognitive_chunking'
+
+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

@@ -0,0 +1,80 @@
+--- !ruby/object:Gem::Specification
+name: lex-cognitive-chunking
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Esity
+bindir: bin
+cert_chain: []
+date: 1980-01-02 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: legion-gaia
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: 'George Miller''s 7+/-2 principle: groups information items into hierarchical
+  chunks to model working memory capacity'
+email:
+- matthewdiverson@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- Gemfile
+- LICENSE
+- README.md
+- lex-cognitive-chunking.gemspec
+- lib/legion/extensions/cognitive_chunking.rb
+- lib/legion/extensions/cognitive_chunking/client.rb
+- lib/legion/extensions/cognitive_chunking/helpers/chunk.rb
+- lib/legion/extensions/cognitive_chunking/helpers/chunking_engine.rb
+- lib/legion/extensions/cognitive_chunking/helpers/constants.rb
+- lib/legion/extensions/cognitive_chunking/helpers/information_item.rb
+- lib/legion/extensions/cognitive_chunking/runners/cognitive_chunking.rb
+- lib/legion/extensions/cognitive_chunking/version.rb
+- spec/legion/extensions/cognitive_chunking/client_spec.rb
+- spec/legion/extensions/cognitive_chunking/helpers/chunk_spec.rb
+- spec/legion/extensions/cognitive_chunking/helpers/chunking_engine_spec.rb
+- spec/legion/extensions/cognitive_chunking/helpers/constants_spec.rb
+- spec/legion/extensions/cognitive_chunking/helpers/information_item_spec.rb
+- spec/legion/extensions/cognitive_chunking/runners/cognitive_chunking_spec.rb
+- spec/spec_helper.rb
+homepage: https://github.com/LegionIO/lex-cognitive-chunking
+licenses:
+- MIT
+metadata:
+  homepage_uri: https://github.com/LegionIO/lex-cognitive-chunking
+  source_code_uri: https://github.com/LegionIO/lex-cognitive-chunking
+  documentation_uri: https://github.com/LegionIO/lex-cognitive-chunking
+  changelog_uri: https://github.com/LegionIO/lex-cognitive-chunking
+  bug_tracker_uri: https://github.com/LegionIO/lex-cognitive-chunking/issues
+  rubygems_mfa_required: 'true'
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '3.4'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.6.9
+specification_version: 4
+summary: LEX Cognitive Chunking
+test_files: []