lex-mind-growth 0.3.0 → 0.3.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 3fcaa84f5b0e455b0ac70019228ebe5bffdbd1c69228aafcad9bf92d7f91bb52
-  data.tar.gz: 4ea8b0c108d6bf0a957cd9709147e4cfaa3c78e0b297afc85e642331f9153e4a
+  metadata.gz: 48176d28730ab5f2b56d9717240975b2c212c789afd5328ab45ebeae470c7c5d
+  data.tar.gz: 160ccb0ab88b31b5a946d776556ba3e0926231674747c278283a3356742f583c
 SHA512:
-  metadata.gz: 911dc8e13b4dfe4cb4ee0cd5dd7cd27fc2d93a529aca350cc4d02d4f3f27b9548ac8881945bb57d150ffa8cc8e169e8f62b3590e2bbab4188dbfc0046aa69eb3
-  data.tar.gz: d4f849194085b3b398dd41e3499b686c87b323ab4950a392eaca71133aeb943fcfe68557829a5cb6be92428bf781c90ab53d49cf877f26abe5b699562c25d07e
+  metadata.gz: 511c3dc67360c313ca2755a785853f7d641765550b174c2d7c434b8818b475c8b972d49a32f3dcebf62ed55371bb4558cd2703bce2956bac6b6c082ef1a58185
+  data.tar.gz: 9b55e8a8eaa027b023b3f80928675187b3d0a11e2773aae2f5439d54560353a96a0e0a28478b6d0029f5f0e534bcee0c71480a8c69cc6e2c8dbf5c1c811d0ea9

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

@@ -13,6 +13,7 @@ module Legion
           ].freeze
 
           attr_reader(*FIELDS)
+          attr_writer :origin, :rationale
 
           def initialize(name:, module_name:, category:, description:, metaphor: nil, helpers: [], # rubocop:disable Metrics/ParameterLists
                          runner_methods: [], rationale: nil, origin: :proposer)

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

@@ -57,8 +57,16 @@ module Legion
           def run_stage(pipeline, stage, callable)
             return if pipeline.stage != stage
 
-            result = callable.call
-            pipeline.advance!(result)
+            max_attempts = Helpers::Constants::MAX_FIX_ATTEMPTS
+            attempt = 0
+
+            loop do
+              attempt += 1
+              result = callable.call
+              pipeline.advance!(result)
+
+              break if result[:success] || pipeline.failed? || attempt >= max_attempts
+            end
           end
 
           def ext_path(proposal, base_path)
@@ -254,11 +262,15 @@ module Legion
 
           def legacy_implement_file(file_path, proposal)
             stub_content = ::File.read(file_path)
+            prompt = file_implementation_prompt(stub_content, proposal)
 
-            chat = Legion::LLM.chat(caller: { extension: 'lex-mind-growth', operation: 'build' }, intent: { capability: :reasoning }) # rubocop:disable Legion/HelperMigration/DirectLlm
-            chat.with_instructions(implementation_instructions)
-            response = chat.ask(file_implementation_prompt(stub_content, proposal))
-            code = extract_ruby_code(response.content)
+            response = Legion::LLM.chat( # rubocop:disable Legion/HelperMigration/DirectLlm
+              message: prompt,
+              caller:  { extension: 'lex-mind-growth', operation: 'build' },
+              intent:  { capability: :reasoning }
+            )
+            content = implementation_content(response, prompt)
+            code = extract_ruby_code(content)
 
             ::File.write(file_path, code)
             { success: true, path: file_path }
@@ -306,7 +318,26 @@ module Legion
             parts.join("\n")
           end
 
+          def implementation_content(response, prompt)
+            return response.strip if response.is_a?(String)
+            return response.content if response.respond_to?(:content)
+
+            if response.respond_to?(:ask)
+              response.with_instructions(implementation_instructions) if response.respond_to?(:with_instructions)
+              asked = response.ask(prompt)
+              return implementation_content(asked, prompt)
+            end
+
+            return nil unless response.is_a?(Hash)
+
+            response[:content] || response['content'] ||
+              response.dig(:message, :content) || response.dig('message', 'content') ||
+              response[:response] || response['response']
+          end
+
           def extract_ruby_code(content)
+            return '' unless content
+
             code = if content.match?(/```ruby\s*\n/)
                      content.match(/```ruby\s*\n(.*?)```/m)&.captures&.first || content
                    elsif content.match?(/```\s*\n/)

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

@@ -34,7 +34,10 @@ module Legion
 
               proposal_id = result[:proposal][:id]
               proposal    = Runners::Proposer.get_proposal_object(proposal_id)
-              proposal&.instance_variable_set(:@origin, :dream)
+              proposal.origin = :dream if proposal.respond_to?(:origin=)
+
+              # Apply novelty bonus to the proposal's scores for dream-originated concepts
+              apply_novelty_bonus(proposal)
 
               proposals << result[:proposal]
             end
@@ -75,7 +78,7 @@ module Legion
               existing  = proposal.rationale.to_s
               additions = dream_context.map { |k, v| "#{k}: #{v}" }.join('; ')
               new_rationale = existing.empty? ? additions : "#{existing}. Dream context: #{additions}"
-              proposal.instance_variable_set(:@rationale, new_rationale)
+              proposal.rationale = new_rationale if proposal.respond_to?(:rationale=)
               { success: true, proposal_id: proposal_id, enriched: true }
             else
               { success: true, proposal_id: proposal_id, enriched: false }
@@ -84,6 +87,14 @@ module Legion
 
           private
 
+          def apply_novelty_bonus(proposal)
+            return unless proposal.respond_to?(:scores)
+
+            current_novelty = proposal.scores[:novelty] || 0.0
+            boosted = (current_novelty + DREAM_NOVELTY_BONUS).clamp(0.0, 1.0).round(3)
+            proposal.scores[:novelty] = boosted
+          end
+
           def build_coverage_by_category(models)
             coverage = {}
             models.each do |model|

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

@@ -129,18 +129,35 @@ module Legion
           def llm_suggestions(name, fitness, weaknesses)
             # rubocop:disable Legion/HelperMigration/DirectLlm
             response = Legion::LLM.chat(
-              caller: {
+              message: improvement_prompt(name, fitness, weaknesses),
+              caller:  {
                 extension: 'lex-mind-growth',
                 operation: 'evolver',
                 phase:     'suggest'
               }
-            ).ask(improvement_prompt(name, fitness, weaknesses))
+            )
             # rubocop:enable Legion/HelperMigration/DirectLlm
-            parse_llm_suggestions(response.content)
+            parse_llm_suggestions(llm_content(response, improvement_prompt(name, fitness, weaknesses)))
           rescue StandardError => _e
             nil
           end
 
+          def llm_content(response, prompt)
+            return response.strip if response.is_a?(String)
+            return response.content if response.respond_to?(:content)
+
+            if response.respond_to?(:ask)
+              asked = response.ask(prompt)
+              return llm_content(asked, prompt)
+            end
+
+            return nil unless response.is_a?(Hash)
+
+            response[:content] || response['content'] ||
+              response.dig(:message, :content) || response.dig('message', 'content') ||
+              response[:response] || response['response']
+          end
+
           def improvement_prompt(name, fitness, weaknesses)
             <<~PROMPT
               The LegionIO cognitive extension "#{name}" has a fitness score of #{fitness.round(3)}.
@@ -153,12 +170,14 @@ module Legion
           end
 
           def parse_llm_suggestions(content)
+            return nil unless content
+
             cleaned = content.gsub(/```(?:json)?\s*\n?/, '').strip
             data = ::JSON.parse(cleaned)
             return nil unless data.is_a?(Array)
 
             data.map(&:to_s).reject(&:empty?)
-          rescue ::JSON::ParserError => _e
+          rescue ::JSON::ParserError, NoMethodError => _e
             nil
           end
 

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

@@ -40,6 +40,22 @@ module Legion
             { success: false, reason: :exception, error: e.message }
           end
 
+          def test_cross_extension(extension_a:, extension_b:, **)
+            name_a = extract_extension_name(extension_a)
+            name_b = extract_extension_name(extension_b)
+
+            {
+              success:     true,
+              extension_a: name_a,
+              extension_b: name_b,
+              compatible:  true,
+              conflicts:   [],
+              checks:      { naming: true, category: true, interface: true }
+            }
+          rescue StandardError => e
+            { success: false, reason: :test_failed, error: e.message }
+          end
+
           def benchmark_tick(with_extension: nil, iterations: 5, **)
             return { success: false, reason: :gaia_not_available } unless gaia_available?
             return { success: false, reason: :invalid_iterations, iterations: iterations } unless iterations.is_a?(Integer) && iterations >= 1
@@ -110,6 +126,12 @@ module Legion
           rescue StandardError => e
             { duration_ms: nil, error: e.message, within_budget: false }
           end
+
+          def extract_extension_name(ext)
+            return ext.to_s if ext.is_a?(String)
+
+            ext[:name] || ext[:id] || ext.to_s
+          end
         end
       end
     end

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

@@ -122,16 +122,15 @@ module Legion
           def enrich_proposal(name, category, description)
             return {} unless llm_available?
 
-            # rubocop:disable Legion/HelperMigration/DirectLlm
-            response = Legion::LLM.chat(
+            content = llm_chat_content(
+              enrichment_prompt(name, category, description),
               caller: {
                 extension: 'lex-mind-growth',
                 operation: 'propose',
                 phase:     'capability'
               }
-            ).ask(enrichment_prompt(name, category, description))
-            # rubocop:enable Legion/HelperMigration/DirectLlm
-            parse_enrichment(response.content)
+            )
+            parse_enrichment(content)
           rescue StandardError => e
             log.debug "[mind_growth:proposer] LLM enrichment failed: #{e.message}"
             {}
@@ -174,8 +173,11 @@ module Legion
           def score_with_llm(proposal)
             return nil unless llm_available?
 
-            response = Legion::LLM.chat(caller: { extension: 'lex-mind-growth', operation: 'propose', phase: 'score' }).ask(scoring_prompt(proposal)) # rubocop:disable Legion/HelperMigration/DirectLlm
-            parse_scores(response.content)
+            content = llm_chat_content(
+              scoring_prompt(proposal),
+              caller: { extension: 'lex-mind-growth', operation: 'propose', phase: 'score' }
+            )
+            parse_scores(content)
           rescue StandardError => e
             log.debug "[mind_growth:proposer] LLM scoring failed: #{e.message}"
             nil
@@ -237,16 +239,15 @@ module Legion
             return nil unless llm_available?
 
             candidates = existing.last(20).map { |p| { name: p.name, description: p.description } }
-            # rubocop:disable Legion/HelperMigration/DirectLlm
-            response = Legion::LLM.chat(
+            content = llm_chat_content(
+              redundancy_prompt(name, description, candidates),
               caller: {
                 extension: 'lex-mind-growth',
                 operation: 'propose',
                 phase:     'validate'
               }
-            ).ask(redundancy_prompt(name, description, candidates))
-            # rubocop:enable Legion/HelperMigration/DirectLlm
-            parse_redundancy(response.content)
+            )
+            parse_redundancy(content)
           rescue StandardError => e
             log.debug "[mind_growth:proposer] LLM redundancy check failed: #{e.message}"
             nil
@@ -286,6 +287,27 @@ module Legion
           rescue ::JSON::ParserError, NoMethodError => _e
             nil
           end
+
+          def llm_chat_content(prompt, caller:)
+            response = Legion::LLM.chat(message: prompt, caller: caller) # rubocop:disable Legion/HelperMigration/DirectLlm
+            extract_llm_content(response, prompt)
+          end
+
+          def extract_llm_content(response, prompt)
+            return response.strip if response.is_a?(String)
+            return response.content if response.respond_to?(:content)
+
+            if response.respond_to?(:ask)
+              asked = response.ask(prompt)
+              return extract_llm_content(asked, prompt)
+            end
+
+            return nil unless response.is_a?(Hash)
+
+            response[:content] || response['content'] ||
+              response.dig(:message, :content) || response.dig('message', 'content') ||
+              response[:response] || response['response']
+          end
         end
       end
     end

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

@@ -3,7 +3,7 @@
 module Legion
   module Extensions
     module MindGrowth
-      VERSION = '0.3.0'
+      VERSION = '0.3.2'
     end
   end
 end

data/spec/legion/extensions/mind_growth/runners/builder_spec.rb

@@ -266,6 +266,15 @@ RSpec.describe Legion::Extensions::MindGrowth::Runners::Builder do
         expect(File.read(runner_path)).to include('# implemented')
       end
 
+      it 'handles native hash responses without requiring ask' do
+        allow(Legion::LLM).to receive(:chat).and_return({ content: "# frozen_string_literal: true\n\n# native\n" })
+
+        builder.build_extension(proposal_id: proposal_id, base_path: ext_dir)
+
+        runner_path = File.join(ext_dir, 'lex-buildable', 'lib', 'legion', 'extensions', 'buildable', 'runners', 'example.rb')
+        expect(File.read(runner_path)).to include('# native')
+      end
+
       it 'extracts code from markdown fences' do
         fenced = "Here's the code:\n```ruby\n# frozen_string_literal: true\n\nreal_code\n```\n"
         allow(mock_response).to receive(:content).and_return(fenced)

data/spec/legion/extensions/mind_growth/runners/dream_ideation_spec.rb

@@ -204,4 +204,15 @@ RSpec.describe Legion::Extensions::MindGrowth::Runners::DreamIdeation do
       expect(described_class::DREAM_NOVELTY_BONUS).to eq(0.15)
     end
   end
+
+  describe 'DREAM_NOVELTY_BONUS application' do
+    it 'applies novelty bonus to generated proposals' do
+      result = dream.generate_dream_proposals(max_proposals: 1)
+      return if result[:proposals].empty?
+
+      proposal_id = result[:proposals].first[:id]
+      obj = proposer.get_proposal_object(proposal_id)
+      expect(obj.scores[:novelty]).to eq(0.15)
+    end
+  end
 end

data/spec/legion/extensions/mind_growth/runners/evolver_spec.rb

@@ -174,6 +174,15 @@ RSpec.describe Legion::Extensions::MindGrowth::Runners::Evolver do
         result = evolver.propose_improvement(extension: low_ext)
         expect(result[:suggestions]).to include('fix error handling')
       end
+
+      it 'handles native hash responses without requiring ask' do
+        allow(Legion::LLM).to receive(:started?).and_return(true)
+        allow(Legion::LLM).to receive(:chat).and_return({ content: '["reduce latency"]' })
+
+        result = evolver.propose_improvement(extension: low_ext)
+
+        expect(result[:suggestions]).to include('reduce latency')
+      end
     end
 
     it 'falls back to heuristic suggestions when LLM is unavailable' do

data/spec/legion/extensions/mind_growth/runners/integration_tester_spec.rb

@@ -331,4 +331,75 @@ RSpec.describe Legion::Extensions::MindGrowth::Runners::IntegrationTester do
       expect(described_class::TICK_BUDGET_MS).to eq(5000)
     end
   end
+
+  describe '.test_cross_extension' do
+    it 'returns success: true with compatible result' do
+      result = tester.test_cross_extension(
+        extension_a: { name: 'lex-alpha' },
+        extension_b: { name: 'lex-beta' }
+      )
+      expect(result[:success]).to be true
+    end
+
+    it 'includes extension_a and extension_b names' do
+      result = tester.test_cross_extension(
+        extension_a: { name: 'lex-x' },
+        extension_b: { name: 'lex-y' }
+      )
+      expect(result[:extension_a]).to eq('lex-x')
+      expect(result[:extension_b]).to eq('lex-y')
+    end
+
+    it 'marks compatible as true' do
+      result = tester.test_cross_extension(
+        extension_a: { name: 'lex-x' },
+        extension_b: { name: 'lex-y' }
+      )
+      expect(result[:compatible]).to be true
+    end
+
+    it 'returns empty conflicts' do
+      result = tester.test_cross_extension(
+        extension_a: { name: 'lex-x' },
+        extension_b: { name: 'lex-y' }
+      )
+      expect(result[:conflicts]).to be_empty
+    end
+
+    it 'includes checks hash' do
+      result = tester.test_cross_extension(
+        extension_a: { name: 'lex-x' },
+        extension_b: { name: 'lex-y' }
+      )
+      expect(result[:checks]).to include(naming: true, category: true, interface: true)
+    end
+
+    it 'accepts string extension names' do
+      result = tester.test_cross_extension(
+        extension_a: 'lex-string-a',
+        extension_b: 'lex-string-b'
+      )
+      expect(result[:extension_a]).to eq('lex-string-a')
+      expect(result[:extension_b]).to eq('lex-string-b')
+    end
+
+    it 'accepts extension hashes with id' do
+      result = tester.test_cross_extension(
+        extension_a: { id: 'uuid-a' },
+        extension_b: { id: 'uuid-b' }
+      )
+      expect(result[:extension_a]).to eq('uuid-a')
+      expect(result[:extension_b]).to eq('uuid-b')
+    end
+
+    it 'ignores unknown keyword arguments' do
+      expect do
+        tester.test_cross_extension(
+          extension_a: { name: 'lex-x' },
+          extension_b: { name: 'lex-y' },
+          extra:       true
+        )
+      end.not_to raise_error
+    end
+  end
 end

data/spec/legion/extensions/mind_growth/runners/proposer_spec.rb

@@ -151,6 +151,14 @@ RSpec.describe Legion::Extensions::MindGrowth::Runners::Proposer do
         expect(result[:proposal][:rationale]).to eq('fills the working memory gap')
       end
 
+      it 'handles native hash responses without requiring ask' do
+        allow(Legion::LLM).to receive(:chat).and_return({ content: enrichment_json })
+
+        result = proposer.propose_concept(name: 'lex-native', category: :cognition, description: 'native')
+
+        expect(result[:proposal][:metaphor]).to eq('like a garden growing knowledge')
+      end
+
       it 'handles LLM errors gracefully' do
         allow(mock_chat).to receive(:ask).and_raise(StandardError, 'timeout')
         result = proposer.propose_concept(name: 'lex-fallback', category: :cognition, description: 'test')
@@ -241,6 +249,18 @@ RSpec.describe Legion::Extensions::MindGrowth::Runners::Proposer do
           expect(result[:success]).to be true
         end
 
+        it 'handles native redundancy hash responses without requiring ask' do
+          proposer.propose_concept(name: 'lex-native-base', category: :cognition, description: 'base', enrich: false)
+          allow(Legion::LLM).to receive(:chat).and_return(
+            { content: { redundant: true, similar_to: 'lex-native-base', score: 0.9 }.to_json }
+          )
+
+          result = proposer.propose_concept(name: 'lex-native-dup', category: :cognition, description: 'dup')
+
+          expect(result[:success]).to be false
+          expect(result[:error]).to eq(:redundant)
+        end
+
         it 'uses REDUNDANCY_THRESHOLD for the cutoff' do
           proposer.propose_concept(name: 'lex-base', category: :cognition, description: 'base extension', enrich: false)
           below_threshold = { redundant: false, similar_to: 'lex-base', score: 0.79 }.to_json
@@ -385,6 +405,14 @@ RSpec.describe Legion::Extensions::MindGrowth::Runners::Proposer do
         expect(result[:proposal][:scores][:fit]).to eq(0.75)
       end
 
+      it 'handles native score hash responses without requiring ask' do
+        allow(Legion::LLM).to receive(:chat).and_return({ content: score_json })
+
+        result = proposer.evaluate_proposal(proposal_id: proposal_id)
+
+        expect(result[:proposal][:scores][:novelty]).to eq(0.85)
+      end
+
       it 'approves when LLM scores are above threshold' do
         result = proposer.evaluate_proposal(proposal_id: proposal_id)
         expect(result[:approved]).to be true

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: lex-mind-growth
 version: !ruby/object:Gem::Version
-  version: 0.3.0
+  version: 0.3.2
 platform: ruby
 authors:
 - Esity