lex-swarm-github 0.1.2 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: d40757aca13c9bab82f57b358f6206276198c6dfd04ffa3be18c5ad4e1a967e5
-  data.tar.gz: d76193d6b724bca39020124a8131e57cc7a2746caa05237acb30c6060c39b1c0
+  metadata.gz: 164c564b62ef684027798c73f8c8137083a55e72df5f0d9204a627789a172472
+  data.tar.gz: 4368bd456b18a7af926460954c76ba8c4da25bbf2233dcdc1541c9fb6949e9ff
 SHA512:
-  metadata.gz: ff0459d83eeb35e01951212ee17867bfe8ad7f4e38f6df0af3dde9a59a193c3e15cf86b790b4994bb3484bf70cd192d0e337c93043e89c2fe0f99fe8d327e29f
-  data.tar.gz: 147be637157b8cddb282d39944ee03f5085c33ca52e2210c9788e1b8ae457b0978efd0bd29116dea418eb88a7ab8fc9e686907d7113b23f795d46c8f7d2e378d
+  metadata.gz: 022a87a111bda8aadf4517c53a70573f5cc9b95f53dad7eb9c4b7c870d695ce783084ff98e64e64b3d769ec8849e8c03112ea0f6ce55e59a9d2dd6f508a2bdb5
+  data.tar.gz: 60ac0a083878d8bfd2bce7513a91998cddb4c26e324a1160a8f9af1f6f62c05f040ebff300efef86fc399647bccad08561d4e1608e2b7a3db4420232b194f69a

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

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+require 'legion/extensions/actors/subscription'
+
+module Legion
+  module Extensions
+    module SwarmGithub
+      module Actor
+        class PrWebhook < Legion::Extensions::Actors::Subscription
+          def runner_class
+            Legion::Extensions::SwarmGithub::Runners::PrPipeline
+          end
+
+          def runner_function
+            'run_review_pipeline_from_webhook'
+          end
+
+          def check_subtask?
+            false
+          end
+
+          def generate_task?
+            false
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -3,12 +3,20 @@
 require 'legion/extensions/swarm_github/helpers/pipeline'
 require 'legion/extensions/swarm_github/helpers/issue_tracker'
 require 'legion/extensions/swarm_github/runners/github_swarm'
+require 'legion/extensions/swarm_github/runners/pull_request_reviewer'
+require 'legion/extensions/swarm_github/runners/review_poster'
+require 'legion/extensions/swarm_github/runners/review_notifier'
+require 'legion/extensions/swarm_github/runners/pr_pipeline'
 
 module Legion
   module Extensions
     module SwarmGithub
       class Client
         include Runners::GithubSwarm
+        include Runners::PullRequestReviewer
+        include Runners::ReviewPoster
+        include Runners::ReviewNotifier
+        include Runners::PrPipeline
 
         def initialize(**)
           @issue_tracker = Helpers::IssueTracker.new

data/lib/legion/extensions/swarm_github/helpers/diff_chunker.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module SwarmGithub
+      module Helpers
+        module DiffChunker
+          DEFAULT_MAX_CHARS = 12_000
+
+          module_function
+
+          def chunk_files(files, max_chars: DEFAULT_MAX_CHARS)
+            files = files.select { |f| f[:patch] && !f[:patch].empty? }
+            return [] if files.empty?
+
+            chunks = []
+            current_chunk = []
+            current_size = 0
+
+            files.each do |file|
+              patch = file[:patch]
+              patch = patch[0, max_chars] if patch.length > max_chars
+              entry = { filename: file[:filename], patch: patch }
+
+              if current_size + patch.length > max_chars && !current_chunk.empty?
+                chunks << current_chunk
+                current_chunk = []
+                current_size = 0
+              end
+
+              current_chunk << entry
+              current_size += patch.length
+            end
+
+            chunks << current_chunk unless current_chunk.empty?
+            chunks
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module SwarmGithub
+      module Runners
+        module PrPipeline
+          REVIEWABLE_ACTIONS = %w[opened synchronize reopened].freeze
+          DEFAULT_SLACK_CHANNEL = '#code-reviews'
+
+          def run_review_pipeline(owner:, repo:, pull_number:, slack_channel: nil, **)
+            channel = slack_channel || DEFAULT_SLACK_CHANNEL
+
+            review = review_pull_request(owner: owner, repo: repo, pull_number: pull_number)
+            return { review: review, post: nil, notify: nil } unless review[:status] == 'reviewed'
+
+            post = post_review(owner: owner, repo: repo, pull_number: pull_number, review: review)
+            notify = notify_review(channel: channel, pull_ref: "#{owner}/#{repo}##{pull_number}",
+                                   review: review, post_result: post)
+
+            { review: review, post: post, notify: notify }
+          end
+
+          def run_review_pipeline_from_webhook(payload:, slack_channel: nil, **)
+            action = payload['action']
+            return { skipped: true, reason: 'action not reviewable' } unless REVIEWABLE_ACTIONS.include?(action)
+
+            full_name = payload.dig('repository', 'full_name') || ''
+            owner, repo = full_name.split('/', 2)
+            pull_number = payload.dig('pull_request', 'number')
+
+            run_review_pipeline(owner: owner, repo: repo, pull_number: pull_number,
+                                slack_channel: slack_channel)
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module SwarmGithub
+      module Runners
+        module ReviewNotifier
+          def notify_review(channel:, pull_ref:, review:, post_result:, **)
+            return { notified: false, reason: 'review not posted' } unless post_result[:posted]
+
+            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(
+              channel: channel, text: message
+            )
+
+            { notified: result[:ok] == true, channel: channel, ts: result[:ts] }
+          rescue StandardError => e
+            { notified: false, reason: "slack error: #{e.message}" }
+          end
+
+          private
+
+          def format_slack_message(pull_ref:, review:, post_result:)
+            comments_count = post_result[:comments_count] || 0
+            files = review[:files_reviewed] || 0
+
+            parts = [":mag: *AI Code Review* for `#{pull_ref}` (#{files} file#{'s' if files != 1})"]
+            parts << review[:summary] if review[:summary]
+
+            parts << if comments_count.positive?
+                       ":memo: #{comments_count} comment#{'s' if comments_count != 1} posted"
+                     else
+                       ':white_check_mark: No issues found'
+                     end
+
+            parts.join("\n")
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,66 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module SwarmGithub
+      module Runners
+        module ReviewPoster
+          def post_review(owner:, repo:, pull_number:, review:, **)
+            return { posted: false, reason: 'review was skipped' } unless review[:status] == 'reviewed'
+
+            return { posted: false, reason: 'lex-github not available' } unless defined?(Legion::Extensions::Github::Client)
+
+            body = format_review_body(review)
+            inline_comments = format_inline_comments(review[:comments] || [])
+
+            result = Legion::Extensions::Github::Client.new.create_review(
+              owner: owner, repo: repo, pull_number: pull_number,
+              body: body, comments: inline_comments
+            )
+
+            review_id = result.dig(:result, 'id') || result.dig(:result, :id)
+            { posted: true, review_id: review_id, comments_count: inline_comments.size }
+          rescue StandardError => e
+            { posted: false, reason: "post failed: #{e.message}" }
+          end
+
+          private
+
+          def format_review_body(review)
+            parts = ["**Legion AI Review** (#{review[:files_reviewed]} file#{'s' if review[:files_reviewed] != 1} reviewed)"]
+            parts << ''
+            parts << review[:summary] if review[:summary]
+
+            comments = review[:comments] || []
+            if comments.any?
+              by_severity = comments.group_by { |c| c[:severity] || 'info' }
+              counts = by_severity.map { |sev, list| "#{list.size} #{sev}" }.join(', ')
+              parts << ''
+              parts << "Findings: #{counts}"
+            end
+
+            parts.join("\n")
+          end
+
+          def format_inline_comments(comments)
+            comments.filter_map do |c|
+              next unless c[:file] && c[:message]
+
+              severity_icon = case c[:severity]
+                              when 'error' then '**Error**'
+                              when 'warning' then 'Warning'
+                              else 'Note'
+                              end
+
+              {
+                path:     c[:file],
+                position: c[:line] || 1,
+                body:     "#{severity_icon}: #{c[:message]}"
+              }
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -3,7 +3,7 @@
 module Legion
   module Extensions
     module SwarmGithub
-      VERSION = '0.1.2'
+      VERSION = '0.2.0'
     end
   end
 end

data/lib/legion/extensions/swarm_github.rb

@@ -5,6 +5,10 @@ require 'legion/extensions/swarm_github/helpers/pipeline'
 require 'legion/extensions/swarm_github/helpers/issue_tracker'
 require 'legion/extensions/swarm_github/runners/github_swarm'
 require 'legion/extensions/swarm_github/runners/pull_request_reviewer'
+require 'legion/extensions/swarm_github/helpers/diff_chunker'
+require 'legion/extensions/swarm_github/runners/review_poster'
+require 'legion/extensions/swarm_github/runners/review_notifier'
+require 'legion/extensions/swarm_github/runners/pr_pipeline'
 
 module Legion
   module Extensions

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

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+# Stub base class for actor
+unless defined?(Legion::Extensions::Actors::Subscription)
+  module Legion
+    module Extensions
+      module Actors
+        class Subscription
+          def initialize(**); end
+        end
+      end
+    end
+  end
+  $LOADED_FEATURES << 'legion/extensions/actors/subscription'
+end
+
+require 'legion/extensions/swarm_github/actors/pr_webhook'
+
+RSpec.describe Legion::Extensions::SwarmGithub::Actor::PrWebhook do
+  let(:actor) { described_class.allocate }
+
+  it 'defines runner_class as PrPipeline' do
+    expect(actor.runner_class).to eq(Legion::Extensions::SwarmGithub::Runners::PrPipeline)
+  end
+
+  it 'defines runner_function as run_review_pipeline_from_webhook' do
+    expect(actor.runner_function).to eq('run_review_pipeline_from_webhook')
+  end
+
+  it 'does not check subtasks' do
+    expect(actor.check_subtask?).to be false
+  end
+
+  it 'does not generate tasks' do
+    expect(actor.generate_task?).to be false
+  end
+end

data/spec/legion/extensions/swarm_github/helpers/diff_chunker_spec.rb

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+require 'legion/extensions/swarm_github/helpers/diff_chunker'
+
+RSpec.describe Legion::Extensions::SwarmGithub::Helpers::DiffChunker do
+  describe '.chunk_files' do
+    let(:small_file) { { filename: 'a.rb', patch: '+ line1' } }
+    let(:large_patch) { "+ #{'x' * 6000}" }
+    let(:large_file) { { filename: 'b.rb', patch: large_patch } }
+
+    it 'returns a single chunk when files fit within limit' do
+      chunks = described_class.chunk_files([small_file], max_chars: 4000)
+      expect(chunks.size).to eq(1)
+      expect(chunks.first.size).to eq(1)
+      expect(chunks.first.first[:filename]).to eq('a.rb')
+    end
+
+    it 'splits files into multiple chunks when total exceeds limit' do
+      files = [small_file, large_file]
+      chunks = described_class.chunk_files(files, max_chars: 4000)
+      expect(chunks.size).to eq(2)
+    end
+
+    it 'truncates a single file patch that exceeds the limit' do
+      chunks = described_class.chunk_files([large_file], max_chars: 1000)
+      expect(chunks.size).to eq(1)
+      expect(chunks.first.first[:patch].length).to be <= 1000
+    end
+
+    it 'preserves filename in each chunk entry' do
+      chunks = described_class.chunk_files([small_file, large_file], max_chars: 4000)
+      all_files = chunks.flatten.map { |f| f[:filename] }
+      expect(all_files).to include('a.rb', 'b.rb')
+    end
+
+    it 'uses default max_chars of 12000' do
+      files = Array.new(5) { |i| { filename: "f#{i}.rb", patch: "+ #{'y' * 3000}" } }
+      chunks = described_class.chunk_files(files)
+      expect(chunks.size).to be > 1
+    end
+
+    it 'handles empty file list' do
+      chunks = described_class.chunk_files([])
+      expect(chunks).to eq([])
+    end
+
+    it 'skips files with nil patch' do
+      nil_patch = { filename: 'binary.png', patch: nil }
+      chunks = described_class.chunk_files([nil_patch, small_file])
+      all_files = chunks.flatten.map { |f| f[:filename] }
+      expect(all_files).not_to include('binary.png')
+      expect(all_files).to include('a.rb')
+    end
+  end
+end

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

@@ -0,0 +1,112 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+require 'legion/extensions/swarm_github/helpers/pipeline'
+require 'legion/extensions/swarm_github/runners/pull_request_reviewer'
+require 'legion/extensions/swarm_github/runners/review_poster'
+require 'legion/extensions/swarm_github/runners/review_notifier'
+require 'legion/extensions/swarm_github/runners/pr_pipeline'
+
+RSpec.describe Legion::Extensions::SwarmGithub::Runners::PrPipeline do
+  let(:pipeline) do
+    klass = Class.new do
+      include Legion::Extensions::SwarmGithub::Runners::PullRequestReviewer
+      include Legion::Extensions::SwarmGithub::Runners::ReviewPoster
+      include Legion::Extensions::SwarmGithub::Runners::ReviewNotifier
+      include Legion::Extensions::SwarmGithub::Runners::PrPipeline
+    end
+    klass.new
+  end
+
+  describe '#run_review_pipeline' do
+    let(:review_result) do
+      { status: 'reviewed', pr: 'org/repo#1', files_reviewed: 2,
+        summary: 'OK', comments: [] }
+    end
+    let(:post_result) { { posted: true, review_id: 1, comments_count: 0 } }
+    let(:notify_result) { { notified: true } }
+
+    before do
+      allow(pipeline).to receive(:review_pull_request).and_return(review_result)
+      allow(pipeline).to receive(:post_review).and_return(post_result)
+      allow(pipeline).to receive(:notify_review).and_return(notify_result)
+    end
+
+    it 'calls review, post, notify in sequence' do
+      expect(pipeline).to receive(:review_pull_request).ordered
+      expect(pipeline).to receive(:post_review).ordered
+      expect(pipeline).to receive(:notify_review).ordered
+
+      pipeline.run_review_pipeline(owner: 'org', repo: 'repo', pull_number: 1)
+    end
+
+    it 'returns combined result' do
+      result = pipeline.run_review_pipeline(owner: 'org', repo: 'repo', pull_number: 1)
+      expect(result[:review][:status]).to eq('reviewed')
+      expect(result[:post][:posted]).to be true
+      expect(result[:notify][:notified]).to be true
+    end
+
+    it 'passes slack_channel to notify' do
+      expect(pipeline).to receive(:notify_review).with(hash_including(channel: '#my-reviews'))
+
+      pipeline.run_review_pipeline(owner: 'org', repo: 'repo', pull_number: 1,
+                                   slack_channel: '#my-reviews')
+    end
+
+    it 'uses default channel when none provided' do
+      expect(pipeline).to receive(:notify_review).with(hash_including(channel: '#code-reviews'))
+
+      pipeline.run_review_pipeline(owner: 'org', repo: 'repo', pull_number: 1)
+    end
+
+    it 'skips post and notify when review is skipped' do
+      allow(pipeline).to receive(:review_pull_request)
+        .and_return({ status: 'skipped', reason: 'no files' })
+
+      expect(pipeline).not_to receive(:post_review)
+      expect(pipeline).not_to receive(:notify_review)
+
+      result = pipeline.run_review_pipeline(owner: 'org', repo: 'repo', pull_number: 1)
+      expect(result[:review][:status]).to eq('skipped')
+      expect(result[:post]).to be_nil
+      expect(result[:notify]).to be_nil
+    end
+  end
+
+  describe '#run_review_pipeline_from_webhook' do
+    let(:review_result) do
+      { status: 'reviewed', pr: 'LegionIO/core#7', files_reviewed: 2,
+        summary: 'OK', comments: [] }
+    end
+
+    before do
+      allow(pipeline).to receive(:review_pull_request).and_return(review_result)
+      allow(pipeline).to receive(:post_review).and_return({ posted: true, review_id: 1, comments_count: 0 })
+      allow(pipeline).to receive(:notify_review).and_return({ notified: true })
+    end
+
+    it 'extracts owner, repo, pull_number from pull_request event' do
+      payload = {
+        'action'       => 'opened',
+        'pull_request' => { 'number' => 7 },
+        'repository'   => { 'full_name' => 'LegionIO/core' }
+      }
+
+      expect(pipeline).to receive(:review_pull_request)
+        .with(hash_including(owner: 'LegionIO', repo: 'core', pull_number: 7))
+        .and_return(review_result)
+
+      pipeline.run_review_pipeline_from_webhook(payload: payload)
+    end
+
+    it 'ignores non-reviewable actions' do
+      payload = { 'action' => 'closed', 'pull_request' => { 'number' => 1 },
+                  'repository' => { 'full_name' => 'a/b' } }
+
+      result = pipeline.run_review_pipeline_from_webhook(payload: payload)
+      expect(result[:skipped]).to be true
+      expect(result[:reason]).to eq('action not reviewable')
+    end
+  end
+end

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

@@ -0,0 +1,95 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+require 'legion/extensions/swarm_github/runners/review_notifier'
+
+RSpec.describe Legion::Extensions::SwarmGithub::Runners::ReviewNotifier do
+  let(:notifier) { Class.new { include Legion::Extensions::SwarmGithub::Runners::ReviewNotifier }.new }
+
+  describe '#notify_review' do
+    let(:review_result) do
+      {
+        status: 'reviewed', pr: 'org/repo#42', files_reviewed: 3,
+        summary: 'Found 1 issue',
+        comments: [{ file: 'lib/foo.rb', severity: 'error', message: 'Bug' }]
+      }
+    end
+
+    let(:post_result) { { posted: true, review_id: 999, comments_count: 1 } }
+
+    context 'when lex-slack is available' do
+      let(:slack_client) { double('Slack::Client') }
+
+      before do
+        stub_const('Legion::Extensions::Slack::Client', Class.new)
+        allow(Legion::Extensions::Slack::Client).to receive(:new).and_return(slack_client)
+      end
+
+      it 'posts a summary to the configured channel' do
+        expect(slack_client).to receive(:post_message) do |args|
+          expect(args[:channel]).to eq('#code-review')
+          expect(args[:text]).to include('org/repo#42')
+          expect(args[:text]).to include('3 file')
+          { ok: true, ts: '123.456' }
+        end
+
+        result = notifier.notify_review(
+          channel: '#code-review', pull_ref: 'org/repo#42',
+          review: review_result, post_result: post_result
+        )
+        expect(result[:notified]).to be true
+      end
+
+      it 'includes comment count in message' do
+        expect(slack_client).to receive(:post_message) do |args|
+          expect(args[:text]).to include('1 comment')
+          { ok: true, ts: '1' }
+        end
+
+        notifier.notify_review(
+          channel: '#reviews', pull_ref: 'org/repo#42',
+          review: review_result, post_result: post_result
+        )
+      end
+
+      it 'sends clean message when review had no issues' do
+        clean_review = review_result.merge(comments: [], summary: 'All clear')
+        clean_post = post_result.merge(comments_count: 0)
+
+        expect(slack_client).to receive(:post_message) do |args|
+          expect(args[:text]).to include('No issues found')
+          { ok: true, ts: '1' }
+        end
+
+        notifier.notify_review(
+          channel: '#reviews', pull_ref: 'org/repo#42',
+          review: clean_review, post_result: clean_post
+        )
+      end
+    end
+
+    context 'when lex-slack is not available' do
+      it 'returns not_available' do
+        result = notifier.notify_review(
+          channel: '#reviews', pull_ref: 'org/repo#42',
+          review: review_result, post_result: post_result
+        )
+        expect(result[:notified]).to be false
+        expect(result[:reason]).to eq('lex-slack not available')
+      end
+    end
+
+    context 'when review was not posted' do
+      let(:failed_post) { { posted: false, reason: 'lex-github not available' } }
+
+      it 'skips notification' do
+        result = notifier.notify_review(
+          channel: '#reviews', pull_ref: 'org/repo#42',
+          review: review_result, post_result: failed_post
+        )
+        expect(result[:notified]).to be false
+        expect(result[:reason]).to eq('review not posted')
+      end
+    end
+  end
+end

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

@@ -0,0 +1,82 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+require 'legion/extensions/swarm_github/runners/review_poster'
+
+RSpec.describe Legion::Extensions::SwarmGithub::Runners::ReviewPoster do
+  let(:poster) { Class.new { include Legion::Extensions::SwarmGithub::Runners::ReviewPoster }.new }
+
+  describe '#post_review' do
+    let(:review_result) do
+      {
+        status: 'reviewed', pr: 'org/repo#42', files_reviewed: 3,
+        summary: 'Found 1 issue',
+        comments: [{ file: 'lib/foo.rb', line: 10, severity: 'error', message: 'SQL injection' }]
+      }
+    end
+
+    context 'when lex-github is available' do
+      let(:github_client) { double('Github::Client') }
+
+      before do
+        stub_const('Legion::Extensions::Github::Client', Class.new)
+        allow(Legion::Extensions::Github::Client).to receive(:new).and_return(github_client)
+      end
+
+      it 'posts a review to GitHub with formatted body' do
+        expect(github_client).to receive(:create_review) do |args|
+          expect(args[:owner]).to eq('org')
+          expect(args[:repo]).to eq('repo')
+          expect(args[:pull_number]).to eq(42)
+          expect(args[:body]).to include('Found 1 issue')
+          expect(args[:body]).to include('3 file')
+          { result: { 'id' => 999 } }
+        end
+
+        result = poster.post_review(owner: 'org', repo: 'repo', pull_number: 42, review: review_result)
+        expect(result[:posted]).to be true
+        expect(result[:review_id]).to eq(999)
+      end
+
+      it 'converts comments to GitHub inline format' do
+        expect(github_client).to receive(:create_review) do |args|
+          expect(args[:comments].size).to eq(1)
+          expect(args[:comments].first[:path]).to eq('lib/foo.rb')
+          expect(args[:comments].first[:body]).to include('SQL injection')
+          { result: { 'id' => 999 } }
+        end
+
+        poster.post_review(owner: 'org', repo: 'repo', pull_number: 42, review: review_result)
+      end
+
+      it 'handles review with no comments' do
+        no_comments = review_result.merge(comments: [], summary: 'All clear')
+        expect(github_client).to receive(:create_review) do |args|
+          expect(args[:comments]).to eq([])
+          { result: { 'id' => 1 } }
+        end
+
+        result = poster.post_review(owner: 'org', repo: 'repo', pull_number: 42, review: no_comments)
+        expect(result[:posted]).to be true
+      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)
+        expect(result[:posted]).to be false
+        expect(result[:reason]).to eq('lex-github not available')
+      end
+    end
+
+    context 'when review was skipped' do
+      let(:skipped) { { status: 'skipped', reason: 'no files' } }
+
+      it 'returns skipped without posting' do
+        result = poster.post_review(owner: 'org', repo: 'repo', pull_number: 1, review: skipped)
+        expect(result[:posted]).to be false
+        expect(result[:reason]).to eq('review was skipped')
+      end
+    end
+  end
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: lex-swarm-github
 version: !ruby/object:Gem::Version
-  version: 0.1.2
+  version: 0.2.0
 platform: ruby
 authors:
 - Esity
@@ -20,19 +20,29 @@ files:
 - Gemfile
 - lex-swarm-github.gemspec
 - lib/legion/extensions/swarm_github.rb
+- lib/legion/extensions/swarm_github/actors/pr_webhook.rb
 - lib/legion/extensions/swarm_github/actors/stale_issues.rb
 - lib/legion/extensions/swarm_github/client.rb
+- lib/legion/extensions/swarm_github/helpers/diff_chunker.rb
 - lib/legion/extensions/swarm_github/helpers/issue_tracker.rb
 - lib/legion/extensions/swarm_github/helpers/pipeline.rb
 - lib/legion/extensions/swarm_github/runners/github_swarm.rb
+- lib/legion/extensions/swarm_github/runners/pr_pipeline.rb
 - lib/legion/extensions/swarm_github/runners/pull_request_reviewer.rb
+- lib/legion/extensions/swarm_github/runners/review_notifier.rb
+- lib/legion/extensions/swarm_github/runners/review_poster.rb
 - lib/legion/extensions/swarm_github/version.rb
+- spec/legion/extensions/swarm_github/actors/pr_webhook_spec.rb
 - spec/legion/extensions/swarm_github/actors/stale_issues_spec.rb
 - spec/legion/extensions/swarm_github/client_spec.rb
+- spec/legion/extensions/swarm_github/helpers/diff_chunker_spec.rb
 - spec/legion/extensions/swarm_github/helpers/issue_tracker_spec.rb
 - spec/legion/extensions/swarm_github/helpers/pipeline_spec.rb
 - spec/legion/extensions/swarm_github/runners/github_swarm_spec.rb
+- spec/legion/extensions/swarm_github/runners/pr_pipeline_spec.rb
 - spec/legion/extensions/swarm_github/runners/pull_request_reviewer_spec.rb
+- spec/legion/extensions/swarm_github/runners/review_notifier_spec.rb
+- spec/legion/extensions/swarm_github/runners/review_poster_spec.rb
 - spec/spec_helper.rb
 homepage: https://github.com/LegionIO/lex-swarm-github
 licenses: