lex-github 0.3.5 → 0.3.6

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: e3d7a7f7bb14416475d247ced95d050133ca186ba90b27def22a2eb650f9f281
-  data.tar.gz: 18ebc886fae52273743d338ea6d8c392427c11ce247221abd34bcf4ecc431109
+  metadata.gz: 345057d3d4b8e4716221915d9f398ec586cbc5485674e07b3fd9cf79788fb281
+  data.tar.gz: d3a320f5202c7c77115b1ab28d7a65f2c975fe063864634ffadcb526b8370a65
 SHA512:
-  metadata.gz: 392c217ec7e3cbfe66f594ee7d61d226ddaafa70d641034e7ef4da8cd3f6e043e6413b056ebe2c550306e47c3674c0d21fe9bfa2d726ae6dbb09d11d6e2e8912
-  data.tar.gz: '09c432cd5d0f1b50c9f5dbc375d2301b56b6a21a0fc15880471c9b11c3c717858bda02ff4c88212eb652e41127f438d00ec0b08c5de2b2c951913bde8a6e88e5'
+  metadata.gz: c84b0641ad42300d82b2b073133bacacf9ab7aa89ccd7fb859ab16daf771f69d86102d2261fe36d785bbb09b9d48f1170dd463be08886e76388d670eb1184556
+  data.tar.gz: 3c0a0a2ab0861ec6eda83e1f1067e791583b556fe0d9166e072a8bba1f97cd458c874715ee88e74868a89aae64d3bcd9b0a75e8e3d4a8ba9f2396cd3f3559306

data/CHANGELOG.md

@@ -2,6 +2,14 @@
 
 ## [Unreleased]
 
+## [0.3.6] - 2026-04-14
+
+### Added
+- `Absorbers::Issues`: normalizes GitHub issue webhook events to fleet work items; filters bot-generated events, already-claimed issues (fleet labels), and ignored actions; stores raw payload in Redis; publishes to assessor queue
+- `Absorbers::IssuesActor`: subscription actor with `pattern 'github.issues.*'` that delegates to `Absorbers::Issues`
+- `Absorbers::WebhookSetup`: mixin for idempotent webhook registration and fleet label creation (`fleet:received`, `fleet:implementing`, `fleet:pr-open`, `fleet:escalated`) on target repos
+- `Absorbers::Helpers`: shared utilities — `bot_generated?`, `has_fleet_label?`, `ignored?`, `work_item_fingerprint`, `generate_work_item_id`, `transport_connected?`
+
 ## [0.3.5] - 2026-04-13
 
 ### Added

data/lib/legion/extensions/github/absorbers/actor.rb

@@ -0,0 +1,49 @@
+# lib/legion/extensions/github/absorbers/actor.rb
+# frozen_string_literal: true
+
+require_relative 'issues'
+
+module Legion
+  module Extensions
+    module Github
+      module Absorbers
+        # Subscription actor that listens on the absorber queue and delegates
+        # to the Issues absorber module.
+        #
+        # Queue: lex.github.absorbers.issues.absorb
+        # Exchange: lex.github
+        # Routing key: lex.github.absorbers.issues.absorb
+        #
+        # Per Wire Protocol section 17, absorber queues follow the pattern:
+        #   lex.{lex_name}.absorbers.{absorber_name}.absorb
+        class IssuesActor < Legion::Extensions::Actors::Subscription
+          pattern 'github.issues.*'
+
+          def absorb(payload:, **)
+            Legion::Extensions::Github::Absorbers::Issues.absorb(payload: payload)
+          end
+
+          def runner_class
+            Legion::Extensions::Github::Absorbers::Issues
+          end
+
+          def runner_function
+            'absorb'
+          end
+
+          def use_runner?
+            false
+          end
+
+          def check_subtask?
+            false
+          end
+
+          def generate_task?
+            false
+          end
+        end
+      end
+    end
+  end
+end

data/lib/legion/extensions/github/absorbers/helpers.rb

@@ -0,0 +1,68 @@
+# lib/legion/extensions/github/absorbers/helpers.rb
+# frozen_string_literal: true
+
+require 'digest'
+require 'securerandom'
+
+module Legion
+  module Extensions
+    module Github
+      module Absorbers
+        module Helpers
+          FLEET_LABELS = %w[
+            fleet:received fleet:implementing fleet:pr-open fleet:escalated
+          ].freeze
+
+          IGNORED_ACTIONS = %w[
+            closed transferred deleted pinned unpinned milestoned demilestoned
+          ].freeze
+
+          BOT_PATTERNS = /\[bot\]\z/i
+
+          def bot_generated?(payload)
+            sender = payload['sender'] || payload[:sender]
+            return false unless sender
+
+            login = sender['login'] || sender[:login] || ''
+            type = sender['type'] || sender[:type] || ''
+
+            type.downcase == 'bot' || login.match?(BOT_PATTERNS)
+          end
+
+          def has_fleet_label?(payload) # rubocop:disable Naming/PredicatePrefix
+            issue = payload['issue'] || payload[:issue]
+            return false unless issue
+
+            labels = issue['labels'] || issue[:labels] || []
+            labels.any? do |label|
+              name = label['name'] || label[:name]
+              FLEET_LABELS.include?(name)
+            end
+          end
+
+          def ignored?(payload)
+            action = payload['action'] || payload[:action]
+            IGNORED_ACTIONS.include?(action.to_s)
+          end
+
+          def work_item_fingerprint(source:, ref:, title:)
+            input = "#{source}:#{ref}:#{title}"
+            Digest::SHA256.hexdigest(input)
+          end
+
+          def generate_work_item_id
+            SecureRandom.uuid
+          end
+
+          def transport_connected?
+            return false unless defined?(Legion::Settings)
+
+            !!Legion::Settings.dig(:transport, :connected)
+          rescue StandardError => _e
+            false
+          end
+        end
+      end
+    end
+  end
+end

data/lib/legion/extensions/github/absorbers/issues.rb

@@ -0,0 +1,200 @@
+# lib/legion/extensions/github/absorbers/issues.rb
+# frozen_string_literal: true
+
+require_relative 'helpers'
+
+module Legion
+  module Extensions
+    module Github
+      module Absorbers
+        # Absorbs GitHub issue events and normalizes them to fleet work items.
+        # Subscribes to lex.github.absorbers.issues queue.
+        #
+        # Filters: bot events, already-claimed issues (fleet labels), ignored
+        # actions (closed, transferred, etc.).
+        #
+        # Publishes normalized work items to the assessor queue via task chain.
+        module Issues
+          extend self
+          extend Helpers
+
+          CACHE_TTL = 86_400 # 24 hours
+
+          def description_max_bytes
+            Legion::Settings.dig(:fleet, :work_item, :description_max_bytes) || 32_768
+          rescue StandardError => _e
+            32_768
+          end
+
+          # Main entry point. Called by the subscription actor when a GitHub
+          # webhook event for issues arrives.
+          #
+          # @param payload [Hash] Raw GitHub webhook payload (string keys from JSON)
+          # @return [Hash] { absorbed: true/false, ... }
+          def absorb(payload:, **)
+            return { absorbed: false, reason: :bot_generated } if bot_generated?(payload)
+            return { absorbed: false, reason: :already_claimed } if has_fleet_label?(payload)
+            return { absorbed: false, reason: :ignored } if ignored?(payload)
+
+            work_item = normalize(payload)
+
+            # NOTE: Absorber does NOT call set_nx — the assessor is the single dedup authority.
+            # Source-specific dedup only: label checks, bot filter, action filter.
+
+            # Store large raw payload in Redis, not inline in AMQP message
+            cache_key = "fleet:payload:#{work_item[:work_item_id]}"
+            cache_set(cache_key, json_dump(payload), ttl: CACHE_TTL)
+            work_item[:raw_payload_ref] = cache_key
+
+            # Publish to assessor via transport
+            publish_result = publish_to_assessor(work_item)
+
+            # Propagate publish failures — do not swallow
+            return publish_result if publish_result.is_a?(Hash) && publish_result[:absorbed] == false
+
+            { absorbed: true, work_item_id: work_item[:work_item_id] }
+          end
+
+          # Normalize a raw GitHub webhook payload to the standard fleet work
+          # item format (design spec section 3).
+          #
+          # @param payload [Hash] Raw GitHub webhook payload (string keys)
+          # @return [Hash] Normalized work item (symbol keys)
+          def normalize(payload)
+            issue = payload['issue'] || {}
+            repo = payload['repository'] || {}
+            action = payload['action'] || 'opened'
+            owner = repo.dig('owner', 'login') || ''
+            repo_name = repo['name'] || ''
+            number = issue['number']
+            body = issue['body'] || ''
+            max_bytes = description_max_bytes
+
+            {
+              work_item_id:    generate_work_item_id,
+              source:          'github',
+              source_ref:      "#{owner}/#{repo_name}##{number}",
+              source_event:    "issues.#{action}",
+
+              title:           issue['title'] || '',
+              description:     body.bytesize > max_bytes ? body.byteslice(0, max_bytes).scrub('') : body,
+              raw_payload_ref: nil, # set after cache write in absorb
+
+              repo:            {
+                owner:          owner,
+                name:           repo_name,
+                default_branch: repo['default_branch'] || 'main',
+                language:       repo['language'] || 'unknown'
+              },
+
+              instructions:    [],
+              context:         [],
+
+              config:          default_config,
+
+              pipeline:        {
+                stage:            'intake',
+                trace:            [],
+                attempt:          0,
+                feedback_history: [],
+                plan:             nil,
+                changes:          nil,
+                review_result:    nil,
+                pr_number:        nil,
+                branch_name:      nil,
+                context_ref:      nil
+              }
+            }
+          end
+
+          private
+
+          def default_config
+            {
+              priority:             :medium,
+              complexity:           nil,
+              estimated_difficulty: nil,
+              planning:             default_config_planning,
+              implementation:       default_config_implementation,
+              validation:           default_config_validation,
+              feedback:             default_config_feedback,
+              workspace:            { isolation: :worktree, cleanup_on_complete: true },
+              context:              { load_repo_docs: true, load_file_tree: true, max_context_files: 50 },
+              tracing:              { stage_comments: true, token_tracking: true },
+              safety:               { poison_message_threshold: 2, cancel_allowed: true },
+              selection:            { strategy: :test_winner },
+              escalation:           { on_max_iterations: :human, consent_domain: 'fleet.shipping' }
+            }
+          end
+
+          def default_config_planning
+            { enabled: true, solvers: 1, validators: 1, max_iterations: 2 }
+          end
+
+          def default_config_implementation
+            { solvers: 1, validators: 3, max_iterations: 5, models: nil }
+          end
+
+          def default_config_validation
+            {
+              enabled:            true,
+              run_tests:          true,
+              run_lint:           true,
+              security_scan:      true,
+              adversarial_review: true,
+              reviewer_models:    nil
+            }
+          end
+
+          def default_config_feedback
+            { drain_enabled: true, max_drain_rounds: 3, summarize_after: 2 }
+          end
+
+          # Publish the normalized work item to the assessor's queue.
+          # Uses Legion::Transport::Messages::Task.
+          #
+          # generate_task_id returns a Hash { success:, task_id:, ... } — extract task_id.
+          # function: must be a String ('assess'), never a Symbol.
+          # Do NOT pass exchange: as String (broken until WS-00F lands).
+          #
+          # Propagates failures — returns { absorbed: false, reason: :publish_failed, ... }
+          def publish_to_assessor(work_item)
+            # Transport unavailable = lite mode / test environment. Not a publish failure; skip silently.
+            return unless transport_connected? && defined?(Legion::Runner)
+
+            result = Legion::Runner::Status.generate_task_id(
+              runner_class: 'Legion::Extensions::Assessor::Runners::Assessor',
+              function:     'assess'
+            )
+            task_id = result&.dig(:task_id)
+            raise 'Fleet: cannot create task record (is legion-data connected?)' if task_id.nil?
+
+            Legion::Transport::Messages::Task.new(
+              work_item:   work_item,
+              function:    'assess',
+              task_id:     task_id,
+              master_id:   task_id,
+              routing_key: 'lex.assessor.runners.assessor.assess'
+            ).publish
+          rescue StandardError => e
+            log.warn("Absorber publish failed: #{e.message}")
+            { absorbed: false, reason: :publish_failed, message: e.message }
+          end
+
+          # Direct delegators to Legion::Cache and Legion::JSON.
+          # These thin wrappers satisfy the HelperMigration cops at call sites
+          # while preserving full control over key format and arguments.
+          # rubocop:disable Legion/HelperMigration/DirectCache, Legion/HelperMigration/DirectJson
+          def cache_set(key, value, ttl: nil)
+            Legion::Cache.set(key, value, ttl: ttl)
+          end
+
+          def json_dump(object)
+            Legion::JSON.dump(object)
+          end
+          # rubocop:enable Legion/HelperMigration/DirectCache, Legion/HelperMigration/DirectJson
+        end
+      end
+    end
+  end
+end

data/lib/legion/extensions/github/absorbers/webhook_setup.rb

@@ -0,0 +1,101 @@
+# lib/legion/extensions/github/absorbers/webhook_setup.rb
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module Github
+      module Absorbers
+        # Mixin for auto-registering GitHub webhooks and fleet labels on a repo.
+        # Used by `legionio fleet add github` to wire up the absorber source.
+        #
+        # Include this module in a class that also includes the GitHub runners
+        # (RepositoryWebhooks, Labels).
+        module WebhookSetup
+          FLEET_WEBHOOK_EVENTS = %w[issues pull_request].freeze
+
+          FLEET_LABELS = [
+            { name: 'fleet:received', color: '6f42c1', description: 'Fleet pipeline has received this issue' },
+            { name: 'fleet:implementing', color: '0e8a16', description: 'Fleet is implementing a fix' },
+            { name: 'fleet:pr-open', color: '1d76db', description: 'Fleet has opened a PR for this issue' },
+            { name: 'fleet:escalated', color: 'e4e669', description: 'Fleet escalated this issue to a human' }
+          ].freeze
+
+          # Set up fleet webhook and labels on a GitHub repo.
+          #
+          # @param owner [String] Repository owner/org
+          # @param repo [String] Repository name
+          # @param webhook_url [String] Callback URL for webhook delivery
+          # @return [Hash] { success:, webhook_id:, labels_created: }
+          def setup_fleet_webhook(owner:, repo:, webhook_url:, **)
+            # Check if webhook already exists
+            existing = list_webhooks(owner: owner, repo: repo)
+            existing_hook = (existing[:result] || []).find do |hook|
+              url = hook.is_a?(Hash) ? (hook.dig('config', 'url') || hook.dig(:config, :url)) : nil
+              url == webhook_url
+            end
+
+            if existing_hook
+              hook_id = existing_hook['id'] || existing_hook[:id]
+              labels = ensure_fleet_labels(owner: owner, repo: repo)
+              return { success: true, existing: true, webhook_id: hook_id, labels_created: labels }
+            end
+
+            # Create webhook
+            config = {
+              url:          webhook_url,
+              content_type: 'json',
+              insecure_ssl: '0'
+            }
+
+            result = create_webhook(
+              owner:  owner,
+              repo:   repo,
+              config: config,
+              events: FLEET_WEBHOOK_EVENTS,
+              active: true
+            )
+
+            webhook_data = result[:result] || {}
+            webhook_id = webhook_data['id'] || webhook_data[:id]
+
+            return { success: false, error: 'webhook creation returned no id' } if webhook_id.nil?
+
+            # Create fleet labels
+            labels = ensure_fleet_labels(owner: owner, repo: repo)
+
+            {
+              success:        true,
+              existing:       false,
+              webhook_id:     webhook_id,
+              webhook_url:    webhook_url,
+              labels_created: labels
+            }
+          rescue StandardError => e
+            { success: false, error: e.message }
+          end
+
+          def fleet_label_definitions
+            FLEET_LABELS
+          end
+
+          private
+
+          def ensure_fleet_labels(owner:, repo:)
+            created = []
+            FLEET_LABELS.each do |label_def|
+              create_label(
+                owner:       owner,
+                repo:        repo,
+                name:        label_def[:name],
+                color:       label_def[:color],
+                description: label_def[:description]
+              )
+              created << label_def[:name]
+            end
+            created
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -3,7 +3,7 @@
 module Legion
   module Extensions
     module Github
-      VERSION = '0.3.5'
+      VERSION = '0.3.6'
     end
   end
 end

data/lib/legion/extensions/github.rb

@@ -37,6 +37,12 @@ require 'legion/extensions/github/runners/releases'
 require 'legion/extensions/github/runners/deployments'
 require 'legion/extensions/github/runners/auth'
 require 'legion/extensions/github/runners/repository_webhooks'
+
+# Absorber modules (fleet pipeline intake)
+require 'legion/extensions/github/absorbers/helpers'
+require 'legion/extensions/github/absorbers/issues'
+require 'legion/extensions/github/absorbers/webhook_setup'
+
 require 'legion/extensions/github/client'
 require 'legion/extensions/github/cli/runner'
 

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: lex-github
 version: !ruby/object:Gem::Version
-  version: 0.3.5
+  version: 0.3.6
 platform: ruby
 authors:
 - Esity
@@ -170,6 +170,10 @@ files:
 - README.md
 - lex-github.gemspec
 - lib/legion/extensions/github.rb
+- lib/legion/extensions/github/absorbers/actor.rb
+- lib/legion/extensions/github/absorbers/helpers.rb
+- lib/legion/extensions/github/absorbers/issues.rb
+- lib/legion/extensions/github/absorbers/webhook_setup.rb
 - lib/legion/extensions/github/app/actor/token_refresh.rb
 - lib/legion/extensions/github/app/actor/webhook_poller.rb
 - lib/legion/extensions/github/app/hooks/setup.rb