lex-mind-growth 0.3.0 → 0.3.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 3fcaa84f5b0e455b0ac70019228ebe5bffdbd1c69228aafcad9bf92d7f91bb52
-  data.tar.gz: 4ea8b0c108d6bf0a957cd9709147e4cfaa3c78e0b297afc85e642331f9153e4a
+  metadata.gz: d9b428be29ef5df316acb3e4b9d6a01b826168046e1133e50c293e1ecc1a1186
+  data.tar.gz: 7a38b04f5d93dea41f294cb0011a9f74511cd24bfe9687af792edc1940dcfd03
 SHA512:
-  metadata.gz: 911dc8e13b4dfe4cb4ee0cd5dd7cd27fc2d93a529aca350cc4d02d4f3f27b9548ac8881945bb57d150ffa8cc8e169e8f62b3590e2bbab4188dbfc0046aa69eb3
-  data.tar.gz: d4f849194085b3b398dd41e3499b686c87b323ab4950a392eaca71133aeb943fcfe68557829a5cb6be92428bf781c90ab53d49cf877f26abe5b699562c25d07e
+  metadata.gz: 33078449b48cf7cae04ceabd91690ae4900f47bc89275aab55005a2f1cb28242e5ef0780ef6321166b09e7b89a79b34b34afbd2d293243807a64c366c5303323
+  data.tar.gz: 6d77136475fc7cde737949355135e60fa90891559f29f02ee71aa522e80d5be82cbbda09e41b16fc4293070eae6c9b0466acd564e1441700c326112905035ef6

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

@@ -254,11 +254,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 +310,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/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/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.1'
     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/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/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.1
 platform: ruby
 authors:
 - Esity