lex-detect 0.1.1 → 0.1.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 0f221abbf1751de26290f2d11137ec31338bb77dfb64b033ce09ebffbcd73d9d
-  data.tar.gz: fac9bfec6e9275b5b48d8d1e253edf98e1fa504b48f90300a44604fe79bd5cc9
+  metadata.gz: 119e238ddb0711af3bb4d23c5c65bb85c910420aa4ce79c1fe28c81950a38d0c
+  data.tar.gz: da4f50f6e3b1653c18d70617ab81630f3f9db6aa01cf6271205882f34df312f6
 SHA512:
-  metadata.gz: '0259374ea1f54906333dba2cbb9de76c6c1081a1e24082956a86b055cfdaa942a442c8d48eb3f49f373276c91bf2901e21720b669205ddc90a3fe97001976d41'
-  data.tar.gz: b6a5d1afa9da7d4f7a6feecd24e49ae2bced0123e79df54d368fa6f1e610189a72e8991866768ff0f4881bd056404b6208318764fb38e66bf57ab2f30835277e
+  metadata.gz: 1f38552069181a4198433a821b64744f6bdf4cd42be0285c22eccfb4ef219f09f5d5d8a5825ac53c95ded7adb45278d5ca9ef20018c96f2dcac1ad61389da296
+  data.tar.gz: ecb32f15376b6079a1810c161a726f447e1aa6b07a3a187d894fe6393b31d608cc4c0a09227d52aefe88110e6f51ff3f3d9ba1e9e61772463587557600142896

data/CHANGELOG.md

@@ -1,5 +1,20 @@
 # Changelog
 
+## [0.1.3] - 2026-03-20
+
+### Added
+- `Runners::TaskObserver` for monitoring task failure patterns
+- `check_and_publish_failure_patterns` publishes failure pattern events to AMQP for self-healing pipeline integration
+- `extract_gem_name` helper derives gem name from runner class string
+- `build_failure_pattern` creates structured failure pattern hash
+
+## [0.1.2] - 2026-03-19
+
+### Added
+- `FullScan` Once actor: runs full environment scan at boot with 2s delay, persists results and writes traces
+- `DeltaScan` Every actor: runs delta detection every 300s, computes additions/removals via Set comparison
+- Data::Local migration for detect_results table (optional persistence)
+
 ## [0.1.1] - 2026-03-18
 
 ### Changed

data/CLAUDE.md

@@ -1,8 +1,8 @@
 # lex-detect: Environment-Aware Extension Discovery
 
 **Repository Level 3 Documentation**
-- **Parent (Level 2)**: `/Users/miverso2/rubymine/legion/extensions/CLAUDE.md`
-- **Parent (Level 1)**: `/Users/miverso2/rubymine/legion/CLAUDE.md`
+- **Parent**: `/Users/miverso2/rubymine/legion/extensions-core/CLAUDE.md`
+- **Grandparent**: `/Users/miverso2/rubymine/legion/CLAUDE.md`
 
 ## Purpose
 
@@ -10,7 +10,7 @@ Legion Extension that scans the local environment and recommends which `lex-*` e
 
 **GitHub**: https://github.com/LegionIO/lex-detect
 **License**: MIT
-**Version**: 0.1.0
+**Version**: 0.1.2
 
 ## Architecture
 
@@ -19,10 +19,13 @@ Legion::Extensions::Detect
 ├── CATALOG (constant)     # Frozen array of 20 detection rules
 ├── Scanner                # Probes environment, matches against catalog
 ├── Installer              # Gem.install wrapper with dry_run support
+├── Actors/
+│   ├── FullScan (Once)    # Full environment scan at startup
+│   └── DeltaScan (Every)  # Periodic delta scan every 6 hours
 └── Entry Point            # Public API: scan, missing, install_missing!, catalog
 ```
 
-This is NOT a typical LEX — no runners, no actors, no AMQP transport, no Faraday client. It is a local-only utility gem with zero runtime dependencies.
+Local-only utility gem. Actors run scans but do not create AMQP queues.
 
 - `data_required? false` — no database needed
 - `remote_invocable? false` — no AMQP queue creation
@@ -49,12 +52,12 @@ Legion::Extensions::Detect.catalog          # raw CATALOG constant
 
 ## Design Docs
 
-- Design: `docs/plans/2026-03-18-lex-detect-design.md`
-- Implementation: `docs/plans/2026-03-18-lex-detect-implementation.md`
+- Design: `docs/work/completed/2026-03-18-lex-detect-design.md`
+- Implementation: `docs/work/completed/2026-03-18-lex-detect-implementation.md`
 
 ## Testing
 
-37 specs across 4 spec files.
+40 specs across 6 spec files.
 
 ```bash
 bundle install

data/lib/legion/extensions/detect/actors/delta_scan.rb

@@ -0,0 +1,99 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module Detect
+      module Actors
+        class DeltaScan < Legion::Extensions::Actors::Every
+          def time
+            settings_interval || 300
+          end
+
+          def run_now?
+            false
+          end
+
+          def action(**_opts)
+            current = Scanner.scan
+            previous = last_scan_results
+            deltas = compute_deltas(current, previous)
+
+            persist_results(current) unless deltas[:added].empty? && deltas[:removed].empty?
+            write_delta_traces(deltas) unless deltas[:added].empty? && deltas[:removed].empty?
+            deltas
+          end
+
+          private
+
+          def settings_interval
+            return nil unless defined?(Legion::Settings)
+
+            Legion::Settings.dig(:extensions, :'lex-detect', :delta_interval)
+          rescue StandardError
+            nil
+          end
+
+          def last_scan_results
+            return [] unless defined?(Legion::Data::Local) &&
+                             Legion::Data::Local.respond_to?(:connected?) &&
+                             Legion::Data::Local.connected?
+
+            Legion::Data::Local.model(:detect_results).all.map do |row|
+              {
+                name:            row[:name],
+                extensions:      Legion::JSON.load(row[:extensions]),
+                matched_signals: Legion::JSON.load(row[:matched_signals])
+              }
+            end
+          rescue StandardError
+            []
+          end
+
+          def compute_deltas(current, previous)
+            prev_names = previous.to_set { |r| r[:name] }
+            curr_names = current.to_set { |r| r[:name] }
+
+            added = current.reject { |r| prev_names.include?(r[:name]) }
+            removed = previous.reject { |r| curr_names.include?(r[:name]) }
+            { added: added, removed: removed }
+          end
+
+          def persist_results(results)
+            return unless defined?(Legion::Data::Local) &&
+                          Legion::Data::Local.respond_to?(:connected?) &&
+                          Legion::Data::Local.connected?
+
+            model = Legion::Data::Local.model(:detect_results)
+            model.where.delete
+            results.each do |result|
+              model.insert(
+                name:            result[:name],
+                extensions:      Legion::JSON.dump(result[:extensions]),
+                matched_signals: Legion::JSON.dump(result[:matched_signals]),
+                installed:       Legion::JSON.dump(result[:installed]),
+                scanned_at:      Time.now,
+                created_at:      Time.now,
+                updated_at:      Time.now
+              )
+            end
+          rescue StandardError
+            nil
+          end
+
+          def write_delta_traces(deltas)
+            return unless defined?(Legion::Extensions::Agentic::Memory)
+
+            deltas[:added]&.each do |r|
+              Legion::Extensions::Agentic::Memory::Trace.write(
+                source: 'lex-detect', category: 'environment',
+                content: "New detection: #{r[:name]}", confidence: 0.8
+              )
+            end
+          rescue StandardError
+            nil
+          end
+        end
+      end
+    end
+  end
+end

data/lib/legion/extensions/detect/actors/full_scan.rb

@@ -0,0 +1,70 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module Detect
+      module Actors
+        class FullScan < Legion::Extensions::Actors::Once
+          def delay
+            2.0
+          end
+
+          def action(**_opts)
+            results = Scanner.scan
+            persist_results(results)
+            write_traces(results)
+            transition_catalog
+            results
+          end
+
+          private
+
+          def persist_results(results)
+            return unless defined?(Legion::Data::Local) &&
+                          Legion::Data::Local.respond_to?(:connected?) &&
+                          Legion::Data::Local.connected?
+
+            model = Legion::Data::Local.model(:detect_results)
+            model.where.delete
+            results.each do |result|
+              model.insert(
+                name:            result[:name],
+                extensions:      Legion::JSON.dump(result[:extensions]),
+                matched_signals: Legion::JSON.dump(result[:matched_signals]),
+                installed:       Legion::JSON.dump(result[:installed]),
+                scanned_at:      Time.now,
+                created_at:      Time.now,
+                updated_at:      Time.now
+              )
+            end
+          rescue StandardError => e
+            Legion::Logging.debug { "FullScan persist failed: #{e.message}" } if defined?(Legion::Logging)
+          end
+
+          def write_traces(results)
+            return unless defined?(Legion::Extensions::Agentic::Memory)
+
+            results.each do |result|
+              Legion::Extensions::Agentic::Memory::Trace.write(
+                source:     'lex-detect',
+                category:   'environment',
+                content:    "Detected #{result[:name]}: #{result[:matched_signals].join(', ')}",
+                confidence: 0.9
+              )
+            end
+          rescue StandardError => e
+            Legion::Logging.debug { "FullScan trace write failed: #{e.message}" } if defined?(Legion::Logging)
+          end
+
+          def transition_catalog
+            return unless defined?(Legion::Extensions::Catalog)
+
+            Legion::Extensions::Catalog.transition('lex-detect', :running)
+          rescue StandardError
+            nil
+          end
+        end
+      end
+    end
+  end
+end

data/lib/legion/extensions/detect/local_migrations/20260319000001_create_detect_results.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+Sequel.migration do
+  change do
+    create_table(:detect_results) do
+      primary_key :id
+      String :name, null: false
+      String :extensions, text: true
+      String :matched_signals, text: true
+      String :installed, text: true
+      Time :scanned_at
+      Time :created_at
+      Time :updated_at
+    end
+  end
+end

data/lib/legion/extensions/detect/runners/task_observer.rb

@@ -0,0 +1,88 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module Detect
+      module Runners
+        module TaskObserver
+          extend self
+
+          def observe(tasks:, **)
+            return { success: true, alerts: [] } unless tasks.is_a?(Array)
+
+            alerts = generate_alerts(tasks)
+            check_and_publish_failure_patterns(tasks)
+            { success: true, alerts: alerts, task_count: tasks.size }
+          rescue StandardError => e
+            { success: false, reason: :error, message: e.message }
+          end
+
+          private
+
+          def generate_alerts(tasks)
+            failed = tasks.select { |t| t[:status] == 'failed' }
+            return [] if failed.empty?
+
+            failed.group_by { |t| t[:runner_class] }.filter_map do |runner_class, failures|
+              next unless failures.size >= 3
+
+              { runner_class: runner_class, failure_count: failures.size, level: :warning }
+            end
+          end
+
+          def check_and_publish_failure_patterns(tasks)
+            return unless defined?(Legion::Data) && defined?(Legion::Transport)
+
+            runner_failures = tasks.select { |t| t[:status] == 'failed' }
+                                   .group_by { |t| t[:runner_class] }
+
+            runner_failures.each do |runner_class, failures|
+              next unless failures.size >= 3
+
+              gem_name = extract_gem_name(runner_class)
+              backtraces = failures.filter_map { |f| f[:error_backtrace] }.first(5)
+              error_class = failures.first[:error_class] || 'StandardError'
+
+              pattern = build_failure_pattern(gem_name, runner_class, error_class, backtraces, failures.size)
+              publish_failure_pattern(pattern)
+            end
+          rescue StandardError
+            nil
+          end
+
+          def build_failure_pattern(gem_name, runner_class, error_class, backtraces, count)
+            {
+              gem_name:       gem_name,
+              runner_class:   runner_class,
+              error_class:    error_class,
+              backtraces:     backtraces,
+              failure_count:  count,
+              window_minutes: 60
+            }
+          end
+
+          def publish_failure_pattern(pattern)
+            return unless defined?(Legion::Transport::Messages::Dynamic)
+
+            Legion::Transport::Messages::Dynamic.new(
+              function: 'auto_fix',
+              payload:  pattern
+            ).publish
+          rescue StandardError
+            nil
+          end
+
+          def extract_gem_name(runner_class)
+            return nil unless runner_class
+
+            parts = runner_class.to_s.split('::')
+            ext_idx = parts.index('Extensions')
+            return nil unless ext_idx && parts[ext_idx + 1]
+
+            "lex-#{parts[ext_idx + 1].gsub(/([a-z])([A-Z])/, '\1_\2').downcase}"
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -3,7 +3,7 @@
 module Legion
   module Extensions
     module Detect
-      VERSION = '0.1.1'
+      VERSION = '0.1.3'
     end
   end
 end

data/lib/legion/extensions/detect.rb

@@ -4,6 +4,7 @@ require 'legion/extensions/detect/version'
 require 'legion/extensions/detect/catalog'
 require 'legion/extensions/detect/scanner'
 require 'legion/extensions/detect/installer'
+require_relative 'detect/runners/task_observer'
 
 module Legion
   module Extensions
@@ -40,6 +41,16 @@ module Legion
           CATALOG
         end
       end
+
+      require_relative 'detect/actors/full_scan' if defined?(Legion::Extensions::Actors::Once)
+      require_relative 'detect/actors/delta_scan' if defined?(Legion::Extensions::Actors::Every)
+
+      if defined?(Legion::Data::Local)
+        Legion::Data::Local.register_migrations(
+          name: :detect,
+          path: File.join(__dir__, 'detect', 'local_migrations')
+        )
+      end
     end
   end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: lex-detect
 version: !ruby/object:Gem::Version
-  version: 0.1.1
+  version: 0.1.3
 platform: ruby
 authors:
 - Esity
@@ -27,8 +27,12 @@ files:
 - README.md
 - lex-detect.gemspec
 - lib/legion/extensions/detect.rb
+- lib/legion/extensions/detect/actors/delta_scan.rb
+- lib/legion/extensions/detect/actors/full_scan.rb
 - lib/legion/extensions/detect/catalog.rb
 - lib/legion/extensions/detect/installer.rb
+- lib/legion/extensions/detect/local_migrations/20260319000001_create_detect_results.rb
+- lib/legion/extensions/detect/runners/task_observer.rb
 - lib/legion/extensions/detect/scanner.rb
 - lib/legion/extensions/detect/version.rb
 homepage: https://github.com/LegionIO/lex-detect