lex-mind-growth 0.2.2 → 0.2.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: '09bcf8ac10095a5ec6dc77fc9d3ceffbcec8f7b207a218fc52fb8f3571f829ff'
-  data.tar.gz: e9c0078ad42782ab0b9ee324c3a8cfb9d02a89ff7e6b5445009f36327f78abbb
+  metadata.gz: e521090b9c272a1969beb62170e55aab7ebdaefbb65a8e9d9cb36107217b73b6
+  data.tar.gz: f92b34127bb840cbb72e70247fb759d1c79a23d6f1690edbafcbe47cc53b1bd4
 SHA512:
-  metadata.gz: 420a685ab1a80584957d3a30e4dc9a478c3e12e1f765f544c852e7f522a587dbb58f0fb22a7c70e2177e0ba3ba76785237b4bac086d49d80f261c06374593995
-  data.tar.gz: 43abebd9a9da4f3f4d296d965fef963583768bb3adc40fbfaae5378e84937ba15b266580ec4c2a042ba2838559474040fe5d6a7cea0755f2926943b42ba1d992
+  metadata.gz: a7354413edb5d555fdee4d69706c3d086edeed67f668609d1f870f67d531ae49d5d6a2150b74152e57cd66786043698f00808109e5344908fd50bc4d55a17c34
+  data.tar.gz: fe1bbaa1c74eb7ee2fd81fe41924cf91177f45e3748d0f5702a8346602c256f94e5b0a652a5ee632f0b95756fa011531fcc637a043c9e1f220f20b6de9f2a9eb

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

@@ -83,9 +83,11 @@ module Legion
           end
 
           # --- Implement Stage ---
-          # Delegates to legion-llm when loaded and started; stubs otherwise
+          # Delegates to lex-codegen FromGap when loaded; falls back to legion-llm; stubs otherwise
           def implement_stage(proposal, base_path)
-            return { success: true, stage: :implement, message: 'implementation requires legion-llm' } unless llm_available?
+            unless llm_available? || codegen_from_gap_available?
+              return { success: true, stage: :implement, message: 'implementation requires legion-llm or lex-codegen' }
+            end
 
             path = ext_path(proposal, base_path)
             target_files = implementation_targets(path)
@@ -179,6 +181,28 @@ module Legion
           end
 
           def implement_file(file_path, proposal)
+            return legacy_implement_file(file_path, proposal) unless codegen_from_gap_available?
+
+            result = Legion::Extensions::Codegen::Runners::FromGap.implement_stub(
+              file_path: file_path,
+              context:   proposal_context(proposal)
+            )
+            return { success: false, error: result[:error] || result[:reason] } unless result[:success]
+
+            if eval_available?
+              review = Legion::Extensions::Eval::Runners::CodeReview.review_generated(
+                code: result[:code], spec_code: nil, context: { source: :mind_growth }
+              )
+              return { success: false, error: "review #{review[:verdict]}: #{review[:issues]&.join(', ')}" } unless review[:passed]
+            end
+
+            ::File.write(file_path, result[:code])
+            { success: true, path: file_path }
+          rescue StandardError => e
+            { success: false, error: e.message }
+          end
+
+          def legacy_implement_file(file_path, proposal)
             stub_content = ::File.read(file_path)
 
             chat = Legion::LLM.chat(caller: { extension: 'lex-mind-growth', operation: 'build' }, intent: { capability: :reasoning })
@@ -192,6 +216,15 @@ module Legion
             { success: false, error: e.message }
           end
 
+          def proposal_context(proposal)
+            {
+              name:        proposal.name,
+              category:    proposal.category,
+              description: proposal.description,
+              metaphor:    proposal.metaphor
+            }
+          end
+
           def implementation_instructions
             <<~INSTRUCTIONS
               You are a Ruby code generator for LegionIO cognitive extensions.
@@ -239,6 +272,16 @@ module Legion
             defined?(Legion::Extensions::Codegen::Runners::Generate)
           end
 
+          def codegen_from_gap_available?
+            defined?(Legion::Extensions::Codegen::Runners::FromGap) &&
+              Legion::Extensions::Codegen::Runners::FromGap.respond_to?(:implement_stub)
+          end
+
+          def eval_available?
+            defined?(Legion::Extensions::Eval::Runners::CodeReview) &&
+              Legion::Extensions::Eval::Runners::CodeReview.respond_to?(:review_generated)
+          end
+
           def exec_available?
             defined?(Legion::Extensions::Exec::Runners::Bundler)
           end

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

@@ -3,7 +3,7 @@
 module Legion
   module Extensions
     module MindGrowth
-      VERSION = '0.2.2'
+      VERSION = '0.2.4'
     end
   end
 end

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

@@ -307,6 +307,158 @@ RSpec.describe Legion::Extensions::MindGrowth::Runners::Builder do
       end
     end
 
+    describe 'implement_stage with codegen FromGap' do
+      let(:ext_dir) { File.join(Dir.tmpdir, "lex-mind-growth-codegen-test-#{SecureRandom.hex(4)}") }
+      let(:generated_code) { "# frozen_string_literal: true\n\nmodule Impl; end\n" }
+
+      before do
+        from_gap_mod = Module.new do
+          def self.implement_stub(file_path:, context: nil) # rubocop:disable Lint/UnusedMethodArgument
+            { success: true, code: "# frozen_string_literal: true\n\nmodule Impl; end\n", file_path: file_path }
+          end
+        end
+        stub_const('Legion::Extensions::Codegen::Runners::FromGap', from_gap_mod)
+        stub_const('Legion::Extensions::Codegen::Runners::Generate', Module.new)
+        stub_const('Legion::Extensions::Codegen::Runners::Validate', Module.new)
+        allow(Legion::Extensions::Codegen::Runners::Generate).to receive(:scaffold_extension)
+          .and_return({ success: true, path: File.join(ext_dir, 'lex-buildable'), files_created: 12 })
+        allow(Legion::Extensions::Codegen::Runners::Validate).to receive(:validate_structure)
+          .and_return({ valid: true, missing: [], present: %w[Gemfile] })
+        allow(Legion::Extensions::Codegen::Runners::Validate).to receive(:validate_gemspec)
+          .and_return({ valid: true, issues: [] })
+
+        runner_dir = File.join(ext_dir, 'lex-buildable', 'lib', 'legion', 'extensions', 'buildable', 'runners')
+        FileUtils.mkdir_p(runner_dir)
+        File.write(File.join(runner_dir, 'example.rb'), "# stub\n")
+      end
+
+      after { FileUtils.rm_rf(ext_dir) }
+
+      it 'delegates to FromGap.implement_stub' do
+        allow(Legion::Extensions::Codegen::Runners::FromGap).to receive(:implement_stub)
+          .and_return({ success: true, code: generated_code, file_path: 'test.rb' })
+        builder.build_extension(proposal_id: proposal_id, base_path: ext_dir)
+        expect(Legion::Extensions::Codegen::Runners::FromGap).to have_received(:implement_stub)
+          .with(hash_including(file_path: a_string_ending_with('example.rb')))
+      end
+
+      it 'includes proposal context in call' do
+        allow(Legion::Extensions::Codegen::Runners::FromGap).to receive(:implement_stub)
+          .and_return({ success: true, code: generated_code, file_path: 'test.rb' })
+        builder.build_extension(proposal_id: proposal_id, base_path: ext_dir)
+        expect(Legion::Extensions::Codegen::Runners::FromGap).to have_received(:implement_stub)
+          .with(hash_including(context: hash_including(name: 'lex-buildable', category: :cognition,
+                                                       description: 'a buildable proposal')))
+      end
+
+      it 'writes approved code to disk' do
+        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('module Impl')
+      end
+
+      it 'pipeline completes when FromGap succeeds' do
+        result = builder.build_extension(proposal_id: proposal_id, base_path: ext_dir)
+        expect(result[:pipeline][:stage]).to eq(:complete)
+      end
+
+      it 'pipeline fails when FromGap returns failure' do
+        allow(Legion::Extensions::Codegen::Runners::FromGap).to receive(:implement_stub)
+          .and_return({ success: false, reason: :llm_empty_response })
+        result = builder.build_extension(proposal_id: proposal_id, base_path: ext_dir)
+        expect(result[:pipeline][:errors]).not_to be_empty
+      end
+    end
+
+    describe 'implement_stage with codegen + eval' do
+      let(:ext_dir) { File.join(Dir.tmpdir, "lex-mind-growth-eval-test-#{SecureRandom.hex(4)}") }
+      let(:generated_code) { "# frozen_string_literal: true\n\nmodule Reviewed; end\n" }
+
+      before do
+        from_gap_mod = Module.new do
+          def self.implement_stub(file_path:, context: nil) # rubocop:disable Lint/UnusedMethodArgument
+            { success: true, code: "# frozen_string_literal: true\n\nmodule Reviewed; end\n", file_path: file_path }
+          end
+        end
+        stub_const('Legion::Extensions::Codegen::Runners::FromGap', from_gap_mod)
+        stub_const('Legion::Extensions::Codegen::Runners::Generate', Module.new)
+        stub_const('Legion::Extensions::Codegen::Runners::Validate', Module.new)
+        stub_const('Legion::Extensions::Eval::Runners::CodeReview', Module.new)
+        allow(Legion::Extensions::Codegen::Runners::Generate).to receive(:scaffold_extension)
+          .and_return({ success: true, path: File.join(ext_dir, 'lex-buildable'), files_created: 12 })
+        allow(Legion::Extensions::Codegen::Runners::Validate).to receive(:validate_structure)
+          .and_return({ valid: true, missing: [], present: %w[Gemfile] })
+        allow(Legion::Extensions::Codegen::Runners::Validate).to receive(:validate_gemspec)
+          .and_return({ valid: true, issues: [] })
+
+        runner_dir = File.join(ext_dir, 'lex-buildable', 'lib', 'legion', 'extensions', 'buildable', 'runners')
+        FileUtils.mkdir_p(runner_dir)
+        File.write(File.join(runner_dir, 'example.rb'), "# stub\n")
+      end
+
+      after { FileUtils.rm_rf(ext_dir) }
+
+      it 'validates code through CodeReview before writing' do
+        allow(Legion::Extensions::Eval::Runners::CodeReview).to receive(:review_generated)
+          .and_return({ passed: true, verdict: :approve })
+        builder.build_extension(proposal_id: proposal_id, base_path: ext_dir)
+        expect(Legion::Extensions::Eval::Runners::CodeReview).to have_received(:review_generated)
+          .with(hash_including(code: a_string_including('module Reviewed'), context: { source: :mind_growth }))
+      end
+
+      it 'writes when review approves' do
+        allow(Legion::Extensions::Eval::Runners::CodeReview).to receive(:review_generated)
+          .and_return({ passed: true, verdict: :approve })
+        result = builder.build_extension(proposal_id: proposal_id, base_path: ext_dir)
+        expect(result[:pipeline][:stage]).to eq(:complete)
+        runner_path = File.join(ext_dir, 'lex-buildable', 'lib', 'legion', 'extensions', 'buildable', 'runners', 'example.rb')
+        expect(File.read(runner_path)).to include('module Reviewed')
+      end
+
+      it 'does not write when review rejects' do
+        allow(Legion::Extensions::Eval::Runners::CodeReview).to receive(:review_generated)
+          .and_return({ passed: false, verdict: :reject, issues: ['unsafe eval'] })
+        result = builder.build_extension(proposal_id: proposal_id, base_path: ext_dir)
+        expect(result[:pipeline][:errors]).not_to be_empty
+        runner_path = File.join(ext_dir, 'lex-buildable', 'lib', 'legion', 'extensions', 'buildable', 'runners', 'example.rb')
+        expect(File.read(runner_path)).to eq("# stub\n")
+      end
+    end
+
+    describe 'implement_stage fallback (no FromGap)' do
+      let(:mock_chat) { double('RubyLLM::Chat') }
+      let(:mock_response) { double('RubyLLM::Message', content: "# frozen_string_literal: true\n\n{ success: true }\n") }
+      let(:ext_dir) { File.join(Dir.tmpdir, "lex-mind-growth-fallback-test-#{SecureRandom.hex(4)}") }
+
+      before do
+        llm_mod = Module.new do
+          def self.started? = true
+          def self.chat(**) = nil
+        end
+        stub_const('Legion::LLM', llm_mod)
+        allow(Legion::LLM).to receive(:chat).and_return(mock_chat)
+        allow(mock_chat).to receive(:with_instructions).and_return(mock_chat)
+        allow(mock_chat).to receive(:ask).and_return(mock_response)
+
+        runner_dir = File.join(ext_dir, 'lex-buildable', 'lib', 'legion', 'extensions', 'buildable', 'runners')
+        FileUtils.mkdir_p(runner_dir)
+        File.write(File.join(runner_dir, 'example.rb'), "# stub\n")
+      end
+
+      after { FileUtils.rm_rf(ext_dir) }
+
+      it 'falls back to legacy LLM implementation' do
+        builder.build_extension(proposal_id: proposal_id, base_path: ext_dir)
+        expect(mock_chat).to have_received(:ask).at_least(:once)
+      end
+
+      it 'writes LLM output to files via legacy path' do
+        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('success: true')
+      end
+    end
+
     describe 'full wired pipeline' do
       before do
         stub_const('Legion::Extensions::Codegen::Runners::Generate', Module.new)

metadata

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