lex-autofix 0.1.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: e309323e3b94d1b313d89ef3519279342ac89a11441f682e1e3d2930415b39b5
+  data.tar.gz: b63ac5224d391c1170f3a69a96874a135ad6726f882d5996923799c89d993338
+SHA512:
+  metadata.gz: 773519f18416a41f2913c1c7bab97ab3fb53da70b02ac241a6185a9128fcfeb5b757fb8af21b72cbb682461d7a6efb096864a2e8a8a03fa4d77067730ce07b94
+  data.tar.gz: cb558e1cd91befef1bca8657072ec7cd35e0467f6275d65725df4255cf9e1d85dd61979e3e16f7a8a6948509a004f534b59b2a3524e49c418565a92b97bdfa32

data/CHANGELOG.md

@@ -0,0 +1,11 @@
+# Changelog
+
+## [0.1.1] - 2026-03-21
+
+### Added
+- CI workflow (reusable LegionIO CI + release)
+
+## [0.1.0] - 2026-03-21
+
+### Added
+- Initial release: scaffold, batch buffer, triage, diagnose, fix, ship runners

data/README.md

@@ -0,0 +1,26 @@
+# lex-autofix
+
+Autonomous error fix agent for LegionIO. Subscribes to the `legion.logging` RabbitMQ exchange, batches and triages errors via LLM, manages GitHub issues, and opens PRs with automated code fixes.
+
+## Installation
+
+Add to your Gemfile:
+
+```ruby
+gem 'lex-autofix'
+```
+
+## Configuration
+
+| Setting | Default | Purpose |
+|---------|---------|---------|
+| `autofix.batch.window_seconds` | 300 | Time window before batch flush |
+| `autofix.batch.count_threshold` | 3 | Error count per group to trigger flush |
+| `autofix.llm.max_retries` | 3 | Max LLM fix attempts before issue-only |
+| `autofix.github.token` | nil | GitHub PAT (supports `vault://`) |
+| `autofix.github.org` | LegionIO | GitHub org for operations |
+| `autofix.checkout_dir` | ~/.legionio/autofix/ | Temp directory for checkouts |
+
+## License
+
+MIT

data/lib/legion/extensions/autofix/actors/log_consumer.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module Autofix
+      module Actors
+        class LogConsumer < Legion::Extensions::Actors::Subscription
+          def runner_function = 'handle_log_event'
+          def check_subtask? = false
+          def generate_task? = false
+
+          def enabled?
+            !!(defined?(Legion::LLM) && Legion::LLM.respond_to?(:started?) && Legion::LLM.started?)
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+require_relative 'helpers/client'
+require_relative 'runners/triage'
+require_relative 'runners/diagnose'
+require_relative 'runners/fix'
+require_relative 'runners/ship'
+
+module Legion
+  module Extensions
+    module Autofix
+      class Client
+        include Helpers::Client
+        include Runners::Triage
+        include Runners::Diagnose
+        include Runners::Fix
+        include Runners::Ship
+
+        attr_reader :opts
+
+        def initialize(github_token: nil, github_org: 'LegionIO', checkout_dir: nil, **extra)
+          @opts = { github_token: github_token, github_org: github_org, checkout_dir: checkout_dir, **extra }
+        end
+      end
+    end
+  end
+end

data/lib/legion/extensions/autofix/helpers/batch_buffer.rb

@@ -0,0 +1,67 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module Autofix
+      module Helpers
+        # Thread-safe in-memory buffer that groups error events by lex:exception_class key.
+        # Flush is triggered when a group reaches count_threshold OR the time window elapses.
+        class BatchBuffer
+          DEFAULT_WINDOW_SECONDS = 300
+          DEFAULT_COUNT_THRESHOLD = 3
+
+          attr_reader :groups
+
+          def initialize(window_seconds: DEFAULT_WINDOW_SECONDS, count_threshold: DEFAULT_COUNT_THRESHOLD)
+            @window_seconds  = window_seconds
+            @count_threshold = count_threshold
+            @groups          = {}
+            @first_event_time = nil
+            @mutex = Mutex.new
+          end
+
+          def add(event)
+            @mutex.synchronize do
+              key = build_key(event)
+              @groups[key] ||= []
+              @groups[key] << event
+              @first_event_time ||= Process.clock_gettime(Process::CLOCK_MONOTONIC)
+            end
+          end
+
+          def flush_ready?
+            @mutex.synchronize do
+              return false if @groups.empty?
+
+              return true if @groups.any? { |_, events| events.length >= @count_threshold }
+
+              elapsed = Process.clock_gettime(Process::CLOCK_MONOTONIC) - @first_event_time
+              elapsed >= @window_seconds
+            end
+          end
+
+          def flush!
+            @mutex.synchronize do
+              all_events = @groups.values.flatten
+              @groups = {}
+              @first_event_time = nil
+              all_events
+            end
+          end
+
+          def size
+            @mutex.synchronize { @groups.values.sum(&:length) }
+          end
+
+          private
+
+          def build_key(event)
+            lex             = event[:lex] || 'core'
+            exception_class = event[:exception_class] || 'unknown'
+            "#{lex}:#{exception_class}"
+          end
+        end
+      end
+    end
+  end
+end

data/lib/legion/extensions/autofix/helpers/client.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module Autofix
+      module Helpers
+        module Client
+          def settings
+            { options: @opts }
+          end
+        end
+      end
+    end
+  end
+end

data/lib/legion/extensions/autofix/helpers/prompts.rb

@@ -0,0 +1,126 @@
+# frozen_string_literal: true
+
+require 'json'
+
+module Legion
+  module Extensions
+    module Autofix
+      module Helpers
+        module Prompts
+          module_function
+
+          def triage(events)
+            serialized = ::JSON.pretty_generate(events)
+            <<~PROMPT
+              You are an expert Ruby engineer analyzing error telemetry from a running system.
+
+              Below is a JSON array of error events captured from one or more LegionIO extensions.
+              Your job is to group these errors into clusters based on their type, origin, and likely root cause.
+
+              For each cluster, decide:
+              - Whether it is actionable (can be fixed by editing source code)
+              - A brief summary of what is going wrong
+              - Which repository (gem) is the likely owner of the fix
+              - The list of event indices belonging to this cluster
+
+              Return ONLY valid JSON matching the required schema. Do not include any explanation outside the JSON.
+
+              Events:
+              #{serialized}
+            PROMPT
+          end
+
+          def triage_schema
+            {
+              type:       'object',
+              properties: {
+                clusters: {
+                  type:  'array',
+                  items: {
+                    type:       'object',
+                    properties: {
+                      id:             { type: 'string' },
+                      summary:        { type: 'string' },
+                      actionable:     { type: 'boolean' },
+                      reason:         { type: 'string' },
+                      events:         { type: 'array', items: { type: 'integer' } },
+                      suggested_repo: { type: 'string' }
+                    },
+                    required:   %w[id summary actionable events]
+                  }
+                }
+              },
+              required:   %w[clusters]
+            }
+          end
+
+          def fix(error_details:, files:)
+            file_section = files.map do |path, content|
+              "### #{path}\n```ruby\n#{content}\n```"
+            end.join("\n\n")
+
+            <<~PROMPT
+              You are an expert Ruby engineer. Your task is to produce a minimal code fix for the error described below.
+
+              ## Error Details
+
+              Exception class: #{error_details[:exception_class]}
+              Message: #{error_details[:message]}
+              Backtrace:
+              #{Array(error_details[:backtrace]).first(10).map { |l| "  #{l}" }.join("\n")}
+
+              ## Source Files
+
+              #{file_section}
+
+              ## Instructions
+
+              Analyze the error and the source files above. Produce the smallest set of edits that fixes the issue.
+              Each edit must specify the exact old string to replace and the new string to substitute.
+              Return ONLY valid JSON matching the required schema. Do not include explanation outside the JSON.
+            PROMPT
+          end
+
+          def fix_retry(error_details:, files:, test_output:)
+            base = fix(error_details: error_details, files: files)
+            <<~PROMPT
+              #{base.chomp}
+
+              ## Previous Fix Attempt Failed
+
+              The prior fix was applied but tests still failed. Here is the test output:
+
+              ```
+              #{test_output}
+              ```
+
+              Review the test failures above and produce a revised set of edits.
+              Return ONLY valid JSON matching the required schema. Do not include explanation outside the JSON.
+            PROMPT
+          end
+
+          def fix_schema
+            {
+              type:       'object',
+              properties: {
+                edits: {
+                  type:  'array',
+                  items: {
+                    type:       'object',
+                    properties: {
+                      file: { type: 'string' },
+                      old:  { type: 'string' },
+                      new:  { type: 'string' }
+                    },
+                    required:   %w[file old new]
+                  }
+                }
+              },
+              required:   %w[edits]
+            }
+          end
+        end
+      end
+    end
+  end
+end

data/lib/legion/extensions/autofix/helpers/temp_checkout.rb

@@ -0,0 +1,75 @@
+# frozen_string_literal: true
+
+require 'fileutils'
+require 'securerandom'
+
+module Legion
+  module Extensions
+    module Autofix
+      module Helpers
+        # Manages temporary git checkouts for applying and testing code fixes.
+        class TempCheckout
+          DEFAULT_BASE_DIR = '~/.legionio/autofix/'
+          FILE_READ_CAP = 10
+
+          def initialize(base_dir: DEFAULT_BASE_DIR)
+            @base_dir = ::File.expand_path(base_dir)
+            ::FileUtils.mkdir_p(@base_dir)
+          end
+
+          def clone(repo_url:, branch:)
+            dir = ::File.join(@base_dir, "checkout_#{SecureRandom.hex(8)}")
+            success = system('git', 'clone', '--depth', '1', repo_url, dir)
+            return { success: false, reason: 'git clone failed' } unless success
+
+            success = system('git', '-C', dir, 'checkout', '-b', branch)
+            return { success: false, reason: 'git checkout -b failed' } unless success
+
+            { success: true, path: dir }
+          end
+
+          def cleanup(path)
+            expanded = ::File.expand_path(path)
+            return { success: false, reason: 'path is outside base_dir' } unless under_base_dir?(expanded)
+
+            ::FileUtils.rm_rf(expanded)
+            { success: true }
+          end
+
+          def apply_edits(checkout_path:, edits:)
+            edits.each do |edit|
+              file_path = ::File.join(checkout_path, edit['file'])
+              return { success: false, reason: "file not found: #{edit['file']}" } unless ::File.exist?(file_path)
+
+              content = ::File.read(file_path)
+              return { success: false, reason: "old string not found in #{edit['file']}" } unless content.include?(edit['old'])
+
+              ::File.write(file_path, content.sub(edit['old'], edit['new']))
+            end
+
+            { success: true }
+          end
+
+          def read_files(checkout_path:, file_paths:)
+            capped = file_paths.first(FILE_READ_CAP)
+            result = {}
+            capped.each do |rel_path|
+              abs_path = ::File.join(checkout_path, rel_path)
+              next unless ::File.exist?(abs_path)
+
+              result[rel_path] = ::File.read(abs_path)
+            end
+            result
+          end
+
+          private
+
+          def under_base_dir?(expanded_path)
+            expanded_path.start_with?(@base_dir + ::File::SEPARATOR) ||
+              expanded_path == @base_dir
+          end
+        end
+      end
+    end
+  end
+end

data/lib/legion/extensions/autofix/runners/diagnose.rb

@@ -0,0 +1,103 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module Autofix
+      module Runners
+        module Diagnose
+          def check_github(cluster:, events:, token:, org: 'LegionIO')
+            repo = cluster[:suggested_repo]
+            exception_class = events.first[:exception_class] || 'unknown'
+            client = Legion::Extensions::Github::Client.new(token: token)
+            search_result = client.search_issues(
+              query: "repo:#{org}/#{repo} is:open label:autofix #{exception_class}"
+            )
+            items = search_result.dig(:result, :items) || []
+
+            if items.any?
+              update_existing_issue(client: client, issue: items.first, events: events, org: org, repo: repo)
+            else
+              ctx = build_issue_context(cluster: cluster, events: events, exception_class: exception_class)
+              open_new_issue(client: client, cluster: cluster, org: org, repo: repo, ctx: ctx)
+            end
+          rescue StandardError => e
+            { success: false, reason: e.message }
+          end
+
+          private
+
+          def update_existing_issue(client:, issue:, events:, org:, repo:)
+            issue_number = issue[:number]
+            issue_body   = issue[:body].to_s
+            caller_locations = events.map { |e| "#{e[:caller_file]}:#{e[:caller_line]}" }
+            new_locations = caller_locations.reject { |loc| issue_body.include?(loc) }
+
+            if new_locations.any?
+              comment_body = "**Additional caller locations observed:**\n\n" \
+                             "#{new_locations.map { |l| "- #{l}" }.join("\n")}"
+              client.create_comment(owner: org, repo: repo, issue_number: issue_number, body: comment_body)
+              { success: true, action: :commented, issue_number: issue_number }
+            else
+              { success: true, action: :skipped, issue_number: issue_number }
+            end
+          end
+
+          def build_issue_context(cluster:, events:, exception_class:)
+            first = events.first
+            {
+              exception_class:  exception_class,
+              caller_locations: events.map { |e| "#{e[:caller_file]}:#{e[:caller_line]}" },
+              occurrences:      events.size,
+              first_seen:       first[:first_seen] || 'unknown',
+              message:          first[:message],
+              backtrace_lines:  (first[:backtrace] || []).first(5).map { |l| "    #{l}" }.join("\n"),
+              diagnosis:        cluster[:diagnosis] || cluster[:summary]
+            }
+          end
+
+          def open_new_issue(client:, cluster:, org:, repo:, ctx:)
+            body = <<~BODY
+              ## autofix report
+
+              **Exception**: `#{ctx[:exception_class]}`
+              **Source**: #{ctx[:caller_locations].first}
+              **Occurrences**: #{ctx[:occurrences]}
+              **First seen**: #{ctx[:first_seen]}
+
+              ### Error Details
+
+              ```
+              #{ctx[:message]}
+              ```
+
+              ### Backtrace (top 5)
+
+              ```
+              #{ctx[:backtrace_lines]}
+              ```
+
+              ### Caller Locations
+
+              #{ctx[:caller_locations].map { |l| "- #{l}" }.join("\n")}
+
+              ### Diagnosis
+
+              #{ctx[:diagnosis]}
+            BODY
+
+            result = client.create_issue(
+              owner:  org,
+              repo:   repo,
+              title:  "autofix: #{cluster[:summary]}",
+              body:   body,
+              labels: ['autofix']
+            )
+
+            issue_data = result[:result] || {}
+            { success: true, action: :created, issue_number: issue_data[:number], url: issue_data[:html_url] }
+          end
+        end
+      end
+    end
+  end
+end

data/lib/legion/extensions/autofix/runners/fix.rb

@@ -0,0 +1,102 @@
+# frozen_string_literal: true
+
+require_relative '../helpers/prompts'
+require_relative '../helpers/temp_checkout'
+
+module Legion
+  module Extensions
+    module Autofix
+      module Runners
+        module Fix
+          def attempt_fix(repo_url:, branch:, error_details:, max_retries: 3, checkout_dir: nil)
+            tc_opts = checkout_dir ? { base_dir: checkout_dir } : {}
+            tc = Helpers::TempCheckout.new(**tc_opts)
+
+            clone_result = tc.clone(repo_url: repo_url, branch: branch)
+            return clone_result unless clone_result[:success]
+
+            checkout_path = clone_result[:path]
+            file_paths = extract_file_paths(error_details)
+            files = tc.read_files(checkout_path: checkout_path, file_paths: file_paths)
+
+            schema = Helpers::Prompts.fix_schema
+            test_output = nil
+
+            max_retries.times do |attempt|
+              messages = build_messages(attempt: attempt, error_details: error_details,
+                                        files: files, test_output: test_output)
+
+              llm_result = Legion::LLM.structured(messages: messages, schema: schema)
+              edits = llm_result[:edits] || []
+
+              apply_result = tc.apply_edits(checkout_path: checkout_path, edits: edits)
+              unless apply_result[:success]
+                tc.cleanup(checkout_path)
+                return { success: false, reason: apply_result[:reason] }
+              end
+
+              test_result = run_tests(checkout_path: checkout_path)
+              if test_result[:success]
+                lint_result = run_lint(checkout_path: checkout_path)
+                return { success: true, checkout_path: checkout_path } if lint_result[:success]
+
+                test_output = lint_result[:output]
+              else
+                test_output = test_result[:output]
+              end
+
+              system('git', '-C', checkout_path, 'checkout', '.')
+            end
+
+            tc.cleanup(checkout_path)
+            { success: false, reason: "fix failed after max retries (#{max_retries})" }
+          rescue StandardError => e
+            { success: false, reason: e.message }
+          end
+
+          def run_tests(checkout_path:)
+            Dir.chdir(checkout_path) do
+              system('bundle', 'install', '--quiet')
+              output = `bundle exec rspec 2>&1`
+              { success: $CHILD_STATUS&.success?, output: output }
+            end
+          end
+
+          def run_lint(checkout_path:)
+            Dir.chdir(checkout_path) do
+              system('bundle', 'exec', 'rubocop', '-A')
+              output = `bundle exec rubocop 2>&1`
+              { success: $CHILD_STATUS&.success?, output: output }
+            end
+          end
+
+          private
+
+          def extract_file_paths(error_details)
+            paths = []
+            paths << error_details[:caller_file] if error_details[:caller_file]
+
+            Array(error_details[:backtrace]).each do |line|
+              file = line.to_s.split(':').first
+              paths << file if file && !file.empty?
+            end
+
+            paths = paths.uniq
+            spec_paths = paths.map { |p| p.sub('lib/', 'spec/').sub(/\.rb$/, '_spec.rb') }
+            (paths + spec_paths).uniq
+          end
+
+          def build_messages(attempt:, error_details:, files:, test_output:)
+            prompt = if attempt.zero?
+                       Helpers::Prompts.fix(error_details: error_details, files: files)
+                     else
+                       Helpers::Prompts.fix_retry(error_details: error_details, files: files,
+                                                  test_output: test_output.to_s)
+                     end
+            [{ role: 'user', content: prompt }]
+          end
+        end
+      end
+    end
+  end
+end

data/lib/legion/extensions/autofix/runners/pipeline.rb

@@ -0,0 +1,138 @@
+# frozen_string_literal: true
+
+require_relative 'triage'
+require_relative 'diagnose'
+require_relative 'fix'
+require_relative 'ship'
+require_relative '../helpers/batch_buffer'
+
+module Legion
+  module Extensions
+    module Autofix
+      module Runners
+        module Pipeline
+          include Triage
+          include Diagnose
+          include Fix
+          include Ship
+
+          def self.buffer
+            @buffer ||= begin
+              window   = Legion::Settings.dig(:autofix, :batch, :window_seconds)  rescue nil # rubocop:disable Style/RescueModifier
+              count    = Legion::Settings.dig(:autofix, :batch, :count_threshold) rescue nil # rubocop:disable Style/RescueModifier
+              opts = {}
+              opts[:window_seconds]  = window if window
+              opts[:count_threshold] = count  if count
+              Helpers::BatchBuffer.new(**opts)
+            end
+          end
+
+          def handle_log_event(**event)
+            Pipeline.buffer.add(event)
+            run_pipeline if Pipeline.buffer.flush_ready?
+            { success: true }
+          end
+
+          def run_pipeline
+            events = Pipeline.buffer.flush!
+            triage_result = batch_triage(events: events)
+            return triage_result unless triage_result[:success]
+
+            triage_result[:non_actionable].each do |cluster|
+              log_info("autofix: skipping non-actionable cluster: #{cluster[:summary]}")
+            end
+
+            triage_result[:actionable].each do |cluster|
+              cluster_events = events.select { |e| e[:lex] == cluster[:suggested_repo] }
+              cluster_events = events if cluster_events.empty?
+              process_cluster(cluster: cluster, events: cluster_events)
+            end
+
+            { success: true }
+          end
+
+          def process_cluster(cluster:, events:)
+            token        = resolve_token
+            org          = resolve_org
+            max_retries  = resolve_max_retries
+            checkout_dir = resolve_checkout_dir
+
+            github_result = check_github(cluster: cluster, events: events, token: token, org: org)
+            return github_result unless github_result[:success]
+
+            issue_number = github_result[:issue_number]
+            repo         = cluster[:suggested_repo]
+
+            return { success: true, action: :issue_only } if github_result[:action] == :skipped
+
+            summary  = cluster[:summary].to_s
+            repo_url = "https://github.com/#{org}/#{repo}.git"
+            branch   = "autofix/#{issue_number}-#{slug(summary)}"
+
+            fix_result = attempt_fix(
+              repo_url:      repo_url,
+              branch:        branch,
+              error_details: events.first,
+              max_retries:   max_retries,
+              checkout_dir:  checkout_dir
+            )
+
+            unless fix_result[:success]
+              log_warn("autofix: fix failed for cluster #{cluster[:summary]}: #{fix_result[:reason]}")
+              return fix_result
+            end
+
+            ship(
+              checkout_path: fix_result[:checkout_path],
+              owner:         org,
+              repo:          repo,
+              branch:        branch,
+              issue_number:  issue_number,
+              summary:       summary,
+              token:         token,
+              checkout_dir:  checkout_dir
+            )
+          end
+
+          private
+
+          def resolve_token
+            Legion::Settings.dig(:autofix, :github, :token)
+          rescue StandardError
+            nil
+          end
+
+          def resolve_org
+            Legion::Settings.dig(:autofix, :github, :org) || 'LegionIO'
+          rescue StandardError
+            'LegionIO'
+          end
+
+          def resolve_max_retries
+            Legion::Settings.dig(:autofix, :llm, :max_retries) || 3
+          rescue StandardError
+            3
+          end
+
+          def resolve_checkout_dir
+            Legion::Settings.dig(:autofix, :checkout_dir)
+          rescue StandardError
+            nil
+          end
+
+          def slug(text)
+            text.to_s.downcase.gsub(/[^a-z0-9]+/, '-').slice(0, 40).chomp('-')
+          end
+
+          def log_info(msg)
+            Legion::Logging.info(msg) if defined?(Legion::Logging)
+          end
+
+          def log_warn(msg)
+            Legion::Logging.warn(msg) if defined?(Legion::Logging)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/legion/extensions/autofix/runners/ship.rb

@@ -0,0 +1,64 @@
+# frozen_string_literal: true
+
+require_relative '../helpers/temp_checkout'
+
+module Legion
+  module Extensions
+    module Autofix
+      module Runners
+        module Ship
+          def commit_and_push(checkout_path:, branch:, message:)
+            Dir.chdir(checkout_path) do
+              return { success: false, reason: 'git add failed' } unless system('git', 'add', '-A')
+              return { success: false, reason: 'git commit failed' } unless system('git', 'commit', '-m', message)
+              return { success: false, reason: 'git push failed' } unless system('git', 'push', '-u', 'origin', branch)
+            end
+
+            { success: true }
+          end
+
+          def open_pr(owner:, repo:, branch:, title:, body:, token:) # rubocop:disable Metrics/ParameterLists
+            client = Legion::Extensions::Github::Client.new(token: token)
+            result = client.create_pull_request(
+              owner: owner,
+              repo:  repo,
+              title: title,
+              head:  branch,
+              base:  'main',
+              body:  body
+            )
+            pr = result[:result] || result
+            { success: true, pr_number: pr[:number], url: pr[:html_url] }
+          rescue StandardError => e
+            { success: false, reason: e.message }
+          end
+
+          def ship(checkout_path:, owner:, repo:, branch:, issue_number:, summary:, token:, checkout_dir: nil) # rubocop:disable Metrics/ParameterLists
+            commit_result = commit_and_push(
+              checkout_path: checkout_path,
+              branch:        branch,
+              message:       "fix: #{summary}"
+            )
+            return commit_result unless commit_result[:success]
+
+            pr_result = open_pr(
+              owner:  owner,
+              repo:   repo,
+              branch: branch,
+              title:  "fix: #{summary}",
+              body:   "Closes ##{issue_number}\n\nAutomated fix by lex-autofix.",
+              token:  token
+            )
+
+            tc_opts = checkout_dir ? { base_dir: checkout_dir } : {}
+            Helpers::TempCheckout.new(**tc_opts).cleanup(checkout_path)
+
+            pr_result
+          rescue StandardError => e
+            { success: false, reason: e.message }
+          end
+        end
+      end
+    end
+  end
+end

data/lib/legion/extensions/autofix/runners/triage.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+require_relative '../helpers/prompts'
+
+module Legion
+  module Extensions
+    module Autofix
+      module Runners
+        module Triage
+          def batch_triage(events:)
+            return { success: false, reason: 'no events to triage' } if events.empty?
+
+            prompt = Helpers::Prompts.triage(events)
+            schema = Helpers::Prompts.triage_schema
+
+            result = Legion::LLM.structured(
+              messages: [{ role: 'user', content: prompt }],
+              schema:   schema
+            )
+
+            clusters = result[:clusters] || []
+            actionable, non_actionable = clusters.partition { |c| c[:actionable] }
+
+            { success: true, clusters: clusters, actionable: actionable, non_actionable: non_actionable }
+          rescue StandardError => e
+            { success: false, reason: e.message }
+          end
+        end
+      end
+    end
+  end
+end

data/lib/legion/extensions/autofix/transport/queues/ingest.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module Autofix
+      module Transport
+        module Queues
+          class Ingest < Legion::Transport::Queue
+            def queue_name = 'autofix.ingest'
+            def queue_options = { durable: true, auto_delete: false }
+          end
+        end
+      end
+    end
+  end
+end

data/lib/legion/extensions/autofix/transport.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module Autofix
+      module Transport
+        extend Legion::Extensions::Transport if defined?(Legion::Extensions::Transport)
+
+        def self.additional_e_to_q
+          [{ from: 'legion.logging', to: 'autofix.ingest', routing_key: 'legion.#' }]
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module Autofix
+      VERSION = '0.1.1'
+    end
+  end
+end

data/lib/legion/extensions/autofix.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+require_relative 'autofix/version'
+
+module Legion
+  module Extensions
+    module Autofix
+      extend Legion::Extensions::Core if defined?(Legion::Extensions::Core)
+
+      def self.llm_required?
+        true
+      end
+    end
+  end
+end
+
+# Require components when framework is available
+if defined?(Legion::Extensions::Core)
+  require_relative 'autofix/helpers/batch_buffer'
+  require_relative 'autofix/helpers/prompts'
+  require_relative 'autofix/helpers/temp_checkout'
+  require_relative 'autofix/helpers/client'
+  require_relative 'autofix/runners/triage'
+  require_relative 'autofix/runners/diagnose'
+  require_relative 'autofix/runners/fix'
+  require_relative 'autofix/runners/ship'
+  require_relative 'autofix/runners/pipeline'
+  require_relative 'autofix/client'
+  require_relative 'autofix/transport' if defined?(Legion::Extensions::Transport)
+  require_relative 'autofix/actors/log_consumer' if defined?(Legion::Extensions::Actors::Subscription)
+end

metadata

@@ -0,0 +1,87 @@
+--- !ruby/object:Gem::Specification
+name: lex-autofix
+version: !ruby/object:Gem::Version
+  version: 0.1.1
+platform: ruby
+authors:
+- LegionIO
+bindir: bin
+cert_chain: []
+date: 1980-01-02 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: legion-llm
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0.3'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0.3'
+- !ruby/object:Gem::Dependency
+  name: lex-github
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0.2'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0.2'
+description: Subscribes to legion.logging exchange, triages errors via LLM, and opens
+  PRs with fixes
+email:
+- admin@legionio.dev
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- CHANGELOG.md
+- README.md
+- lib/legion/extensions/autofix.rb
+- lib/legion/extensions/autofix/actors/log_consumer.rb
+- lib/legion/extensions/autofix/client.rb
+- lib/legion/extensions/autofix/helpers/batch_buffer.rb
+- lib/legion/extensions/autofix/helpers/client.rb
+- lib/legion/extensions/autofix/helpers/prompts.rb
+- lib/legion/extensions/autofix/helpers/temp_checkout.rb
+- lib/legion/extensions/autofix/runners/diagnose.rb
+- lib/legion/extensions/autofix/runners/fix.rb
+- lib/legion/extensions/autofix/runners/pipeline.rb
+- lib/legion/extensions/autofix/runners/ship.rb
+- lib/legion/extensions/autofix/runners/triage.rb
+- lib/legion/extensions/autofix/transport.rb
+- lib/legion/extensions/autofix/transport/queues/ingest.rb
+- lib/legion/extensions/autofix/version.rb
+homepage: https://github.com/LegionIO/lex-autofix
+licenses:
+- MIT
+metadata:
+  rubygems_mfa_required: 'true'
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '3.4'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.6.9
+specification_version: 4
+summary: Autonomous error fix agent for LegionIO
+test_files: []