lex-swarm-github 0.2.3 → 0.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 6dac167b9c8a974aa180eb0519a006ddd30a839ccd6e3a00ec42618d1d8f6021
-  data.tar.gz: f298aaa736b6ab8ffddba8614c19ba31a7b16d23a0a95f51d4cae24b04e71e88
+  metadata.gz: a5b852399782262ebab25e020d689b147a55ce6f256134a9d53137b223e6ba8e
+  data.tar.gz: 8804deca49b8a4bd37a262d90e152ade0e2359fd065f40ea4d32604bb0f885bf
 SHA512:
-  metadata.gz: 679c7437587c3e567d673ceab73c4c375c48671820433de46b4f569d9d6218ac9d9dd8bdff0815aba012a7a42ea768791a90797581e030393d1018af7cbd621c
-  data.tar.gz: 2bf0b8ad3718eeb2291720e71c3cf1d809dd33fee39409d826c64b4f3fefe53b05004a7e77f20461e2a54f1955a18bb28799123ddac0da67c483cc3500492912
+  metadata.gz: 798c161250c26ba51ca15c0696d7f97dcc794d78b34fc1696b466e0aba16196368b96f2e5fc9351c0b34244efdbf3fe0c35b0a7cca4bc09d684d1fd014cec361
+  data.tar.gz: 5ad660b2154048f0974ff1ac444ac0a96f282c9ffa789455bb901a29b3c737cfe103ea0bfb8c177862daec6b11efe2d4606a221edcedb8689005b6c8dea76d38

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

@@ -10,8 +10,9 @@ module Legion
           REVIEWABLE_ACTIONS = %w[opened synchronize reopened].freeze
           DEFAULT_SLACK_CHANNEL = '#code-reviews'
 
-          def run_review_pipeline(owner:, repo:, pull_number:, slack_channel: nil, **)
+          def run_review_pipeline(owner:, repo:, pull_number:, slack_channel: nil, **opts)
             channel = slack_channel || DEFAULT_SLACK_CHANNEL
+            issue_number = opts[:issue_number]
 
             review = review_pull_request(owner: owner, repo: repo, pull_number: pull_number)
             return { review: review, post: nil, notify: nil } unless review[:status] == 'reviewed'
@@ -20,7 +21,10 @@ module Legion
             notify = notify_review(channel: channel, pull_ref: "#{owner}/#{repo}##{pull_number}",
                                    review: review, post_result: post)
 
-            { review: review, post: post, notify: notify }
+            result = { review: review, post: post, notify: notify }
+            bridge_review_to_issue(repo: "#{owner}/#{repo}", issue_number: issue_number,
+                                   review_result: result)
+            result
           end
 
           def run_review_pipeline_from_webhook(payload:, slack_channel: nil, **)
@@ -35,6 +39,18 @@ module Legion
                                 slack_channel: slack_channel)
           end
 
+          def bridge_review_to_issue(repo:, issue_number:, review_result:)
+            return unless issue_number
+
+            review_comments = review_result.dig(:review, :comments) || []
+            approved = review_comments.none? { |c| %w[critical high].include?(c[:severity]&.to_s&.downcase) }
+            @issue_tracker&.record_validation(
+              "#{repo}##{issue_number}",
+              validator: :code_review,
+              approved:  approved
+            )
+          end
+
           def handle_mesh_review_request(payload:, charter_id: nil, **)
             owner = payload[:owner] || payload['owner']
             repo = payload[:repo] || payload['repo']

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

@@ -9,8 +9,7 @@ module Legion
             files = fetch_pr_files(owner: owner, repo: repo, pull_number: pull_number)
             return { status: 'skipped', reason: 'no files' } if files.empty?
 
-            diff_text = files.map { |f| "#{f[:filename]}:\n#{f[:patch]}" }.join("\n\n")
-            review = generate_review(diff_text)
+            review = generate_review(files)
 
             {
               status:         'reviewed',
@@ -33,24 +32,43 @@ module Legion
             []
           end
 
-          def generate_review(diff_text)
-            return { summary: 'LLM unavailable', comments: [] } unless defined?(Legion::LLM)
-
-            result = Legion::LLM.chat(
-              message: "#{code_review_prompt}\n\n#{diff_text[0..12_000]}",
-              caller:  { extension: 'lex-swarm-github' }
-            )
-            ::JSON.parse(result[:content] || '{}', symbolize_names: true)
+          def generate_review(files)
+            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' })
+              parse_review_response(response)
+            end
+            merge_chunk_reviews(reviews)
           rescue StandardError => e
-            { summary: "Review failed: #{e.message}", comments: [] }
+            Legion::Logging::Logger.warn "Review generation failed: #{e.message}"
+            { summary: 'Review generation failed', comments: [] }
+          end
+
+          def merge_chunk_reviews(reviews)
+            merged_comments = reviews.flat_map { |r| r[:comments] || [] }
+            summaries = reviews.map { |r| r[:summary] }.compact
+            {
+              summary:  summaries.join("\n\n"),
+              comments: merged_comments
+            }
           end
 
-          def code_review_prompt
+          def parse_review_response(response)
+            Legion::JSON.load(response)
+          rescue StandardError
+            { summary: response.to_s, comments: [] }
+          end
+
+          def code_review_prompt(diff_text)
             <<~PROMPT
               Review this code diff. Return JSON with:
               - "summary": 1-2 sentence overall assessment
               - "comments": array of {"file", "line", "severity", "message"}
               Severity: info, warning, error. Focus on bugs and security issues.
+
+              #{diff_text}
             PROMPT
           end
         end

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

@@ -11,7 +11,7 @@ module Legion
             return { notified: false, reason: 'lex-slack not available' } unless defined?(Legion::Extensions::Slack::Client)
 
             message = format_slack_message(pull_ref: pull_ref, review: review, post_result: post_result)
-            result = Legion::Extensions::Slack::Client.new(**).post_message(
+            result = Legion::Extensions::Slack::Client.new.post_message(
               channel: channel, text: message
             )
 

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

@@ -15,7 +15,8 @@ module Legion
 
             result = Legion::Extensions::Github::Client.new.create_review(
               owner: owner, repo: repo, pull_number: pull_number,
-              body: body, comments: inline_comments
+              body: body, comments: inline_comments,
+              event: review_event(review[:comments])
             )
 
             review_id = result.dig(:result, 'id') || result.dig(:result, :id)
@@ -26,6 +27,13 @@ module Legion
 
           private
 
+          def review_event(comments)
+            severities = (comments || []).map { |c| c[:severity]&.to_s&.downcase }
+            return 'REQUEST_CHANGES' if severities.any? { |s| %w[critical high].include?(s) }
+
+            'APPROVE'
+          end
+
           def format_review_body(review)
             parts = ["**Legion AI Review** (#{review[:files_reviewed]} file#{'s' if review[:files_reviewed] != 1} reviewed)"]
             parts << ''

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

@@ -3,7 +3,7 @@
 module Legion
   module Extensions
     module SwarmGithub
-      VERSION = '0.2.3'
+      VERSION = '0.3.0'
     end
   end
 end

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

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require 'spec_helper'
+require 'legion/extensions/swarm_github/client'
 require 'legion/extensions/swarm_github/helpers/pipeline'
 require 'legion/extensions/swarm_github/helpers/mesh_integration'
 require 'legion/extensions/swarm_github/runners/pull_request_reviewer'
@@ -75,6 +76,29 @@ RSpec.describe Legion::Extensions::SwarmGithub::Runners::PrPipeline do
     end
   end
 
+  describe '#run_review_pipeline with issue bridge' do
+    let(:client) { Legion::Extensions::SwarmGithub::Client.new }
+
+    before do
+      client.ingest_issue(repo: 'owner/repo', issue_number: 5, title: 'Fix bug')
+      client.claim_issue(key: 'owner/repo#5')
+      client.start_fix(key: 'owner/repo#5')
+      allow(client).to receive(:review_pull_request).and_return(
+        { status: 'reviewed', files_reviewed: 1, summary: 'OK', comments: [] }
+      )
+      allow(client).to receive(:post_review).and_return({ posted: true, review_id: 1, comments_count: 0 })
+      allow(client).to receive(:notify_review).and_return({ notified: false, reason: 'lex-slack not available' })
+    end
+
+    context 'when PR is linked to a tracked issue' do
+      it 'records review as validation on the linked issue' do
+        client.run_review_pipeline(owner: 'owner', repo: 'repo', pull_number: 1, issue_number: 5)
+        issue = client.get_issue(key: 'owner/repo#5')[:issue]
+        expect(issue[:validations]).not_to be_empty
+      end
+    end
+  end
+
   describe '#run_review_pipeline_from_webhook' do
     let(:review_result) do
       { status: 'reviewed', pr: 'LegionIO/core#7', files_reviewed: 2,

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

@@ -45,6 +45,26 @@ RSpec.describe Legion::Extensions::SwarmGithub::Runners::PullRequestReviewer do
       end
     end
 
+    context 'when diff exceeds max_chars' do
+      let(:large_files) do
+        [
+          { filename: 'a.rb', patch: 'x' * 7000 },
+          { filename: 'b.rb', patch: 'y' * 7000 }
+        ]
+      end
+
+      before do
+        stub_const('Legion::LLM', Module.new)
+        allow(reviewer).to receive(:fetch_pr_files).and_return(large_files)
+        allow(Legion::LLM).to receive(:chat).and_return('{"summary":"ok","comments":[]}')
+      end
+
+      it 'calls LLM multiple times for chunked diffs' do
+        reviewer.review_pull_request(owner: 'owner', repo: 'repo', pull_number: 1)
+        expect(Legion::LLM).to have_received(:chat).at_least(2).times
+      end
+    end
+
     context 'when PR has multiple files with comments' do
       let(:files) do
         [

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

@@ -68,6 +68,26 @@ RSpec.describe Legion::Extensions::SwarmGithub::Runners::ReviewNotifier do
       end
     end
 
+    context 'when instantiating Slack client' do
+      let(:slack_client) { double('Slack::Client') }
+      let(:slack_client_class) { Class.new }
+
+      before do
+        stub_const('Legion::Extensions::Slack::Client', slack_client_class)
+        allow(slack_client_class).to receive(:new).and_return(slack_client)
+        allow(slack_client).to receive(:post_message).and_return({ ok: true, ts: '1' })
+      end
+
+      it 'instantiates Slack client with no arguments' do
+        notifier.notify_review(
+          channel: '#reviews', pull_ref: 'owner/repo#1',
+          review: review_result, post_result: post_result,
+          extra_kwarg: 'value'
+        )
+        expect(slack_client_class).to have_received(:new).with(no_args)
+      end
+    end
+
     context 'when lex-slack is not available' do
       it 'returns not_available' do
         result = notifier.notify_review(

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

@@ -61,6 +61,42 @@ RSpec.describe Legion::Extensions::SwarmGithub::Runners::ReviewPoster do
       end
     end
 
+    context 'when review has no critical or high severity comments' do
+      let(:github_client) { double('Github::Client') }
+      let(:review) { { status: 'reviewed', files_reviewed: 1, summary: 'Looks good', comments: [{ severity: 'info', message: 'nit' }] } }
+
+      before do
+        stub_const('Legion::Extensions::Github::Client', Class.new)
+        allow(Legion::Extensions::Github::Client).to receive(:new).and_return(github_client)
+        allow(github_client).to receive(:create_review).and_return({ result: { 'id' => 1 } })
+      end
+
+      it 'posts with APPROVE event' do
+        poster.post_review(owner: 'owner', repo: 'repo', pull_number: 1, review: review)
+        expect(github_client).to have_received(:create_review).with(
+          hash_including(event: 'APPROVE')
+        )
+      end
+    end
+
+    context 'when review has critical severity comments' do
+      let(:github_client) { double('Github::Client') }
+      let(:review) { { status: 'reviewed', files_reviewed: 1, summary: 'Issues found', comments: [{ severity: 'critical', message: 'bug' }] } }
+
+      before do
+        stub_const('Legion::Extensions::Github::Client', Class.new)
+        allow(Legion::Extensions::Github::Client).to receive(:new).and_return(github_client)
+        allow(github_client).to receive(:create_review).and_return({ result: { 'id' => 2 } })
+      end
+
+      it 'posts with REQUEST_CHANGES event' do
+        poster.post_review(owner: 'owner', repo: 'repo', pull_number: 1, review: review)
+        expect(github_client).to have_received(:create_review).with(
+          hash_including(event: 'REQUEST_CHANGES')
+        )
+      end
+    end
+
     context 'when lex-github is not available' do
       it 'returns not_available error' do
         result = poster.post_review(owner: 'org', repo: 'repo', pull_number: 42, review: review_result)

metadata

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