lex-mind-growth 0.1.4 → 0.1.5

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 40f7d638167956b7c52bd79a6946c7489ad677e2cf8ed0afd095530cf907ad08
-  data.tar.gz: 9054302975661892f60a91fa9d3b41eae764e8c48509d480b2242cc213b737c0
+  metadata.gz: 3749e6e3fd39af6abe591e437da33b0c159db29b6e3463bd96dfb46f17b65d47
+  data.tar.gz: c702f090f36a6279fcded74bc19fccfa16cf8149d549d2603d0d38ed8b706432
 SHA512:
-  metadata.gz: e966570dcfdf4bd5b5e0d6ff1b176772e62d0cbe77d6f25cdb88dec1afe091fbf0a77791084476f1423b93407ef3ff1f4733af8c713241ef982331faff7974c2
-  data.tar.gz: c07d864de3b898050838da167d1ec9e65424291df54af05a0628ba46821591899e84898a45f406f4edc1131c90c93bd0c4da4ff779903cde73f3db54ac2a07b7
+  metadata.gz: 5a70ad32a8ca26d122eae4d6e176d3d680f8943c08fa9c74379e3e03bbc99f1f7663b1b0abf6ecb5ef3d06f997107fd2c3d04d48ab32306f458a78419f92e39d
+  data.tar.gz: 9861dfcd32bad6bcb08b398be0a1a1fc3e3f564e2cb8d17a58cb30cdd43218d1ce1600c7d2f0af559f38c0ce5868f639e14fb59f8dc00fd6ac13b551770cb197

data/lib/legion/extensions/mind_growth/helpers/phase_allocator.rb

@@ -0,0 +1,106 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module MindGrowth
+      module Helpers
+        module PhaseAllocator
+          # Maps cognitive categories to GAIA tick phases
+          CATEGORY_PHASE_MAP = {
+            perception:    :sensory_processing,
+            attention:     :sensory_processing,
+            emotion:       :emotional_evaluation,
+            affect:        :emotional_evaluation,
+            memory:        :memory_retrieval,
+            knowledge:     :knowledge_retrieval,
+            identity:      :identity_entropy_check,
+            cognition:     :working_memory_integration,
+            reasoning:     :working_memory_integration,
+            safety:        :procedural_check,
+            defense:       :procedural_check,
+            prediction:    :prediction_engine,
+            inference:     :prediction_engine,
+            communication: :mesh_interface,
+            social:        :mesh_interface,
+            coordination:  :mesh_interface,
+            motivation:    :action_selection,
+            executive:     :action_selection,
+            learning:      :memory_consolidation,
+            consolidation: :memory_consolidation,
+            introspection: :post_tick_reflection,
+            self:          :post_tick_reflection,
+            reflection:    :post_tick_reflection
+          }.freeze
+
+          # Dream cycle phase mappings
+          DREAM_PHASE_MAP = {
+            memory:        :memory_audit,
+            association:   :association_walk,
+            conflict:      :contradiction_resolution,
+            curiosity:     :agenda_formation,
+            consolidation: :consolidation_commit,
+            knowledge:     :knowledge_promotion,
+            reflection:    :dream_reflection,
+            narrative:     :dream_narration
+          }.freeze
+
+          # Maps method name substrings to inferred GAIA phases for unknown categories
+          METHOD_INFERENCE_MAP = [
+            [%w[filter sense detect], :sensory_processing],
+            [%w[predict forecast estimate],      :prediction_engine],
+            [%w[reflect evaluate assess],        :post_tick_reflection],
+            [%w[store retrieve recall],          :memory_retrieval],
+            [%w[decide select choose],           :action_selection]
+          ].freeze
+
+          module_function
+
+          def allocate_phase(category:, runner_methods: [])
+            category_sym = category.to_s.downcase.to_sym
+
+            # Check active phases first
+            phase = CATEGORY_PHASE_MAP[category_sym]
+            return { phase: phase, cycle: :active, confidence: :high } if phase
+
+            # Try to infer from runner method names
+            inferred = infer_from_methods(runner_methods)
+            return inferred if inferred
+
+            # Default to working_memory_integration (safest catch-all)
+            { phase: :working_memory_integration, cycle: :active, confidence: :low }
+          end
+
+          def allocate_dream_phase(category:)
+            category_sym = category.to_s.downcase.to_sym
+            phase = DREAM_PHASE_MAP[category_sym]
+            return { phase: phase, cycle: :dream, confidence: :high } if phase
+
+            nil
+          end
+
+          def infer_from_methods(methods)
+            method_names = methods.map(&:to_s)
+            match = METHOD_INFERENCE_MAP.find do |keywords, _phase|
+              method_names.any? { |m| keywords.any? { |kw| m.include?(kw) } }
+            end
+            return nil unless match
+
+            { phase: match[1], cycle: :active, confidence: :medium }
+          end
+
+          def valid_phase?(phase)
+            CATEGORY_PHASE_MAP.values.include?(phase) || DREAM_PHASE_MAP.values.include?(phase)
+          end
+
+          def phases_for_category(category)
+            category_sym = category.to_s.downcase.to_sym
+            results = []
+            results << CATEGORY_PHASE_MAP[category_sym] if CATEGORY_PHASE_MAP.key?(category_sym)
+            results << DREAM_PHASE_MAP[category_sym] if DREAM_PHASE_MAP.key?(category_sym)
+            results.compact
+          end
+        end
+      end
+    end
+  end
+end

data/lib/legion/extensions/mind_growth/runners/integration_tester.rb

@@ -0,0 +1,116 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module MindGrowth
+      module Runners
+        module IntegrationTester
+          include Legion::Extensions::Helpers::Lex if Legion::Extensions.const_defined?(:Helpers) &&
+                                                      Legion::Extensions::Helpers.const_defined?(:Lex)
+
+          extend self
+
+          TICK_BUDGET_MS = 5000
+
+          def test_extension_in_tick(ext_module:, runner_module:, fn:, phase:, test_args: {}, **) # rubocop:disable Naming/MethodParameterName
+            return { success: false, reason: :gaia_not_available } unless gaia_available?
+
+            runner_class = resolve_runner_class(ext_module, runner_module)
+            return { success: false, reason: :runner_not_found } unless runner_class
+
+            # Test 1: Method exists and is callable
+            method_check = test_method_callable(runner_class, fn)
+            return method_check unless method_check[:success]
+
+            # Test 2: Method returns valid response hash
+            response_check = test_valid_response(runner_class, fn, test_args)
+            return response_check unless response_check[:success]
+
+            # Test 3: Method completes within budget
+            perf_check = test_performance(runner_class, fn, test_args)
+
+            {
+              success:         true,
+              method_callable: method_check[:success],
+              valid_response:  response_check[:success],
+              performance:     perf_check,
+              phase:           phase
+            }
+          rescue StandardError => e
+            { success: false, reason: :exception, error: e.message }
+          end
+
+          def benchmark_tick(with_extension: nil, iterations: 5, **)
+            return { success: false, reason: :gaia_not_available } unless gaia_available?
+
+            timings = iterations.times.map do
+              start = ::Process.clock_gettime(::Process::CLOCK_MONOTONIC)
+              Legion::Gaia.heartbeat if Legion::Gaia.respond_to?(:heartbeat)
+              finish = ::Process.clock_gettime(::Process::CLOCK_MONOTONIC)
+              ((finish - start) * 1000).round(2)
+            end
+
+            {
+              success:        true,
+              with_extension: with_extension,
+              iterations:     iterations,
+              avg_ms:         (timings.sum / timings.size).round(2),
+              max_ms:         timings.max,
+              min_ms:         timings.min,
+              within_budget:  timings.max <= TICK_BUDGET_MS
+            }
+          rescue StandardError => e
+            { success: false, reason: :benchmark_failed, error: e.message }
+          end
+
+          private
+
+          def gaia_available?
+            defined?(Legion::Gaia)
+          end
+
+          def resolve_runner_class(ext_module, runner_module)
+            return nil unless defined?(Legion::Gaia::PhaseWiring)
+
+            Legion::Gaia::PhaseWiring.resolve_runner_class(ext_module.to_sym, runner_module.to_sym)
+          end
+
+          def test_method_callable(runner_class, fn) # rubocop:disable Naming/MethodParameterName
+            if runner_class.method_defined?(fn) || runner_class.respond_to?(fn)
+              { success: true, method: fn }
+            else
+              { success: false, reason: :method_not_defined, method: fn }
+            end
+          end
+
+          def test_valid_response(runner_class, fn, args) # rubocop:disable Naming/MethodParameterName
+            host = Object.new.extend(runner_class)
+            result = host.send(fn, **args)
+
+            if result.is_a?(Hash)
+              { success: true, response_type: :hash, keys: result.keys }
+            elsif result.nil?
+              { success: true, response_type: :nil }
+            else
+              { success: true, response_type: result.class.name }
+            end
+          rescue StandardError => e
+            { success: false, reason: :invocation_error, error: e.message }
+          end
+
+          def test_performance(runner_class, fn, args) # rubocop:disable Naming/MethodParameterName
+            host = Object.new.extend(runner_class)
+            start = ::Process.clock_gettime(::Process::CLOCK_MONOTONIC)
+            host.send(fn, **args)
+            finish = ::Process.clock_gettime(::Process::CLOCK_MONOTONIC)
+            duration_ms = ((finish - start) * 1000).round(2)
+
+            { duration_ms: duration_ms, within_budget: duration_ms <= TICK_BUDGET_MS }
+          rescue StandardError => e
+            { duration_ms: nil, error: e.message, within_budget: false }
+          end
+        end
+      end
+    end
+  end
+end

data/lib/legion/extensions/mind_growth/runners/wirer.rb

@@ -0,0 +1,145 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module MindGrowth
+      module Runners
+        module Wirer
+          include Legion::Extensions::Helpers::Lex if Legion::Extensions.const_defined?(:Helpers) &&
+                                                      Legion::Extensions::Helpers.const_defined?(:Lex)
+
+          extend self
+
+          def analyze_fit(extension_name:, category:, runner_module: nil, runner_methods: [], **) # rubocop:disable Lint/UnusedMethodArgument
+            allocation = Helpers::PhaseAllocator.allocate_phase(
+              category:       category,
+              runner_methods: runner_methods
+            )
+
+            dream_allocation = Helpers::PhaseAllocator.allocate_dream_phase(category: category)
+
+            {
+              success:        true,
+              extension:      extension_name,
+              active_phase:   allocation,
+              dream_phase:    dream_allocation,
+              recommendation: build_recommendation(allocation, dream_allocation)
+            }
+          end
+
+          def wire_extension(extension_name:, ext_module:, runner_module:, fn:, phase:, **) # rubocop:disable Naming/MethodParameterName
+            return { success: false, reason: :gaia_not_available } unless gaia_available?
+            return { success: false, reason: :invalid_phase } unless Helpers::PhaseAllocator.valid_phase?(phase)
+
+            # Verify the runner class exists and has the method
+            runner_class = resolve_runner(ext_module: ext_module, runner_module: runner_module)
+            return { success: false, reason: :runner_not_found } unless runner_class
+
+            return { success: false, reason: :method_not_found, method: fn } unless runner_class.method_defined?(fn) || runner_class.respond_to?(fn)
+
+            # Record the wiring in our registry
+            wiring_registry[extension_name] = {
+              ext_module:    ext_module,
+              runner_module: runner_module,
+              fn:            fn,
+              phase:         phase,
+              wired_at:      Time.now,
+              enabled:       true
+            }
+
+            # Trigger GAIA rediscovery to pick up the new wiring
+            rediscover_result = trigger_rediscovery
+
+            {
+              success:     true,
+              extension:   extension_name,
+              phase:       phase,
+              fn:          fn,
+              rediscovery: rediscover_result
+            }
+          end
+
+          def unwire_extension(extension_name:, **)
+            entry = wiring_registry.delete(extension_name)
+            return { success: false, reason: :not_wired } unless entry
+
+            trigger_rediscovery
+
+            { success: true, extension: extension_name, unwired_phase: entry[:phase] }
+          end
+
+          def disable_extension(extension_name:, **)
+            entry = wiring_registry[extension_name]
+            return { success: false, reason: :not_wired } unless entry
+
+            entry[:enabled] = false
+            { success: true, extension: extension_name, status: :disabled }
+          end
+
+          def enable_extension(extension_name:, **)
+            entry = wiring_registry[extension_name]
+            return { success: false, reason: :not_wired } unless entry
+
+            entry[:enabled] = true
+            trigger_rediscovery
+            { success: true, extension: extension_name, status: :enabled }
+          end
+
+          def wiring_status(**)
+            {
+              success:       true,
+              wired_count:   wiring_registry.size,
+              enabled_count: wiring_registry.count { |_, v| v[:enabled] },
+              extensions:    wiring_registry.transform_values { |v| v.slice(:phase, :fn, :enabled, :wired_at) }
+            }
+          end
+
+          def rewire_all(**)
+            return { success: false, reason: :gaia_not_available } unless gaia_available?
+
+            result = trigger_rediscovery
+            { success: true, rediscovery: result }
+          end
+
+          private
+
+          def gaia_available?
+            defined?(Legion::Gaia) && Legion::Gaia.respond_to?(:registry)
+          end
+
+          def resolve_runner(ext_module:, runner_module:)
+            return nil unless defined?(Legion::Gaia::PhaseWiring)
+
+            Legion::Gaia::PhaseWiring.resolve_runner_class(ext_module.to_sym, runner_module.to_sym)
+          end
+
+          def trigger_rediscovery
+            return { rediscovered: false, reason: :gaia_not_available } unless gaia_available?
+
+            Legion::Gaia.registry.rediscover
+          rescue StandardError => e
+            { rediscovered: false, error: e.message }
+          end
+
+          def wiring_registry
+            @wiring_registry ||= {}
+          end
+
+          def build_recommendation(active_alloc, dream_alloc)
+            parts = []
+            parts << case active_alloc[:confidence]
+                     when :high
+                       "Wire to #{active_alloc[:phase]} (high confidence)"
+                     when :medium
+                       "Suggest #{active_alloc[:phase]} (medium confidence, verify manually)"
+                     else
+                       "Default to #{active_alloc[:phase]} (low confidence, manual review recommended)"
+                     end
+            parts << "Also wire dream phase: #{dream_alloc[:phase]}" if dream_alloc
+            parts.join('. ')
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -3,7 +3,7 @@
 module Legion
   module Extensions
     module MindGrowth
-      VERSION = '0.1.4'
+      VERSION = '0.1.5'
     end
   end
 end

data/lib/legion/extensions/mind_growth.rb

@@ -9,11 +9,14 @@ require 'legion/extensions/mind_growth/helpers/proposal_store'
 require 'legion/extensions/mind_growth/helpers/cognitive_models'
 require 'legion/extensions/mind_growth/helpers/build_pipeline'
 require 'legion/extensions/mind_growth/helpers/fitness_evaluator'
+require 'legion/extensions/mind_growth/helpers/phase_allocator'
 require 'legion/extensions/mind_growth/runners/proposer'
 require 'legion/extensions/mind_growth/runners/analyzer'
 require 'legion/extensions/mind_growth/runners/builder'
 require 'legion/extensions/mind_growth/runners/validator'
 require 'legion/extensions/mind_growth/runners/orchestrator'
+require 'legion/extensions/mind_growth/runners/wirer'
+require 'legion/extensions/mind_growth/runners/integration_tester'
 require 'legion/extensions/mind_growth/client'
 
 module Legion