lex-cognitive-mycelium 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 9bb3fcb205f37ec89847ee5b27fc927063cde42b67e1c5c300504f8494b40af4
+  data.tar.gz: 40a70575d4362fd4a29c649228082e4e9fd27253f6e17726f4cfbb594afc208a
+SHA512:
+  metadata.gz: 0615f7d3098282b7b4147e2c8509d4528a182173913f77553ef787fb473cf5482d90b66a68c0cb3d76ebb819f43fbe7d564d6457ec62dc163c696cc1d61ee8cd
+  data.tar.gz: d4106d376468094d6b86abbeed50b74444f87660db27912a350be75369f9e0db2aa294581d51cd90c93cb802531065f1b8b9ba6064915597eb9ce044770cb77f

data/CLAUDE.md

@@ -0,0 +1,101 @@
+# lex-cognitive-mycelium
+
+**Level 3 Leaf Documentation**
+- **Parent**: `/Users/miverso2/rubymine/legion/extensions-agentic/CLAUDE.md`
+
+## Purpose
+
+Fungal mycelium network metaphor for distributed knowledge. Nodes (knowledge clusters, insight nodes, memory nodes, etc.) are connected by hyphae (connections with nutrient types and strength states). Nutrients transfer through hyphae at an efficiency rate. When a node accumulates sufficient nutrients it becomes ready to fruit, producing a fruiting body (insight, breakthrough, synthesis, etc.). Models how knowledge fragments strengthen through use, dormant connections exist, and concentrated knowledge produces emergent insights.
+
+## Gem Info
+
+- **Gem name**: `lex-cognitive-mycelium`
+- **Module**: `Legion::Extensions::CognitiveMycelium`
+- **Version**: `0.1.0`
+- **Ruby**: `>= 3.4`
+- **License**: MIT
+
+## File Structure
+
+```
+lib/legion/extensions/cognitive_mycelium/
+  version.rb
+  client.rb
+  helpers/
+    constants.rb
+    mycelial_node.rb
+    hypha.rb
+  runners/
+    cognitive_mycelium.rb
+```
+
+## Key Constants
+
+| Constant | Value | Purpose |
+|---|---|---|
+| `MAX_NODES` | `200` | Per-engine node capacity |
+| `MAX_HYPHAE` | `500` | Per-engine hypha capacity |
+| `MAX_FRUITING_BODIES` | `100` | Fruiting body ring buffer size |
+| `NUTRIENT_DECAY` | `0.03` | Per-cycle node nutrient decay |
+| `TRANSFER_EFFICIENCY` | `0.8` | Fraction of nutrients that transfer through a hypha |
+| `FRUITING_THRESHOLD` | `0.7` | Nutrient level at which a node can fruit |
+| `NODE_TYPES` | `%i[knowledge_cluster insight_node memory_node skill_node pattern_node creative_node]` | Valid types |
+| `NUTRIENT_TYPES` | `%i[information energy pattern association context emotion]` | Valid nutrient categories |
+| `HYPHA_STATES` | `%i[growing mature dormant decaying]` | Hypha lifecycle states |
+| `FRUITING_TYPES` | `%i[insight breakthrough synthesis connection revelation]` | Fruiting body types |
+| `NETWORK_HEALTH_LABELS` | range hash | Network health classification |
+
+## Helpers
+
+### `Helpers::MycelialNode`
+Individual network node. Has `id`, `label`, `node_type`, `domain`, `nutrient_level`, `connections` (hypha IDs), and `fruiting_bodies` (array).
+
+- `absorb!(amount, nutrient_type:)` — increases nutrient level (clamped to 1.0)
+- `deplete!(amount)` — decreases nutrient level (floor 0)
+- `fruiting_ready?` — `nutrient_level >= FRUITING_THRESHOLD`
+- `starving?` — `nutrient_level <= 0.1`
+
+### `Helpers::Hypha`
+Connection between two nodes. Has `id`, `from_node_id`, `to_node_id`, `nutrient_type`, `strength`, and `state`.
+
+- `reinforce!(amount)` — increases strength; transitions to `:mature` when >= 0.6
+- `decay!(amount)` — decreases strength; transitions to `:dormant` when < 0.4, `:decaying` when < 0.2
+- `transfer_capacity` — `strength * TRANSFER_EFFICIENCY` (actual nutrients transferred)
+- `active?` — state is `:growing` or `:mature`
+
+### Engine (inline in runner/client)
+- `create_node(label:, node_type:, domain:)` → node
+- `connect(from_id:, to_id:, nutrient_type:)` → hypha
+- `transfer_nutrients(hypha_id:, amount:)` → transfer result
+- `fruit(node_id:, fruiting_type:)` → fruiting body or `:not_ready`
+- Network health calculations
+
+## Runners
+
+Module: `Runners::CognitiveMycelium`
+
+| Runner Method | Description |
+|---|---|
+| `create_node(label:, node_type:, domain:)` | Register a new node |
+| `connect(from_id:, to_id:, nutrient_type:)` | Create a hypha between nodes |
+| `transfer_nutrients(hypha_id:, amount:)` | Transfer nutrients through a hypha |
+| `fruit(node_id:, fruiting_type:)` | Produce a fruiting body from a ready node |
+| `network_status` | Full network health report |
+
+All runners return `{success: true/false, ...}` hashes.
+
+## Integration Points
+
+- `lex-memory`: mycelial nodes parallel memory traces; hyphae parallel Hebbian links
+- `lex-dream` `association_walk` phase: walk the mycelium network to find nutrient-rich clusters
+- Fruiting bodies (insights) can be injected into `lex-memory` as high-confidence semantic traces
+- Nutrient transfer models information propagation through `lex-mesh` between agents
+- `TRANSFER_EFFICIENCY = 0.8` means each hop loses 20% — models signal degradation across hops
+
+## Development Notes
+
+- `Client` instantiates the engine (memoized as `@default_engine`)
+- Hypha state transitions are: `growing` → `mature` (reinforce to >= 0.6) → `dormant` (decay < 0.4) → `decaying` (decay < 0.2)
+- `fruit` requires `fruiting_ready?` to return true; otherwise returns `{success: false, error: :not_ready}`
+- `MAX_FRUITING_BODIES = 100` is a ring buffer — oldest fruiting bodies are dropped when full
+- `NUTRIENT_DECAY = 0.03` per cycle means a fully charged node (1.0) reaches `FRUITING_THRESHOLD` (0.7) floor in ~10 cycles without reinforcement

data/README.md

@@ -0,0 +1,50 @@
+# lex-cognitive-mycelium
+
+Fungal mycelium network model for LegionIO cognitive agents. Nodes hold nutrients; hyphae transfer nutrients between nodes at an efficiency rate. When a node accumulates enough nutrients it can fruit, producing an emergent insight or breakthrough.
+
+## What It Does
+
+- Six node types: `knowledge_cluster`, `insight_node`, `memory_node`, `skill_node`, `pattern_node`, `creative_node`
+- Six nutrient types: `information`, `energy`, `pattern`, `association`, `context`, `emotion`
+- Hyphae have states: `growing`, `mature`, `dormant`, `decaying`
+- Nutrient transfer efficiency: 80% per hop (configurable)
+- Fruiting threshold: 0.7 nutrient level triggers readiness
+- Five fruiting body types: `insight`, `breakthrough`, `synthesis`, `connection`, `revelation`
+- Network health tracking across all nodes and connections
+
+## Usage
+
+```ruby
+# Create nodes
+a = runner.create_node(label: 'pattern_library', node_type: :knowledge_cluster, domain: :architecture)
+b = runner.create_node(label: 'current_problem',  node_type: :insight_node, domain: :architecture)
+
+# Connect them
+h = runner.connect(from_id: a[:node][:id], to_id: b[:node][:id], nutrient_type: :pattern)
+
+# Transfer nutrients
+runner.transfer_nutrients(hypha_id: h[:hypha][:id], amount: 0.5)
+# => { success: true, transferred: 0.4, to_node_level: 0.4, ... }
+
+# Keep feeding until ready
+# ... repeat transfers ...
+
+# Fruit when ready
+runner.fruit(node_id: b[:node][:id], fruiting_type: :insight)
+# => { success: true, fruiting_body: { type: :insight, content: '...', ... } }
+
+# Network status
+runner.network_status
+```
+
+## Development
+
+```bash
+bundle install
+bundle exec rspec
+bundle exec rubocop
+```
+
+## License
+
+MIT

data/lex-cognitive-mycelium.gemspec

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+require_relative 'lib/legion/extensions/cognitive_mycelium/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = 'lex-cognitive-mycelium'
+  spec.version       = Legion::Extensions::CognitiveMycelium::VERSION
+  spec.authors       = ['Esity']
+  spec.email         = ['matthewdiverson@gmail.com']
+  spec.license       = 'MIT'
+
+  spec.summary       = 'Cognitive mycelium LEX — underground knowledge network ' \
+                       'connecting disparate cognitive domains'
+  spec.description   = 'Models a mycelial network beneath conscious awareness: ' \
+                       'hyphae connect disparate knowledge domains, nutrients ' \
+                       '(insights) flow through the network, and fruiting bodies ' \
+                       '(creative breakthroughs) emerge at the surface.'
+  spec.homepage      = 'https://github.com/LegionIO/lex-cognitive-mycelium'
+
+  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}#readme"
+  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.start_with?('spec/', '.', 'Gemfile')
+    end
+  end
+  spec.require_paths = ['lib']
+  spec.add_development_dependency 'legion-gaia'
+end

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

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module CognitiveMycelium
+      class Client
+        include Runners::CognitiveMycelium
+
+        def initialize(engine: nil)
+          @default_engine = engine || Helpers::MyceliumEngine.new
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module CognitiveMycelium
+      module Helpers
+        module Constants
+          MAX_NODES           = 200
+          MAX_HYPHAE          = 500
+          MAX_FRUITING_BODIES = 100
+          NUTRIENT_DECAY      = 0.03
+          TRANSFER_EFFICIENCY = 0.8
+          FRUITING_THRESHOLD  = 0.7
+
+          NODE_TYPES = %i[
+            knowledge_cluster insight_node memory_node
+            skill_node pattern_node creative_node
+          ].freeze
+
+          NUTRIENT_TYPES = %i[
+            information experience emotional_energy
+            novelty pattern_recognition creative_potential
+          ].freeze
+
+          HYPHA_STATES = %i[growing mature dormant decaying].freeze
+
+          FRUITING_TYPES = %i[
+            insight breakthrough connection analogy
+            synthesis innovation
+          ].freeze
+
+          NETWORK_HEALTH_LABELS = [
+            [0.8..1.0, :thriving],
+            [0.6..0.8, :healthy],
+            [0.4..0.6, :stable],
+            [0.2..0.4, :stressed],
+            [0.0..0.2, :depleted]
+          ].freeze
+
+          def self.label_for(table, value)
+            table.each { |range, label| return label if range.cover?(value) }
+            table.last.last
+          end
+        end
+      end
+    end
+  end
+end

data/lib/legion/extensions/cognitive_mycelium/helpers/fruiting_body.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module CognitiveMycelium
+      module Helpers
+        class FruitingBody
+          attr_reader :id, :fruiting_type, :source_node_id,
+                      :content, :potency, :emerged_at
+
+          def initialize(fruiting_type:, source_node_id:,
+                         content:, potency: 0.5)
+            validate_type!(fruiting_type)
+            @id             = SecureRandom.uuid
+            @fruiting_type  = fruiting_type.to_sym
+            @source_node_id = source_node_id
+            @content        = content.to_s
+            @potency        = potency.to_f.clamp(0.0, 1.0).round(10)
+            @emerged_at     = Time.now.utc
+          end
+
+          def to_h
+            {
+              id:             @id,
+              fruiting_type:  @fruiting_type,
+              source_node_id: @source_node_id,
+              content:        @content,
+              potency:        @potency,
+              emerged_at:     @emerged_at
+            }
+          end
+
+          private
+
+          def validate_type!(val)
+            return if Constants::FRUITING_TYPES.include?(val.to_sym)
+
+            raise ArgumentError,
+                  "unknown fruiting type: #{val.inspect}; " \
+                  "must be one of #{Constants::FRUITING_TYPES.inspect}"
+          end
+        end
+      end
+    end
+  end
+end

data/lib/legion/extensions/cognitive_mycelium/helpers/hypha.rb

@@ -0,0 +1,72 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module CognitiveMycelium
+      module Helpers
+        class Hypha
+          attr_reader :id, :source_id, :target_id, :nutrient_type,
+                      :created_at
+          attr_accessor :strength, :state
+
+          def initialize(source_id:, target_id:, nutrient_type:,
+                         strength: 0.5)
+            validate_nutrient!(nutrient_type)
+            @id            = SecureRandom.uuid
+            @source_id     = source_id
+            @target_id     = target_id
+            @nutrient_type = nutrient_type.to_sym
+            @strength      = strength.to_f.clamp(0.0, 1.0).round(10)
+            @state         = :growing
+            @created_at    = Time.now.utc
+          end
+
+          def reinforce!(amount: 0.1)
+            @strength = (@strength + amount.abs).clamp(0.0, 1.0).round(10)
+            @state = :mature if @strength >= 0.6
+            self
+          end
+
+          def decay!(rate: Constants::NUTRIENT_DECAY)
+            @strength = (@strength - rate.abs).clamp(0.0, 1.0).round(10)
+            @state = :decaying if @strength < 0.2
+            @state = :dormant if @strength < 0.4 && @state == :mature
+            self
+          end
+
+          def transfer_capacity
+            (@strength * Constants::TRANSFER_EFFICIENCY).round(10)
+          end
+
+          def active?
+            %i[growing mature].include?(@state)
+          end
+
+          def to_h
+            {
+              id:                @id,
+              source_id:         @source_id,
+              target_id:         @target_id,
+              nutrient_type:     @nutrient_type,
+              strength:          @strength,
+              state:             @state,
+              transfer_capacity: transfer_capacity,
+              active:            active?,
+              created_at:        @created_at
+            }
+          end
+
+          private
+
+          def validate_nutrient!(val)
+            return if Constants::NUTRIENT_TYPES.include?(val.to_sym)
+
+            raise ArgumentError,
+                  "unknown nutrient type: #{val.inspect}; " \
+                  "must be one of #{Constants::NUTRIENT_TYPES.inspect}"
+          end
+        end
+      end
+    end
+  end
+end

data/lib/legion/extensions/cognitive_mycelium/helpers/mycelial_node.rb

@@ -0,0 +1,68 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module CognitiveMycelium
+      module Helpers
+        class MycelialNode
+          attr_reader :id, :node_type, :domain, :content, :created_at
+          attr_accessor :nutrient_level, :connections_count
+
+          def initialize(node_type:, domain:, content:,
+                         nutrient_level: 0.5)
+            validate_type!(node_type)
+            @id                = SecureRandom.uuid
+            @node_type         = node_type.to_sym
+            @domain            = domain.to_sym
+            @content           = content.to_s
+            @nutrient_level    = nutrient_level.to_f.clamp(0.0, 1.0).round(10)
+            @connections_count = 0
+            @created_at        = Time.now.utc
+          end
+
+          def absorb!(amount)
+            @nutrient_level = (@nutrient_level + amount.abs).clamp(0.0, 1.0).round(10)
+            self
+          end
+
+          def deplete!(amount)
+            @nutrient_level = (@nutrient_level - amount.abs).clamp(0.0, 1.0).round(10)
+            self
+          end
+
+          def fruiting_ready?
+            @nutrient_level >= Constants::FRUITING_THRESHOLD
+          end
+
+          def starving?
+            @nutrient_level < 0.1
+          end
+
+          def to_h
+            {
+              id:                @id,
+              node_type:         @node_type,
+              domain:            @domain,
+              content:           @content,
+              nutrient_level:    @nutrient_level,
+              connections_count: @connections_count,
+              fruiting_ready:    fruiting_ready?,
+              starving:          starving?,
+              created_at:        @created_at
+            }
+          end
+
+          private
+
+          def validate_type!(val)
+            return if Constants::NODE_TYPES.include?(val.to_sym)
+
+            raise ArgumentError,
+                  "unknown node type: #{val.inspect}; " \
+                  "must be one of #{Constants::NODE_TYPES.inspect}"
+          end
+        end
+      end
+    end
+  end
+end

data/lib/legion/extensions/cognitive_mycelium/helpers/mycelium_engine.rb

@@ -0,0 +1,147 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module CognitiveMycelium
+      module Helpers
+        class MyceliumEngine
+          def initialize
+            @nodes          = {}
+            @hyphae         = {}
+            @fruiting_bodies = {}
+          end
+
+          def create_node(node_type:, domain:, content:,
+                          nutrient_level: 0.5)
+            validate_capacity!(@nodes, Constants::MAX_NODES, 'nodes')
+            node = MycelialNode.new(
+              node_type: node_type, domain: domain,
+              content: content, nutrient_level: nutrient_level
+            )
+            @nodes[node.id] = node
+            node
+          end
+
+          def connect(source_id:, target_id:, nutrient_type:,
+                      strength: 0.5)
+            validate_capacity!(@hyphae, Constants::MAX_HYPHAE, 'hyphae')
+            fetch_node!(source_id)
+            fetch_node!(target_id)
+            hypha = Hypha.new(
+              source_id: source_id, target_id: target_id,
+              nutrient_type: nutrient_type, strength: strength
+            )
+            @hyphae[hypha.id] = hypha
+            increment_connections(source_id, target_id)
+            hypha
+          end
+
+          def transfer_nutrients(hypha_id:)
+            hypha  = fetch_hypha!(hypha_id)
+            source = fetch_node!(hypha.source_id)
+            target = fetch_node!(hypha.target_id)
+            amount = [hypha.transfer_capacity, source.nutrient_level].min
+            source.deplete!(amount)
+            target.absorb!(amount)
+            { transferred: amount, source: source.to_h, target: target.to_h }
+          end
+
+          def fruit!(node_id:, fruiting_type:, content:)
+            validate_capacity!(@fruiting_bodies,
+                               Constants::MAX_FRUITING_BODIES, 'fruiting bodies')
+            node = fetch_node!(node_id)
+            raise ArgumentError, 'node not ready for fruiting' unless node.fruiting_ready?
+
+            body = FruitingBody.new(
+              fruiting_type: fruiting_type, source_node_id: node_id,
+              content: content, potency: node.nutrient_level
+            )
+            node.deplete!(0.3)
+            @fruiting_bodies[body.id] = body
+            body
+          end
+
+          def decay_network!(rate: Constants::NUTRIENT_DECAY)
+            @hyphae.each_value { |h| h.decay!(rate: rate) }
+            @nodes.each_value { |n| n.deplete!(rate * 0.5) }
+            prune_dead!
+            { nodes: @nodes.size, hyphae: @hyphae.size }
+          end
+
+          def all_nodes
+            @nodes.values
+          end
+
+          def all_hyphae
+            @hyphae.values
+          end
+
+          def all_fruiting_bodies
+            @fruiting_bodies.values
+          end
+
+          def connections_for(node_id)
+            @hyphae.values.select do |h|
+              h.source_id == node_id || h.target_id == node_id
+            end
+          end
+
+          def network_report
+            {
+              total_nodes:    @nodes.size,
+              total_hyphae:   @hyphae.size,
+              total_fruiting: @fruiting_bodies.size,
+              active_hyphae:  @hyphae.values.count(&:active?),
+              avg_nutrient:   avg_field(@nodes, :nutrient_level),
+              avg_strength:   avg_field(@hyphae, :strength),
+              fruiting_ready: @nodes.values.count(&:fruiting_ready?),
+              starving_nodes: @nodes.values.count(&:starving?),
+              network_health: network_health_label
+            }
+          end
+
+          private
+
+          def fetch_node!(id)
+            @nodes.fetch(id) do
+              raise ArgumentError, "node not found: #{id.inspect}"
+            end
+          end
+
+          def fetch_hypha!(id)
+            @hyphae.fetch(id) do
+              raise ArgumentError, "hypha not found: #{id.inspect}"
+            end
+          end
+
+          def validate_capacity!(coll, max, name)
+            return if coll.size < max
+
+            raise ArgumentError,
+                  "#{name} capacity reached (max #{max})"
+          end
+
+          def increment_connections(source_id, target_id)
+            @nodes[source_id].connections_count += 1
+            @nodes[target_id].connections_count += 1
+          end
+
+          def prune_dead!
+            @hyphae.delete_if { |_, h| h.strength <= 0.0 }
+          end
+
+          def avg_field(coll, field)
+            return 0.0 if coll.empty?
+
+            (coll.values.sum(&field) / coll.size).round(10)
+          end
+
+          def network_health_label
+            avg = avg_field(@nodes, :nutrient_level)
+            Constants.label_for(Constants::NETWORK_HEALTH_LABELS, avg)
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,69 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module CognitiveMycelium
+      module Runners
+        module CognitiveMycelium
+          extend self
+
+          def create_node(node_type:, domain:, content:,
+                          nutrient_level: 0.5, engine: nil, **)
+            eng  = resolve_engine(engine)
+            node = eng.create_node(node_type: node_type, domain: domain,
+                                   content: content,
+                                   nutrient_level: nutrient_level)
+            { success: true, node: node.to_h }
+          rescue ArgumentError => e
+            { success: false, error: e.message }
+          end
+
+          def connect(source_id:, target_id:, nutrient_type:,
+                      strength: 0.5, engine: nil, **)
+            eng   = resolve_engine(engine)
+            hypha = eng.connect(source_id: source_id, target_id: target_id,
+                                nutrient_type: nutrient_type,
+                                strength: strength)
+            { success: true, hypha: hypha.to_h }
+          rescue ArgumentError => e
+            { success: false, error: e.message }
+          end
+
+          def transfer_nutrients(hypha_id:, engine: nil, **)
+            eng    = resolve_engine(engine)
+            result = eng.transfer_nutrients(hypha_id: hypha_id)
+            { success: true }.merge(result)
+          rescue ArgumentError => e
+            { success: false, error: e.message }
+          end
+
+          def fruit(node_id:, fruiting_type:, content:, engine: nil, **)
+            eng  = resolve_engine(engine)
+            body = eng.fruit!(node_id: node_id, fruiting_type: fruiting_type,
+                              content: content)
+            { success: true, fruiting_body: body.to_h }
+          rescue ArgumentError => e
+            { success: false, error: e.message }
+          end
+
+          def network_status(engine: nil, **)
+            eng = resolve_engine(engine)
+            { success: true, report: eng.network_report }
+          end
+
+          include Legion::Extensions::Helpers::Lex if defined?(Legion::Extensions::Helpers::Lex)
+
+          private
+
+          def resolve_engine(engine)
+            engine || default_engine
+          end
+
+          def default_engine
+            @default_engine ||= Helpers::MyceliumEngine.new
+          end
+        end
+      end
+    end
+  end
+end

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

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

data/lib/legion/extensions/cognitive_mycelium.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+require 'securerandom'
+
+require_relative 'cognitive_mycelium/version'
+require_relative 'cognitive_mycelium/helpers/constants'
+require_relative 'cognitive_mycelium/helpers/mycelial_node'
+require_relative 'cognitive_mycelium/helpers/hypha'
+require_relative 'cognitive_mycelium/helpers/fruiting_body'
+require_relative 'cognitive_mycelium/helpers/mycelium_engine'
+require_relative 'cognitive_mycelium/runners/cognitive_mycelium'
+require_relative 'cognitive_mycelium/client'
+
+module Legion
+  module Extensions
+    module CognitiveMycelium
+      extend Legion::Extensions::Core if Legion::Extensions.const_defined? :Core
+    end
+  end
+end

metadata

@@ -0,0 +1,75 @@
+--- !ruby/object:Gem::Specification
+name: lex-cognitive-mycelium
+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 a mycelial network beneath conscious awareness: hyphae connect
+  disparate knowledge domains, nutrients (insights) flow through the network, and
+  fruiting bodies (creative breakthroughs) emerge at the surface.'
+email:
+- matthewdiverson@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- CLAUDE.md
+- README.md
+- lex-cognitive-mycelium.gemspec
+- lib/legion/extensions/cognitive_mycelium.rb
+- lib/legion/extensions/cognitive_mycelium/client.rb
+- lib/legion/extensions/cognitive_mycelium/helpers/constants.rb
+- lib/legion/extensions/cognitive_mycelium/helpers/fruiting_body.rb
+- lib/legion/extensions/cognitive_mycelium/helpers/hypha.rb
+- lib/legion/extensions/cognitive_mycelium/helpers/mycelial_node.rb
+- lib/legion/extensions/cognitive_mycelium/helpers/mycelium_engine.rb
+- lib/legion/extensions/cognitive_mycelium/runners/cognitive_mycelium.rb
+- lib/legion/extensions/cognitive_mycelium/version.rb
+homepage: https://github.com/LegionIO/lex-cognitive-mycelium
+licenses:
+- MIT
+metadata:
+  homepage_uri: https://github.com/LegionIO/lex-cognitive-mycelium
+  source_code_uri: https://github.com/LegionIO/lex-cognitive-mycelium
+  documentation_uri: https://github.com/LegionIO/lex-cognitive-mycelium#readme
+  changelog_uri: https://github.com/LegionIO/lex-cognitive-mycelium/blob/main/CHANGELOG.md
+  bug_tracker_uri: https://github.com/LegionIO/lex-cognitive-mycelium/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 mycelium LEX — underground knowledge network connecting disparate
+  cognitive domains
+test_files: []