lex-swarm-github 0.3.1 → 0.3.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: a1c767cd01e97e707ce4079c0a3313c723e984143e1e29cfcd580bfd7b391735
-  data.tar.gz: abf61ad73ed7875421cef31b0ff713031f5fc99bc61ece84943fdba22cf34169
+  metadata.gz: afb02c0714b2eeeb371b7d0890c04b6a5637be7b8584f62872cec6337baa980e
+  data.tar.gz: 794646c0b9897d25e18fb22cf156c3f7ee2a5a07408aa23876b17cef00ece198
 SHA512:
-  metadata.gz: 99ae16ec047585531e0c41eedb26e55d4a4e4b2940562078bbc1c36f4f9eb734c08c1df8aef46aa35032ea68c2199e90d39cef50b7535eb8c179f16f90a689c9
-  data.tar.gz: f61a356f212fa8f7b7b250fa6d4fd9ef10446233842cf65410ec3239e76bb689793ef3694978b2e6ee67c00ea09f137b9bcc36d7ec0ad438b626ec5da9fa3875
+  metadata.gz: 5c20383d9e86e5db3135a6cca8af1b1b226348f9cada58232425e7ae8064c17c2366f6aab167404b2081a567e95e238cfd37fc23cebf338fedb9078c35d5591c
+  data.tar.gz: 9d494a1404085b965f8bf6d272b9b875fc4bd3c21c291d9d07fdf45452fe356d6e3966f4e5fe6f42c142f5557b18ea80d68092fe33dbc0cd1d5c9628eea9e68e

data/lib/legion/extensions/swarm_github/actors/lifecycle_subscriber.rb

@@ -19,10 +19,14 @@ module Legion
               return { skipped: true, reason: verdict == 'approve' ? :github_disabled : :not_approved }
             end
 
-            generation = payload[:generation] || {}
-            review = payload.except(:generation)
+            generation = payload[:generation] || payload['generation'] || {}
+            review = payload.except(:generation, 'generation')
+            review_k = payload[:review_k] || payload['review_k']
+            raw_models = payload[:review_models] || payload['review_models']
+            review_models = normalize_review_models(raw_models)
 
-            Runners::ExtensionLifecycle.run_lifecycle(generation: generation, review: review)
+            Runners::ExtensionLifecycle.run_lifecycle(generation: generation, review: review,
+                                                      review_k: review_k, review_models: review_models)
           rescue StandardError => e
             log.warn("LifecycleSubscriber failed: #{e.message}")
             { success: false, error: e.message }
@@ -30,6 +34,16 @@ module Legion
 
           private
 
+          def normalize_review_models(raw)
+            return nil unless raw.is_a?(Array)
+
+            raw.filter_map do |spec|
+              next unless spec.is_a?(Hash)
+
+              spec.transform_keys { |k| k.respond_to?(:to_sym) ? k.to_sym : k }
+            end
+          end
+
           def github_lifecycle_enabled?
             return false unless defined?(Legion::Settings)
 

data/lib/legion/extensions/swarm_github/runners/extension_lifecycle.rb

@@ -7,7 +7,7 @@ module Legion
         module ExtensionLifecycle
           extend self
 
-          def run_lifecycle(generation:, review:)
+          def run_lifecycle(generation:, review:, review_k: nil, review_models: nil)
             config = github_config
             return { success: false, error: :github_not_enabled } unless config[:enabled]
             return { success: false, error: :target_repo_missing } unless config[:target_repo]
@@ -31,11 +31,17 @@ module Legion
             label_pull_request(owner: owner, repo: repo, pull_number: pr[:pull_number],
                                labels: config[:pr_labels])
 
+            k = review_k || default_review_k
+            models = review_models || default_review_models
+            review_result = run_adversarial_review(owner: owner, repo: repo,
+                                                   pull_number: pr[:pull_number], k: k, models: models)
+
             handle_auto_merge(owner: owner, repo: repo, pull_number: pr[:pull_number],
-                              config: config, review: review)
+                              config: config, review: review, review_result: review_result)
 
             { success: true, pull_number: pr[:pull_number], html_url: pr[:html_url],
-              branch: branch_name, generation_id: generation[:generation_id] }
+              branch: branch_name, generation_id: generation[:generation_id],
+              review_consensus: review_result&.dig(:consensus), review_k: k }
           rescue StandardError => e
             log.warn("ExtensionLifecycle failed: #{e.message}")
             { success: false, error: e.message }
@@ -84,8 +90,109 @@ module Legion
             { success: false, error: e.message }
           end
 
-          def handle_auto_merge(owner:, repo:, pull_number:, config:, review:)
+          def default_review_k
+            return 1 unless defined?(Legion::Settings)
+
+            Legion::Settings.dig(:codegen, :self_generate, :github, :review_k) || 1
+          rescue StandardError => e
+            log.warn(e.message)
+            1
+          end
+
+          def default_review_models
+            return [] unless defined?(Legion::Settings)
+
+            Legion::Settings.dig(:codegen, :self_generate, :github, :review_models) || []
+          rescue StandardError => e
+            log.warn(e.message)
+            []
+          end
+
+          def provider_available?(provider_sym)
+            return false unless defined?(Legion::Settings)
+
+            Legion::Settings.dig(:llm, :providers, provider_sym, :enabled) == true
+          rescue StandardError => e
+            log.warn(e.message)
+            false
+          end
+
+          def build_model_assignments(count, models)
+            return Array.new(count) { nil } if models.nil?
+
+            unless models.is_a?(Array)
+              log.warn("review_models must be an Array, got #{models.class}; using defaults")
+              return Array.new(count) { nil }
+            end
+
+            return Array.new(count) { nil } if models.empty?
+
+            available = models.filter_map do |raw_spec|
+              unless raw_spec.is_a?(Hash)
+                log.warn('review model spec is not a Hash, skipping')
+                next
+              end
+
+              spec = raw_spec.transform_keys { |k| k.respond_to?(:to_sym) ? k.to_sym : k }
+              provider_value = spec[:provider]
+
+              if provider_value && !provider_value.respond_to?(:to_sym)
+                log.warn("review provider value #{provider_value.inspect} (#{provider_value.class}) cannot be symbolized, skipping")
+                next
+              end
+
+              provider_sym = provider_value&.to_sym
+              spec[:provider] = provider_sym if provider_sym
+
+              if provider_sym && !provider_available?(provider_sym)
+                log.warn("review provider #{provider_sym} not available, skipping")
+                next
+              end
+
+              spec
+            end
+
+            return Array.new(count) { nil } if available.empty?
+
+            assignments = available.first(count)
+            assignments + Array.new([count - assignments.length, 0].max) { nil }
+          end
+
+          def run_adversarial_review(owner:, repo:, pull_number:, k:, models: []) # rubocop:disable Naming/MethodParameterName
+            return { success: true, skipped: true, reason: :reviewer_unavailable } unless pr_reviewer_available?
+
+            assignments = build_model_assignments(k, models)
+
+            reviews = assignments.map do |spec|
+              kwargs = { owner: owner, repo: repo, pull_number: pull_number }
+              if spec
+                kwargs[:model] = spec[:model] if spec[:model]
+                kwargs[:provider] = spec[:provider] if spec[:provider]
+              end
+              Legion::Extensions::SwarmGithub::Runners::PullRequestReviewer.review_pull_request(**kwargs)
+            end
+
+            approvals = reviews.count do |r|
+              r[:status] == 'reviewed' && (r[:comments] || []).none? { |c| %w[error critical].include?(c[:severity]&.to_s) }
+            end
+            rejections = k - approvals
+
+            {
+              success:    true,
+              consensus:  approvals > rejections ? :approve : :request_changes,
+              k:          k,
+              approvals:  approvals,
+              rejections: rejections,
+              reviews:    reviews
+            }
+          rescue StandardError => e
+            log.warn("adversarial PR review failed: #{e.message}")
+            { success: true, skipped: true, reason: :review_error }
+          end
+
+          def handle_auto_merge(owner:, repo:, pull_number:, config:, review:, review_result: nil) # rubocop:disable Metrics/ParameterLists
             return unless config[:auto_merge] && review[:verdict]&.to_sym == :approve
+            return if review_result && review_result[:consensus] == :request_changes
 
             github_client.merge_pull_request(
               owner: owner, repo: repo, pull_number: pull_number,
@@ -150,6 +257,10 @@ module Legion
             defined?(Legion::Extensions::Github::Client)
           end
 
+          def pr_reviewer_available?
+            defined?(Legion::Extensions::SwarmGithub::Runners::PullRequestReviewer)
+          end
+
           def github_client
             @github_client ||= Legion::Extensions::Github::Client.new(**github_connection_opts)
           end

data/lib/legion/extensions/swarm_github/runners/pull_request_reviewer.rb

@@ -5,11 +5,13 @@ module Legion
     module SwarmGithub
       module Runners
         module PullRequestReviewer
-          def review_pull_request(owner:, repo:, pull_number:)
+          extend self
+
+          def review_pull_request(owner:, repo:, pull_number:, model: nil, provider: nil)
             files = fetch_pr_files(owner: owner, repo: repo, pull_number: pull_number)
             return { status: 'skipped', reason: 'no files' } if files.empty?
 
-            review = generate_review(files)
+            review = generate_review(files, model: model, provider: provider)
 
             {
               status:         'reviewed',
@@ -33,12 +35,15 @@ module Legion
             []
           end
 
-          def generate_review(files)
+          def generate_review(files, model: nil, provider: nil)
             chunks = Helpers::DiffChunker.chunk_files(files)
             reviews = chunks.map do |chunk|
               diff_text = chunk.map { |f| "--- #{f[:filename]} ---\n#{f[:patch]}" }.join("\n\n")
               prompt = code_review_prompt(diff_text)
-              response = Legion::LLM.chat(message: prompt, caller: { extension: 'lex-swarm-github' })
+              llm_kwargs = { message: prompt, caller: { extension: 'lex-swarm-github' } }
+              llm_kwargs[:model] = model if model
+              llm_kwargs[:provider] = provider if provider
+              response = Legion::LLM.chat(**llm_kwargs)
               parse_review_response(response)
             end
             merge_chunk_reviews(reviews)

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

@@ -3,7 +3,7 @@
 module Legion
   module Extensions
     module SwarmGithub
-      VERSION = '0.3.1'
+      VERSION = '0.3.2'
     end
   end
 end

data/spec/legion/extensions/swarm_github/actors/lifecycle_subscriber_spec.rb

@@ -80,11 +80,21 @@ RSpec.describe Legion::Extensions::SwarmGithub::Actor::LifecycleSubscriber do
         actor.action(payload)
         expect(Legion::Extensions::SwarmGithub::Runners::ExtensionLifecycle)
           .to have_received(:run_lifecycle).with(
-            generation: generation,
-            review:     hash_including(verdict: 'approve')
+            generation:    generation,
+            review:        hash_including(verdict: 'approve'),
+            review_k:      nil,
+            review_models: nil
           )
       end
 
+      it 'forwards review_models from payload' do
+        models = [{ provider: :bedrock, model: 'claude' }]
+        payload = { verdict: 'approve', generation: generation, review_models: models }
+        actor.action(payload)
+        expect(Legion::Extensions::SwarmGithub::Runners::ExtensionLifecycle)
+          .to have_received(:run_lifecycle).with(hash_including(review_models: models))
+      end
+
       it 'returns the lifecycle result' do
         result = actor.action({ verdict: 'approve', generation: generation })
         expect(result).to eq(lifecycle_result)

data/spec/legion/extensions/swarm_github/runners/extension_lifecycle_spec.rb

@@ -79,6 +79,7 @@ RSpec.describe Legion::Extensions::SwarmGithub::Runners::ExtensionLifecycle do
           { result: { 'number' => 42, 'html_url' => 'https://github.com/org/repo/pull/42' } }
         )
         allow(github_client).to receive(:add_labels).and_return({ success: true })
+        allow(runner).to receive(:pr_reviewer_available?).and_return(false)
       end
 
       it 'returns success with PR details' do
@@ -154,6 +155,7 @@ RSpec.describe Legion::Extensions::SwarmGithub::Runners::ExtensionLifecycle do
           { result: { 'number' => 7, 'html_url' => 'https://github.com/org/repo/pull/7' } }
         )
         allow(github_client).to receive(:merge_pull_request).and_return({ success: true })
+        allow(runner).to receive(:pr_reviewer_available?).and_return(false)
       end
 
       it 'calls merge_pull_request' do
@@ -175,5 +177,142 @@ RSpec.describe Legion::Extensions::SwarmGithub::Runners::ExtensionLifecycle do
         expect(result[:error]).to eq('unexpected failure')
       end
     end
+
+    describe 'adversarial PR review' do
+      let(:mod) { described_class }
+
+      before do
+        allow(mod).to receive(:github_config).and_return(
+          enabled: true, target_repo: 'Test/repo', target_branch: 'main',
+          auto_merge: false, pr_labels: [], branch_prefix: 'feature/auto-gen'
+        )
+        allow(mod).to receive(:create_lifecycle_branch).and_return({ success: true })
+        allow(mod).to receive(:commit_generated_files).and_return({ success: true })
+        allow(mod).to receive(:open_pull_request).and_return({ success: true, pull_number: 1, html_url: 'url' })
+        allow(mod).to receive(:label_pull_request).and_return({ success: true })
+        allow(mod).to receive(:run_adversarial_review).and_return({ success: true, consensus: :approve, k: 3 })
+        allow(mod).to receive(:handle_auto_merge)
+      end
+
+      it 'passes review_k through to adversarial review' do
+        mod.run_lifecycle(generation: generation, review: review, review_k: 3)
+        expect(mod).to have_received(:run_adversarial_review).with(hash_including(k: 3))
+      end
+
+      it 'defaults review_k to 1' do
+        mod.run_lifecycle(generation: generation, review: review)
+        expect(mod).to have_received(:run_adversarial_review).with(hash_including(k: 1))
+      end
+
+      it 'includes review consensus in result' do
+        result = mod.run_lifecycle(generation: generation, review: review, review_k: 3)
+        expect(result[:review_consensus]).to eq(:approve)
+        expect(result[:review_k]).to eq(3)
+      end
+    end
+
+    describe 'multi-provider adversarial review' do
+      let(:mod) { described_class }
+
+      before do
+        allow(mod).to receive(:github_config).and_return(
+          enabled: true, target_repo: 'Test/repo', target_branch: 'main',
+          auto_merge: false, pr_labels: [], branch_prefix: 'feature/auto-gen'
+        )
+        allow(mod).to receive(:create_lifecycle_branch).and_return({ success: true })
+        allow(mod).to receive(:commit_generated_files).and_return({ success: true })
+        allow(mod).to receive(:open_pull_request).and_return({ success: true, pull_number: 1, html_url: 'url' })
+        allow(mod).to receive(:label_pull_request).and_return({ success: true })
+        allow(mod).to receive(:handle_auto_merge)
+      end
+
+      it 'forwards review_models to adversarial review' do
+        allow(mod).to receive(:run_adversarial_review).and_return({ success: true, consensus: :approve, k: 2 })
+        models = [{ provider: :bedrock, model: 'claude' }]
+        mod.run_lifecycle(generation: generation, review: review, review_k: 2, review_models: models)
+        expect(mod).to have_received(:run_adversarial_review).with(hash_including(models: models))
+      end
+
+      it 'uses default_review_models when review_models is nil' do
+        allow(mod).to receive(:run_adversarial_review).and_return({ success: true, consensus: :approve, k: 1 })
+        allow(mod).to receive(:default_review_models).and_return([])
+        mod.run_lifecycle(generation: generation, review: review)
+        expect(mod).to have_received(:default_review_models)
+      end
+    end
+
+    describe '#build_model_assignments' do
+      let(:mod) { described_class }
+
+      it 'returns all nils when models is nil' do
+        result = mod.send(:build_model_assignments, 3, nil)
+        expect(result).to eq([nil, nil, nil])
+      end
+
+      it 'returns all nils when models is empty' do
+        result = mod.send(:build_model_assignments, 2, [])
+        expect(result).to eq([nil, nil])
+      end
+
+      it 'uses each available model at most once, then fills remaining slots with nil' do
+        allow(mod).to receive(:provider_available?).and_return(true)
+        models = [{ provider: :bedrock, model: 'a' }, { provider: :openai, model: 'b' }]
+        result = mod.send(:build_model_assignments, 3, models)
+        expect(result).to eq([{ provider: :bedrock, model: 'a' }, { provider: :openai, model: 'b' }, nil])
+      end
+
+      it 'skips unavailable providers and falls back to nil assignments' do
+        allow(mod).to receive(:provider_available?).and_return(false)
+        models = [{ provider: :unavailable, model: 'x' }]
+        result = mod.send(:build_model_assignments, 2, models)
+        expect(result).to eq([nil, nil])
+      end
+
+      it 'returns all nils and warns when models is a String' do
+        expect(mod).to receive(:log).at_least(:once).and_return(double(warn: nil))
+        result = mod.send(:build_model_assignments, 2, 'not-an-array')
+        expect(result).to eq([nil, nil])
+      end
+
+      it 'returns all nils and warns when models is a Hash' do
+        expect(mod).to receive(:log).at_least(:once).and_return(double(warn: nil))
+        result = mod.send(:build_model_assignments, 2, { provider: :bedrock, model: 'claude' })
+        expect(result).to eq([nil, nil])
+      end
+
+      it 'returns all nils and warns when models is an Integer' do
+        expect(mod).to receive(:log).at_least(:once).and_return(double(warn: nil))
+        result = mod.send(:build_model_assignments, 2, 42)
+        expect(result).to eq([nil, nil])
+      end
+
+      it 'skips specs with a non-symbolizable provider value and warns' do
+        logger = double(warn: nil)
+        allow(mod).to receive(:log).and_return(logger)
+        models = [{ provider: [1, 2], model: 'x' }, { provider: :openai, model: 'y' }]
+        allow(mod).to receive(:provider_available?).with(:openai).and_return(true)
+        result = mod.send(:build_model_assignments, 2, models)
+        expect(logger).to have_received(:warn).with(/cannot be symbolized/)
+        expect(result).to eq([{ provider: :openai, model: 'y' }, nil])
+      end
+    end
+
+    describe '#provider_available?' do
+      let(:mod) { described_class }
+
+      it 'returns false when Legion::Settings is not defined' do
+        hide_const('Legion::Settings') if defined?(Legion::Settings)
+        expect(mod.send(:provider_available?, :bedrock)).to be false
+      end
+    end
+
+    describe '#default_review_models' do
+      let(:mod) { described_class }
+
+      it 'returns empty array when Legion::Settings is not defined' do
+        hide_const('Legion::Settings') if defined?(Legion::Settings)
+        expect(mod.send(:default_review_models)).to eq([])
+      end
+    end
   end
 end

data/spec/legion/extensions/swarm_github/runners/pull_request_reviewer_spec.rb

@@ -98,5 +98,32 @@ RSpec.describe Legion::Extensions::SwarmGithub::Runners::PullRequestReviewer do
         expect(result[:comments].first[:severity]).to eq('error')
       end
     end
+
+    context 'with model: and provider: kwargs' do
+      let(:client) { Class.new { include Legion::Extensions::SwarmGithub::Runners::PullRequestReviewer }.new }
+
+      before do
+        stub_const('Legion::LLM', Module.new)
+        allow(Legion::LLM).to receive(:chat).and_return('{"summary":"ok","comments":[]}')
+        allow(client).to receive(:fetch_pr_files).and_return(
+          [{ filename: 'test.rb', patch: '+x' }]
+        )
+      end
+
+      it 'forwards model and provider to Legion::LLM.chat' do
+        client.review_pull_request(owner: 'o', repo: 'r', pull_number: 1, model: 'gpt-4o', provider: :openai)
+        expect(Legion::LLM).to have_received(:chat).with(hash_including(model: 'gpt-4o', provider: :openai))
+      end
+
+      it 'omits model key when model is nil' do
+        client.review_pull_request(owner: 'o', repo: 'r', pull_number: 1)
+        expect(Legion::LLM).to have_received(:chat).with(hash_not_including(:model))
+      end
+
+      it 'omits provider key when provider is nil' do
+        client.review_pull_request(owner: 'o', repo: 'r', pull_number: 1)
+        expect(Legion::LLM).to have_received(:chat).with(hash_not_including(:provider))
+      end
+    end
   end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: lex-swarm-github
 version: !ruby/object:Gem::Version
-  version: 0.3.1
+  version: 0.3.2
 platform: ruby
 authors:
 - Esity