lex-swarm-github 0.2.0 → 0.2.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 164c564b62ef684027798c73f8c8137083a55e72df5f0d9204a627789a172472
-  data.tar.gz: 4368bd456b18a7af926460954c76ba8c4da25bbf2233dcdc1541c9fb6949e9ff
+  metadata.gz: 51af406fe3fd169d214ad624baa8397ea249af6fd6b2931ce0c16e05476b3089
+  data.tar.gz: dff84459e2f0fb6966b1942c271feac122d146d31f44a32a1e3949db3296b7fd
 SHA512:
-  metadata.gz: 022a87a111bda8aadf4517c53a70573f5cc9b95f53dad7eb9c4b7c870d695ce783084ff98e64e64b3d769ec8849e8c03112ea0f6ce55e59a9d2dd6f508a2bdb5
-  data.tar.gz: 60ac0a083878d8bfd2bce7513a91998cddb4c26e324a1160a8f9af1f6f62c05f040ebff300efef86fc399647bccad08561d4e1608e2b7a3db4420232b194f69a
+  metadata.gz: 185c32b2089ea81b7d714437c5ea2a468e6e20114831c466466905b548fe499ff1c7734bc6a76cf5fcdad91c279bd56baa0887e5519fdf7c15c58b1c6c5026c4
+  data.tar.gz: f17146fded2ba6da1e07e742aaec32f942d2efa8501a66958fbdb00bf15c9c9aa2f308048cd54b1332b7f5009a2e3cf6f20de92d372b3ca53cfa914ee93bb6bb

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

@@ -0,0 +1,61 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module SwarmGithub
+      module Helpers
+        module MeshIntegration
+          AGENT_ID = 'swarm-github-code-reviewer'
+          CAPABILITIES = %i[code_review pr_review].freeze
+
+          module_function
+
+          def register_reviewer
+            return { skipped: true, reason: 'lex-mesh not available' } unless mesh_available?
+
+            Legion::Extensions::Mesh::Client.new.register(
+              agent_id:     AGENT_ID,
+              capabilities: CAPABILITIES,
+              endpoint:     'local'
+            )
+          end
+
+          def record_review_start(charter_id:, owner:, repo:, pull_number:)
+            return unless workspace_available?
+
+            Legion::Extensions::Swarm::Client.new.workspace_put(
+              charter_id: charter_id,
+              key:        "review:#{owner}/#{repo}##{pull_number}",
+              value:      { status: 'in_progress', started_at: Time.now.utc.to_s },
+              author:     AGENT_ID
+            )
+          end
+
+          def record_review_complete(charter_id:, owner:, repo:, pull_number:, result:)
+            return unless workspace_available?
+
+            Legion::Extensions::Swarm::Client.new.workspace_put(
+              charter_id: charter_id,
+              key:        "review:#{owner}/#{repo}##{pull_number}",
+              value:      {
+                status:         result[:review]&.dig(:status) || 'unknown',
+                posted:         result[:post]&.dig(:posted) || false,
+                comments_count: result[:post]&.dig(:comments_count) || 0,
+                completed_at:   Time.now.utc.to_s
+              },
+              author:     AGENT_ID
+            )
+          end
+
+          def mesh_available?
+            defined?(Legion::Extensions::Mesh::Client)
+          end
+
+          def workspace_available?
+            defined?(Legion::Extensions::Swarm::Client)
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require_relative '../helpers/mesh_integration'
+
 module Legion
   module Extensions
     module SwarmGithub
@@ -32,6 +34,27 @@ module Legion
             run_review_pipeline(owner: owner, repo: repo, pull_number: pull_number,
                                 slack_channel: slack_channel)
           end
+
+          def handle_mesh_review_request(payload:, charter_id: nil, **)
+            owner = payload[:owner] || payload['owner']
+            repo = payload[:repo] || payload['repo']
+            pull_number = payload[:pull_number] || payload['pull_number']
+
+            return { success: false, reason: :missing_params } unless owner && repo && pull_number
+
+            cid = charter_id || "mesh-review-#{owner}-#{repo}-#{pull_number}"
+            Helpers::MeshIntegration.record_review_start(
+              charter_id: cid, owner: owner, repo: repo, pull_number: pull_number
+            )
+
+            result = run_review_pipeline(owner: owner, repo: repo, pull_number: pull_number)
+
+            Helpers::MeshIntegration.record_review_complete(
+              charter_id: cid, owner: owner, repo: repo, pull_number: pull_number, result: result
+            )
+
+            result.merge(success: true)
+          end
         end
       end
     end

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

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

data/lib/legion/extensions/swarm_github.rb

@@ -3,6 +3,7 @@
 require 'legion/extensions/swarm_github/version'
 require 'legion/extensions/swarm_github/helpers/pipeline'
 require 'legion/extensions/swarm_github/helpers/issue_tracker'
+require 'legion/extensions/swarm_github/helpers/mesh_integration'
 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'

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

@@ -0,0 +1,155 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+require 'legion/extensions/swarm_github/helpers/mesh_integration'
+
+RSpec.describe Legion::Extensions::SwarmGithub::Helpers::MeshIntegration do
+  subject(:mod) { described_class }
+
+  describe '.mesh_available?' do
+    it 'returns falsy when Mesh::Client is not defined' do
+      expect(mod.mesh_available?).to be_falsy
+    end
+
+    it 'returns truthy when Mesh::Client is defined' do
+      stub_const('Legion::Extensions::Mesh::Client', Class.new)
+      expect(mod.mesh_available?).to be_truthy
+    end
+  end
+
+  describe '.workspace_available?' do
+    it 'returns falsy when Swarm::Client is not defined' do
+      expect(mod.workspace_available?).to be_falsy
+    end
+
+    it 'returns truthy when Swarm::Client is defined' do
+      stub_const('Legion::Extensions::Swarm::Client', Class.new)
+      expect(mod.workspace_available?).to be_truthy
+    end
+  end
+
+  describe '.register_reviewer' do
+    context 'when lex-mesh is not available' do
+      it 'returns skipped hash' do
+        result = mod.register_reviewer
+        expect(result[:skipped]).to be true
+        expect(result[:reason]).to eq('lex-mesh not available')
+      end
+    end
+
+    context 'when lex-mesh is available' do
+      let(:mesh_client) { instance_double('Legion::Extensions::Mesh::Client') }
+
+      before do
+        stub_const('Legion::Extensions::Mesh::Client', Class.new)
+        allow(Legion::Extensions::Mesh::Client).to receive(:new).and_return(mesh_client)
+        allow(mesh_client).to receive(:register).and_return({ success: true, registered: true,
+                                                              agent_id: described_class::AGENT_ID })
+      end
+
+      it 'calls register on a Mesh::Client instance' do
+        expect(mesh_client).to receive(:register).with(
+          agent_id:     described_class::AGENT_ID,
+          capabilities: described_class::CAPABILITIES,
+          endpoint:     'local'
+        )
+        mod.register_reviewer
+      end
+
+      it 'returns the registration result' do
+        result = mod.register_reviewer
+        expect(result[:success]).to be true
+        expect(result[:registered]).to be true
+      end
+    end
+  end
+
+  describe '.record_review_start' do
+    let(:params) { { charter_id: 'cid-1', owner: 'org', repo: 'myrepo', pull_number: 42 } }
+
+    context 'when lex-swarm is not available' do
+      it 'returns nil' do
+        expect(mod.record_review_start(**params)).to be_nil
+      end
+    end
+
+    context 'when lex-swarm is available' do
+      let(:swarm_client) { instance_double('Legion::Extensions::Swarm::Client') }
+
+      before do
+        stub_const('Legion::Extensions::Swarm::Client', Class.new)
+        allow(Legion::Extensions::Swarm::Client).to receive(:new).and_return(swarm_client)
+        allow(swarm_client).to receive(:workspace_put).and_return({ success: true })
+      end
+
+      it 'calls workspace_put with in_progress status' do
+        expect(swarm_client).to receive(:workspace_put).with(
+          charter_id: 'cid-1',
+          key:        'review:org/myrepo#42',
+          value:      hash_including(status: 'in_progress'),
+          author:     described_class::AGENT_ID
+        )
+        mod.record_review_start(**params)
+      end
+
+      it 'includes started_at timestamp' do
+        expect(swarm_client).to receive(:workspace_put).with(
+          hash_including(value: hash_including(:started_at))
+        )
+        mod.record_review_start(**params)
+      end
+    end
+  end
+
+  describe '.record_review_complete' do
+    let(:result) do
+      {
+        review: { status: 'reviewed' },
+        post:   { posted: true, comments_count: 3 },
+        notify: { notified: true }
+      }
+    end
+    let(:params) { { charter_id: 'cid-1', owner: 'org', repo: 'myrepo', pull_number: 42, result: result } }
+
+    context 'when lex-swarm is not available' do
+      it 'returns nil' do
+        expect(mod.record_review_complete(**params)).to be_nil
+      end
+    end
+
+    context 'when lex-swarm is available' do
+      let(:swarm_client) { instance_double('Legion::Extensions::Swarm::Client') }
+
+      before do
+        stub_const('Legion::Extensions::Swarm::Client', Class.new)
+        allow(Legion::Extensions::Swarm::Client).to receive(:new).and_return(swarm_client)
+        allow(swarm_client).to receive(:workspace_put).and_return({ success: true })
+      end
+
+      it 'calls workspace_put with final status from result' do
+        expect(swarm_client).to receive(:workspace_put).with(
+          charter_id: 'cid-1',
+          key:        'review:org/myrepo#42',
+          value:      hash_including(status: 'reviewed', posted: true, comments_count: 3),
+          author:     described_class::AGENT_ID
+        )
+        mod.record_review_complete(**params)
+      end
+
+      it 'includes completed_at timestamp' do
+        expect(swarm_client).to receive(:workspace_put).with(
+          hash_including(value: hash_including(:completed_at))
+        )
+        mod.record_review_complete(**params)
+      end
+
+      it 'handles missing review status gracefully' do
+        result_no_status = { review: nil, post: nil, notify: nil }
+        expect(swarm_client).to receive(:workspace_put).with(
+          hash_including(value: hash_including(status: 'unknown', posted: false, comments_count: 0))
+        )
+        mod.record_review_complete(**params, result: result_no_status)
+      end
+    end
+  end
+end

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

@@ -2,6 +2,7 @@
 
 require 'spec_helper'
 require 'legion/extensions/swarm_github/helpers/pipeline'
+require 'legion/extensions/swarm_github/helpers/mesh_integration'
 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'
@@ -109,4 +110,89 @@ RSpec.describe Legion::Extensions::SwarmGithub::Runners::PrPipeline do
       expect(result[:reason]).to eq('action not reviewable')
     end
   end
+
+  describe '#handle_mesh_review_request' do
+    let(:review_result) do
+      { review: { status: 'reviewed' }, post: { posted: true, comments_count: 2 }, notify: { notified: true } }
+    end
+
+    before do
+      allow(pipeline).to receive(:run_review_pipeline).and_return(review_result)
+      allow(Legion::Extensions::SwarmGithub::Helpers::MeshIntegration).to receive(:record_review_start)
+      allow(Legion::Extensions::SwarmGithub::Helpers::MeshIntegration).to receive(:record_review_complete)
+    end
+
+    it 'returns success: false when owner is missing' do
+      result = pipeline.handle_mesh_review_request(payload: { repo: 'myrepo', pull_number: 1 })
+      expect(result[:success]).to be false
+      expect(result[:reason]).to eq(:missing_params)
+    end
+
+    it 'returns success: false when repo is missing' do
+      result = pipeline.handle_mesh_review_request(payload: { owner: 'org', pull_number: 1 })
+      expect(result[:success]).to be false
+      expect(result[:reason]).to eq(:missing_params)
+    end
+
+    it 'returns success: false when pull_number is missing' do
+      result = pipeline.handle_mesh_review_request(payload: { owner: 'org', repo: 'myrepo' })
+      expect(result[:success]).to be false
+      expect(result[:reason]).to eq(:missing_params)
+    end
+
+    it 'calls run_review_pipeline with extracted params' do
+      expect(pipeline).to receive(:run_review_pipeline)
+        .with(hash_including(owner: 'org', repo: 'myrepo', pull_number: 42))
+        .and_return(review_result)
+
+      pipeline.handle_mesh_review_request(payload: { owner: 'org', repo: 'myrepo', pull_number: 42 })
+    end
+
+    it 'merges success: true into pipeline result' do
+      result = pipeline.handle_mesh_review_request(
+        payload: { owner: 'org', repo: 'myrepo', pull_number: 42 }
+      )
+      expect(result[:success]).to be true
+      expect(result[:review][:status]).to eq('reviewed')
+    end
+
+    it 'accepts string-keyed payload' do
+      expect(pipeline).to receive(:run_review_pipeline)
+        .with(hash_including(owner: 'org', repo: 'myrepo', pull_number: 5))
+        .and_return(review_result)
+
+      pipeline.handle_mesh_review_request(payload: { 'owner' => 'org', 'repo' => 'myrepo', 'pull_number' => 5 })
+    end
+
+    it 'records workspace start before pipeline runs' do
+      expect(Legion::Extensions::SwarmGithub::Helpers::MeshIntegration).to receive(:record_review_start).ordered
+      expect(pipeline).to receive(:run_review_pipeline).ordered.and_return(review_result)
+
+      pipeline.handle_mesh_review_request(payload: { owner: 'org', repo: 'myrepo', pull_number: 1 })
+    end
+
+    it 'records workspace complete after pipeline runs' do
+      expect(pipeline).to receive(:run_review_pipeline).ordered.and_return(review_result)
+      expect(Legion::Extensions::SwarmGithub::Helpers::MeshIntegration).to receive(:record_review_complete).ordered
+
+      pipeline.handle_mesh_review_request(payload: { owner: 'org', repo: 'myrepo', pull_number: 1 })
+    end
+
+    it 'uses provided charter_id for workspace calls' do
+      expect(Legion::Extensions::SwarmGithub::Helpers::MeshIntegration).to receive(:record_review_start)
+        .with(hash_including(charter_id: 'my-charter'))
+
+      pipeline.handle_mesh_review_request(
+        payload:    { owner: 'org', repo: 'myrepo', pull_number: 1 },
+        charter_id: 'my-charter'
+      )
+    end
+
+    it 'generates a charter_id when none provided' do
+      expect(Legion::Extensions::SwarmGithub::Helpers::MeshIntegration).to receive(:record_review_start)
+        .with(hash_including(charter_id: 'mesh-review-org-myrepo-42'))
+
+      pipeline.handle_mesh_review_request(payload: { owner: 'org', repo: 'myrepo', pull_number: 42 })
+    end
+  end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: lex-swarm-github
 version: !ruby/object:Gem::Version
-  version: 0.2.0
+  version: 0.2.1
 platform: ruby
 authors:
 - Esity
@@ -25,6 +25,7 @@ files:
 - 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/mesh_integration.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
@@ -37,6 +38,7 @@ files:
 - 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/mesh_integration_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