lex-cognitive-compression 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 2267287b5f2dea75cb6cb8606b891280b9a8593f1a83febdd769747cc2254ebf
+  data.tar.gz: 90fd47f51582ff7ad354b7a3885958e078dbd73db3696e6b96d731a7a01fbecd
+SHA512:
+  metadata.gz: c55c3ec947051588b37b93c7d5ea4de4c4070d5cd9c9377980c8aa62ba111b57b7528c6cd492a34c4463f94e68730741d8673af36c662b0c3d7777a6350c48ee
+  data.tar.gz: 8abc5bea22c7538d9ccadfad5f94a2efb4591714d3a45e71b52e50c387b35664b3f46c59ce7966b851f89e5bb9ac01f44471778e67197fbca445ca9b14dc5c2d

data/.github/workflows/ci.yml

@@ -0,0 +1,16 @@
+name: CI
+on:
+  push:
+    branches: [main]
+  pull_request:
+
+jobs:
+  ci:
+    uses: LegionIO/.github/.github/workflows/ci.yml@main
+
+  release:
+    needs: ci
+    if: github.event_name == 'push' && github.ref == 'refs/heads/main'
+    uses: LegionIO/.github/.github/workflows/release.yml@main
+    secrets:
+      rubygems-api-key: ${{ secrets.RUBYGEMS_API_KEY }}

data/.gitignore

@@ -0,0 +1,2 @@
+.rspec_status
+Gemfile.lock

data/.rspec

@@ -0,0 +1,4 @@
+--format documentation
+--color
+--require spec_helper
+--order random

data/.rubocop.yml

@@ -0,0 +1,40 @@
+AllCops:
+  NewCops: enable
+  TargetRubyVersion: 3.4
+
+Style/Documentation:
+  Enabled: false
+
+Naming/PredicateMethod:
+  Enabled: false
+
+Metrics/ClassLength:
+  Max: 150
+
+Metrics/MethodLength:
+  Max: 25
+
+Metrics/AbcSize:
+  Max: 25
+
+Metrics/ParameterLists:
+  Max: 8
+  MaxOptionalParameters: 8
+
+Layout/HashAlignment:
+  EnforcedColonStyle: table
+  EnforcedHashRocketStyle: table
+
+Metrics/BlockLength:
+  Exclude:
+    - 'spec/**/*'
+
+Style/FrozenStringLiteralComment:
+  Enabled: true
+
+Style/StringLiterals:
+  EnforcedStyle: single_quotes
+
+Style/OneClassPerFile:
+  Exclude:
+    - 'spec/spec_helper.rb'

data/CLAUDE.md

@@ -0,0 +1,73 @@
+# lex-cognitive-compression
+
+**Level 3 Documentation**
+- **Parent**: `/Users/miverso2/rubymine/legion/extensions-agentic/CLAUDE.md`
+- **Grandparent**: `/Users/miverso2/rubymine/legion/CLAUDE.md`
+
+## Purpose
+
+Models information compression and abstraction as knowledge moves through memory tiers. Raw episodic content is compressed as it ages; fidelity decreases with compression, but storage cost drops. Abstraction groups chunks into higher-level representations. Mirrors the psychological phenomenon where detailed memories fade to gist-level representations over time.
+
+## Gem Info
+
+- **Gem name**: `lex-cognitive-compression`
+- **Version**: `0.1.0`
+- **Module**: `Legion::Extensions::CognitiveCompression`
+- **Ruby**: `>= 3.4`
+- **License**: MIT
+
+## File Structure
+
+```
+lib/legion/extensions/cognitive_compression/
+  cognitive_compression.rb
+  version.rb
+  client.rb
+  helpers/
+    constants.rb
+    compression_engine.rb
+    information_chunk.rb
+  runners/
+    cognitive_compression.rb
+```
+
+## Key Constants
+
+From `helpers/constants.rb`:
+
+- `CHUNK_TYPES` — `%i[episodic semantic procedural sensory emotional abstract relational]`
+- `MAX_CHUNKS` = `500`, `MAX_ABSTRACTIONS` = `200`
+- `DEFAULT_COMPRESSION_RATIO` = `0.5`, `COMPRESSION_RATE` = `0.1`
+- `FIDELITY_LOSS_RATE` = `0.02`, `MIN_FIDELITY` = `0.1`
+- `COMPRESSION_LABELS` — `0.8+` = `:highly_compressed`, `0.6` = `:compressed`, `0.4` = `:moderate`, `0.2` = `:detailed`, below = `:raw`
+- `FIDELITY_LABELS` — `0.8+` = `:pristine`, `0.6` = `:faithful`, `0.4` = `:approximate`, `0.2` = `:lossy`, below = `:degraded`
+
+## Runners
+
+All methods in `Runners::CognitiveCompression`:
+
+- `store_chunk(label:, chunk_type: :semantic, original_size: 1.0)` — stores a new chunk at default compression ratio
+- `compress_chunk(chunk_id:, amount: COMPRESSION_RATE)` — increases compression, decreasing fidelity
+- `decompress_chunk(chunk_id:, amount: COMPRESSION_RATE)` — decreases compression, partially restoring fidelity
+- `abstract_chunks(chunk_ids:, abstraction_label:)` — combines multiple chunks into a single higher-level abstraction
+- `compress_all(amount: COMPRESSION_RATE)` — applies compression to all chunks; intended as periodic runner
+- `average_fidelity` — mean fidelity across all stored chunks
+- `overall_compression_ratio` — mean compression ratio
+- `compression_report` — full report: chunk counts, fidelity, compression distribution, abstraction count
+
+## Helpers
+
+- `CompressionEngine` — manages `@chunks` and `@abstractions`. `abstract_chunks` creates a new `InformationChunk` representing the merged abstraction, linking back to source chunk IDs.
+- `InformationChunk` — has `chunk_type`, `original_size`, `compression_ratio`, `fidelity`. `compress!(amount)` increases ratio and decreases fidelity. `decompress!(amount)` reverses compression but fidelity does not fully recover (capped at original minus `FIDELITY_LOSS_RATE * compressions`).
+
+## Integration Points
+
+- `lex-memory` handles long-term trace storage with tier migration; compression models what happens to fidelity as traces move from `episodic` to `semantic` tier — detail is lost, gist is retained.
+- `lex-cognitive-chunking` creates named groups; compression models what happens to those groups over time as they age.
+- `compress_all` is the natural periodic maintenance runner — called each decay cycle alongside `lex-memory`'s `decay_cycle`.
+
+## Development Notes
+
+- Decompression is lossy: `fidelity` does not return to 1.0 after repeated compress/decompress cycles. `MIN_FIDELITY = 0.1` is a floor; once reached, no further fidelity loss occurs.
+- `abstract_chunks` returns `nil` if no valid source chunks are found — the runner wraps this with `{ success: false, error: 'no valid chunks' }`.
+- `chunk_type: :episodic` represents autobiographical/event memory (high initial fidelity, fast compression target). `chunk_type: :semantic` represents general knowledge (moderate compression acceptable).

data/Gemfile

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+source 'https://rubygems.org'
+
+gemspec
+
+group :development, :test do
+  gem 'rspec', '~> 3.13'
+  gem 'rubocop', '~> 1.75'
+  gem 'rubocop-rspec'
+end
+
+gem 'legion-gaia', path: '../../legion-gaia'

data/Gemfile.lock

@@ -0,0 +1,78 @@
+PATH
+  remote: .
+  specs:
+    lex-cognitive-compression (0.1.0)
+
+GEM
+  remote: https://rubygems.org/
+  specs:
+    addressable (2.8.9)
+      public_suffix (>= 2.0.2, < 8.0)
+    ast (2.4.3)
+    bigdecimal (4.0.1)
+    diff-lcs (1.6.2)
+    json (2.19.1)
+    json-schema (6.2.0)
+      addressable (~> 2.8)
+      bigdecimal (>= 3.1, < 5)
+    language_server-protocol (3.17.0.5)
+    lint_roller (1.1.0)
+    mcp (0.8.0)
+      json-schema (>= 4.1)
+    parallel (1.27.0)
+    parser (3.3.10.2)
+      ast (~> 2.4.1)
+      racc
+    prism (1.9.0)
+    public_suffix (7.0.5)
+    racc (1.8.1)
+    rainbow (3.1.1)
+    regexp_parser (2.11.3)
+    rspec (3.13.2)
+      rspec-core (~> 3.13.0)
+      rspec-expectations (~> 3.13.0)
+      rspec-mocks (~> 3.13.0)
+    rspec-core (3.13.6)
+      rspec-support (~> 3.13.0)
+    rspec-expectations (3.13.5)
+      diff-lcs (>= 1.2.0, < 2.0)
+      rspec-support (~> 3.13.0)
+    rspec-mocks (3.13.8)
+      diff-lcs (>= 1.2.0, < 2.0)
+      rspec-support (~> 3.13.0)
+    rspec-support (3.13.7)
+    rubocop (1.85.1)
+      json (~> 2.3)
+      language_server-protocol (~> 3.17.0.2)
+      lint_roller (~> 1.1.0)
+      mcp (~> 0.6)
+      parallel (~> 1.10)
+      parser (>= 3.3.0.2)
+      rainbow (>= 2.2.2, < 4.0)
+      regexp_parser (>= 2.9.3, < 3.0)
+      rubocop-ast (>= 1.49.0, < 2.0)
+      ruby-progressbar (~> 1.7)
+      unicode-display_width (>= 2.4.0, < 4.0)
+    rubocop-ast (1.49.1)
+      parser (>= 3.3.7.2)
+      prism (~> 1.7)
+    rubocop-rspec (3.9.0)
+      lint_roller (~> 1.1)
+      rubocop (~> 1.81)
+    ruby-progressbar (1.13.0)
+    unicode-display_width (3.2.0)
+      unicode-emoji (~> 4.1)
+    unicode-emoji (4.2.0)
+
+PLATFORMS
+  arm64-darwin-25
+  ruby
+
+DEPENDENCIES
+  lex-cognitive-compression!
+  rspec (~> 3.13)
+  rubocop (~> 1.75)
+  rubocop-rspec
+
+BUNDLED WITH
+   2.6.9

data/README.md

@@ -0,0 +1,45 @@
+# lex-cognitive-compression
+
+Cognitive information compression for LegionIO. Models information compression and abstraction as knowledge moves through memory tiers.
+
+## What It Does
+
+Raw memories start with high fidelity but take full storage. Over time they compress — detail fades, gist remains. This extension models that process: chunks are stored at a compression ratio, can be incrementally compressed (losing fidelity), and can be abstracted into higher-level representations. Decompression is lossy — you cannot fully recover the original fidelity once lost.
+
+Seven chunk types are supported: episodic, semantic, procedural, sensory, emotional, abstract, and relational. Each has different natural compression targets appropriate to its type.
+
+## Usage
+
+```ruby
+client = Legion::Extensions::CognitiveCompression::Client.new
+
+chunk = client.store_chunk(
+  label: 'meeting notes 2026-03-14',
+  chunk_type: :episodic,
+  original_size: 1.0
+)
+
+client.compress_chunk(chunk_id: chunk[:chunk][:id], amount: 0.2)
+client.average_fidelity
+# => { fidelity: 0.96 }  # small fidelity loss from one compression step
+
+# Abstract multiple chunks into a summary
+client.abstract_chunks(
+  chunk_ids: [chunk[:chunk][:id]],
+  abstraction_label: 'Q1 meeting themes'
+)
+
+client.compression_report
+```
+
+## Development
+
+```bash
+bundle install
+bundle exec rspec
+bundle exec rubocop
+```
+
+## License
+
+MIT

data/lex-cognitive-compression.gemspec

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+require_relative 'lib/legion/extensions/cognitive_compression/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = 'lex-cognitive-compression'
+  spec.version       = Legion::Extensions::CognitiveCompression::VERSION
+  spec.authors       = ['Esity']
+  spec.email         = ['matthewdiverson@gmail.com']
+
+  spec.summary       = 'Cognitive information compression for LegionIO'
+  spec.description   = 'Models information compression and abstraction as knowledge moves through memory tiers'
+  spec.homepage      = 'https://github.com/LegionIO/lex-cognitive-compression'
+  spec.license       = 'MIT'
+  spec.required_ruby_version = '>= 3.4'
+
+  spec.metadata['homepage_uri']        = spec.homepage
+  spec.metadata['source_code_uri']     = spec.homepage
+  spec.metadata['documentation_uri']   = "#{spec.homepage}/blob/main/README.md"
+  spec.metadata['changelog_uri']       = "#{spec.homepage}/blob/main/CHANGELOG.md"
+  spec.metadata['bug_tracker_uri']     = "#{spec.homepage}/issues"
+  spec.metadata['rubygems_mfa_required'] = 'true'
+
+  spec.files = Dir.chdir(__dir__) do
+    `git ls-files -z`.split("\x0").reject do |f|
+      f.match(%r{\A(?:test|spec|features)/})
+    end
+  end
+  spec.require_paths = ['lib']
+  spec.add_development_dependency 'legion-gaia'
+end

data/lib/legion/extensions/cognitive_compression/client.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module CognitiveCompression
+      class Client
+        include Runners::CognitiveCompression
+      end
+    end
+  end
+end

data/lib/legion/extensions/cognitive_compression/helpers/compression_engine.rb

@@ -0,0 +1,141 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module CognitiveCompression
+      module Helpers
+        class CompressionEngine
+          include Constants
+
+          def initialize
+            @chunks       = {}
+            @abstractions = {}
+          end
+
+          def store_chunk(label:, chunk_type: :semantic, original_size: 1.0)
+            prune_chunks_if_needed
+            chunk = InformationChunk.new(label: label, chunk_type: chunk_type,
+                                         original_size: original_size)
+            @chunks[chunk.id] = chunk
+            chunk
+          end
+
+          def compress_chunk(chunk_id:, amount: COMPRESSION_RATE)
+            chunk = @chunks[chunk_id]
+            return nil unless chunk
+
+            chunk.compress!(amount: amount)
+          end
+
+          def decompress_chunk(chunk_id:, amount: COMPRESSION_RATE)
+            chunk = @chunks[chunk_id]
+            return nil unless chunk
+
+            chunk.decompress!(amount: amount)
+          end
+
+          def abstract_chunks(chunk_ids:, abstraction_label:)
+            prune_abstractions_if_needed
+            chunks = chunk_ids.filter_map { |id| @chunks[id] }
+            return nil if chunks.empty?
+
+            combined_size = chunks.sum(&:compressed_size)
+            abstraction = InformationChunk.new(
+              label:         abstraction_label,
+              chunk_type:    :abstract,
+              original_size: combined_size
+            )
+            avg_fidelity = (chunks.sum(&:fidelity) / chunks.size).round(10)
+            abstraction.compress!(amount: DEFAULT_COMPRESSION_RATIO)
+            @abstractions[abstraction.id] = {
+              chunk:      abstraction,
+              source_ids: chunk_ids,
+              fidelity:   avg_fidelity
+            }
+            abstraction
+          end
+
+          def compress_all(amount: COMPRESSION_RATE)
+            @chunks.each_value { |c| c.compress!(amount: amount) }
+            @chunks.size
+          end
+
+          def chunks_by_type(chunk_type:)
+            ct = chunk_type.to_sym
+            @chunks.values.select { |c| c.chunk_type == ct }
+          end
+
+          def highly_compressed_chunks
+            @chunks.values.select(&:highly_compressed?)
+          end
+
+          def average_compression_ratio
+            return 0.0 if @chunks.empty?
+
+            ratios = @chunks.values.map(&:compression_ratio)
+            (ratios.sum / ratios.size).round(10)
+          end
+
+          def average_fidelity
+            return 1.0 if @chunks.empty?
+
+            fids = @chunks.values.map(&:fidelity)
+            (fids.sum / fids.size).round(10)
+          end
+
+          def total_original_size
+            @chunks.values.sum(&:original_size).round(10)
+          end
+
+          def total_compressed_size
+            @chunks.values.sum(&:compressed_size).round(10)
+          end
+
+          def overall_compression_ratio
+            return 0.0 if total_original_size.zero?
+
+            (1.0 - (total_compressed_size / total_original_size)).clamp(0.0, 1.0).round(10)
+          end
+
+          def compression_report
+            {
+              total_chunks:              @chunks.size,
+              total_abstractions:        @abstractions.size,
+              average_compression_ratio: average_compression_ratio,
+              overall_compression_ratio: overall_compression_ratio,
+              average_fidelity:          average_fidelity,
+              total_original_size:       total_original_size,
+              total_compressed_size:     total_compressed_size,
+              highly_compressed_count:   highly_compressed_chunks.size
+            }
+          end
+
+          def to_h
+            {
+              total_chunks:              @chunks.size,
+              total_abstractions:        @abstractions.size,
+              average_compression_ratio: average_compression_ratio,
+              average_fidelity:          average_fidelity
+            }
+          end
+
+          private
+
+          def prune_chunks_if_needed
+            return if @chunks.size < MAX_CHUNKS
+
+            oldest = @chunks.values.min_by(&:created_at)
+            @chunks.delete(oldest.id) if oldest
+          end
+
+          def prune_abstractions_if_needed
+            return if @abstractions.size < MAX_ABSTRACTIONS
+
+            oldest_key = @abstractions.min_by { |_, v| v[:chunk].created_at }&.first
+            @abstractions.delete(oldest_key) if oldest_key
+          end
+        end
+      end
+    end
+  end
+end

data/lib/legion/extensions/cognitive_compression/helpers/constants.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module CognitiveCompression
+      module Helpers
+        module Constants
+          MAX_CHUNKS = 500
+          MAX_ABSTRACTIONS = 200
+
+          DEFAULT_COMPRESSION_RATIO = 0.5
+          COMPRESSION_RATE = 0.1
+          FIDELITY_LOSS_RATE = 0.02
+          MIN_FIDELITY = 0.1
+
+          COMPRESSION_LABELS = {
+            (0.8..)     => :highly_compressed,
+            (0.6...0.8) => :compressed,
+            (0.4...0.6) => :moderate,
+            (0.2...0.4) => :detailed,
+            (..0.2)     => :raw
+          }.freeze
+
+          FIDELITY_LABELS = {
+            (0.8..)     => :pristine,
+            (0.6...0.8) => :faithful,
+            (0.4...0.6) => :approximate,
+            (0.2...0.4) => :lossy,
+            (..0.2)     => :degraded
+          }.freeze
+
+          CHUNK_TYPES = %i[
+            episodic semantic procedural sensory
+            emotional abstract relational
+          ].freeze
+        end
+      end
+    end
+  end
+end

data/lib/legion/extensions/cognitive_compression/helpers/information_chunk.rb

@@ -0,0 +1,77 @@
+# frozen_string_literal: true
+
+require 'securerandom'
+
+module Legion
+  module Extensions
+    module CognitiveCompression
+      module Helpers
+        class InformationChunk
+          include Constants
+
+          attr_reader :id, :label, :chunk_type, :original_size, :compressed_size,
+                      :fidelity, :compression_count, :created_at
+
+          def initialize(label:, chunk_type: :semantic, original_size: 1.0)
+            @id                = SecureRandom.uuid
+            @label             = label
+            @chunk_type        = chunk_type.to_sym
+            @original_size     = [original_size.to_f, 0.01].max
+            @compressed_size   = @original_size
+            @fidelity          = 1.0
+            @compression_count = 0
+            @created_at        = Time.now.utc
+          end
+
+          def compression_ratio
+            return 0.0 if @original_size.zero?
+
+            (1.0 - (@compressed_size / @original_size)).clamp(0.0, 1.0).round(10)
+          end
+
+          def compress!(amount: COMPRESSION_RATE)
+            @compressed_size = (@compressed_size * (1.0 - amount)).clamp(0.01, @original_size).round(10)
+            @fidelity = (@fidelity - FIDELITY_LOSS_RATE).clamp(MIN_FIDELITY, 1.0).round(10)
+            @compression_count += 1
+            self
+          end
+
+          def decompress!(amount: COMPRESSION_RATE)
+            @compressed_size = (@compressed_size / (1.0 - amount)).clamp(0.01, @original_size).round(10)
+            self
+          end
+
+          def highly_compressed?
+            compression_ratio >= 0.8
+          end
+
+          def compression_label
+            match = COMPRESSION_LABELS.find { |range, _| range.cover?(compression_ratio) }
+            match ? match.last : :raw
+          end
+
+          def fidelity_label
+            match = FIDELITY_LABELS.find { |range, _| range.cover?(@fidelity) }
+            match ? match.last : :degraded
+          end
+
+          def to_h
+            {
+              id:                @id,
+              label:             @label,
+              chunk_type:        @chunk_type,
+              original_size:     @original_size,
+              compressed_size:   @compressed_size,
+              compression_ratio: compression_ratio,
+              compression_label: compression_label,
+              fidelity:          @fidelity,
+              fidelity_label:    fidelity_label,
+              compression_count: @compression_count,
+              created_at:        @created_at
+            }
+          end
+        end
+      end
+    end
+  end
+end

data/lib/legion/extensions/cognitive_compression/runners/cognitive_compression.rb

@@ -0,0 +1,72 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module CognitiveCompression
+      module Runners
+        module CognitiveCompression
+          include Helpers::Constants
+
+          include Legion::Extensions::Helpers::Lex if defined?(Legion::Extensions::Helpers::Lex)
+
+          def store_chunk(label:, engine: nil, chunk_type: :semantic, original_size: 1.0, **)
+            eng = engine || default_engine
+            chunk = eng.store_chunk(label: label, chunk_type: chunk_type, original_size: original_size)
+            { success: true, chunk: chunk.to_h }
+          end
+
+          def compress_chunk(chunk_id:, engine: nil, amount: COMPRESSION_RATE, **)
+            eng = engine || default_engine
+            result = eng.compress_chunk(chunk_id: chunk_id, amount: amount)
+            return { success: false, error: 'chunk not found' } unless result
+
+            { success: true, chunk: result.to_h }
+          end
+
+          def decompress_chunk(chunk_id:, engine: nil, amount: COMPRESSION_RATE, **)
+            eng = engine || default_engine
+            result = eng.decompress_chunk(chunk_id: chunk_id, amount: amount)
+            return { success: false, error: 'chunk not found' } unless result
+
+            { success: true, chunk: result.to_h }
+          end
+
+          def abstract_chunks(chunk_ids:, abstraction_label:, engine: nil, **)
+            eng = engine || default_engine
+            result = eng.abstract_chunks(chunk_ids: chunk_ids, abstraction_label: abstraction_label)
+            return { success: false, error: 'no valid chunks' } unless result
+
+            { success: true, abstraction: result.to_h }
+          end
+
+          def compress_all(engine: nil, amount: COMPRESSION_RATE, **)
+            eng = engine || default_engine
+            count = eng.compress_all(amount: amount)
+            { success: true, compressed_count: count }
+          end
+
+          def average_fidelity(engine: nil, **)
+            eng = engine || default_engine
+            { success: true, fidelity: eng.average_fidelity }
+          end
+
+          def overall_compression_ratio(engine: nil, **)
+            eng = engine || default_engine
+            { success: true, ratio: eng.overall_compression_ratio }
+          end
+
+          def compression_report(engine: nil, **)
+            eng = engine || default_engine
+            { success: true, report: eng.compression_report }
+          end
+
+          private
+
+          def default_engine
+            @default_engine ||= Helpers::CompressionEngine.new
+          end
+        end
+      end
+    end
+  end
+end

data/lib/legion/extensions/cognitive_compression/version.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module CognitiveCompression
+      VERSION = '0.1.0'
+    end
+  end
+end

data/lib/legion/extensions/cognitive_compression.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+require_relative 'cognitive_compression/version'
+require_relative 'cognitive_compression/helpers/constants'
+require_relative 'cognitive_compression/helpers/information_chunk'
+require_relative 'cognitive_compression/helpers/compression_engine'
+require_relative 'cognitive_compression/runners/cognitive_compression'
+require_relative 'cognitive_compression/client'
+
+module Legion
+  module Extensions
+    module CognitiveCompression
+    end
+  end
+end

metadata

@@ -0,0 +1,77 @@
+--- !ruby/object:Gem::Specification
+name: lex-cognitive-compression
+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: Models information compression and abstraction as knowledge moves through
+  memory tiers
+email:
+- matthewdiverson@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".github/workflows/ci.yml"
+- ".gitignore"
+- ".rspec"
+- ".rubocop.yml"
+- CLAUDE.md
+- Gemfile
+- Gemfile.lock
+- README.md
+- lex-cognitive-compression.gemspec
+- lib/legion/extensions/cognitive_compression.rb
+- lib/legion/extensions/cognitive_compression/client.rb
+- lib/legion/extensions/cognitive_compression/helpers/compression_engine.rb
+- lib/legion/extensions/cognitive_compression/helpers/constants.rb
+- lib/legion/extensions/cognitive_compression/helpers/information_chunk.rb
+- lib/legion/extensions/cognitive_compression/runners/cognitive_compression.rb
+- lib/legion/extensions/cognitive_compression/version.rb
+homepage: https://github.com/LegionIO/lex-cognitive-compression
+licenses:
+- MIT
+metadata:
+  homepage_uri: https://github.com/LegionIO/lex-cognitive-compression
+  source_code_uri: https://github.com/LegionIO/lex-cognitive-compression
+  documentation_uri: https://github.com/LegionIO/lex-cognitive-compression/blob/main/README.md
+  changelog_uri: https://github.com/LegionIO/lex-cognitive-compression/blob/main/CHANGELOG.md
+  bug_tracker_uri: https://github.com/LegionIO/lex-cognitive-compression/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: Cognitive information compression for LegionIO
+test_files: []