lex-detect 0.1.2 → 0.1.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: ac8b336bd2c34b58a559c0f4b664c728b2c61991d9f88f4a4bc83014ff5fe45f
-  data.tar.gz: 8d6b78909cf1e3c405f6251099f686882bab688496a66588681ad6646e7b2455
+  metadata.gz: 4be5aba6e8a22792e9f9fcbc2db27f18fe2d51f176044e7a18bdcc7db534becf
+  data.tar.gz: de631309f69e478a59d46d7ea9d8f0ff90f4ceff01e198424813e5bece7c00a1
 SHA512:
-  metadata.gz: e0f94a3e7c7f3ab15a9f27c5646423d98a9c275c203911a8c6d3a44c1c17830c3de2cd1cad4e5d769e5d1662ab54e03daedfb3f885cd579d47ab62ef67c83031
-  data.tar.gz: ac6498c5166dc7cbf6b077be7476b8911c979fe3eb911703840bb87f7944f35a5262581d6918ba4a142c98d37f4373816ac0eb68e7dae9b114f82979e4dd6afe
+  metadata.gz: 18ef38241cf694a8244900735878fe5e5f49a70e3cedf50db94eb2e902aec8c84ecd3074e79a98320accea445e10b9145eca6590fc5fda4b2efce07e5338f737
+  data.tar.gz: af5e47f0566ca56b6b1eee75afd6620a5ec6201363e2c1d68ca89d47681221a0634979a52d9e941764204b3cdeb6745a4d9e33305537f548044c148425b137b0

data/CHANGELOG.md

@@ -1,5 +1,25 @@
 # Changelog
 
+## [0.1.4] - 2026-03-20
+
+### Changed
+- Version bump for deployment (0.1.3 was released before task observer and cancel task changes landed)
+
+## [0.1.3] - 2026-03-20
+
+### Added
+- `Runners::TaskObserver` for monitoring task failure patterns; supports DB-based `observe(since:)` and array-based `observe(tasks:)` calling styles
+- `check_timeout_risk` detects tasks running beyond 2x expected duration and emits `timeout_risk` alert
+- `check_repeated_failure` detects >=3 failures in 10 minutes per runner class
+- `publish_alerts` forwards structured alerts to AMQP when `Legion::Transport` is available
+- `record_observations` persists per-task observation records to `Legion::Data::Local` observer_events table
+- `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
+- `Runners::CancelTask` sets `cancelled_at` timestamp on tasks, guarded by `Legion::Data` availability
+- `Actors::ObserverTick` runs `TaskObserver#observe` every 60 seconds, passing `since:` for incremental DB scans
+- Local migration `20260320000001_create_observer_events` creates observer_events table for cognitive observation history
+
 ## [0.1.2] - 2026-03-19
 
 ### Added

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-core/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.1
+**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/observer_tick.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module Detect
+      module Actors
+        class ObserverTick < Legion::Extensions::Actors::Every
+          def time = 60
+          def run_now? = false
+          def use_runner? = false
+          def check_subtask? = false
+          def generate_task? = false
+
+          def action(**_opts)
+            observer = Object.new.extend(Runners::TaskObserver)
+            observer.observe(since: @last_tick || (Time.now - 60))
+          ensure
+            @last_tick = Time.now
+          end
+        end
+      end
+    end
+  end
+end

data/lib/legion/extensions/detect/local_migrations/20260320000001_create_observer_events.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+Sequel.migration do
+  up do
+    create_table?(:observer_events) do
+      primary_key :id
+      String :task_id, size: 64
+      String :runner, size: 255
+      String :rule, size: 64, null: true
+      String :severity, size: 16, null: true
+      Float :duration, null: true
+      Float :token_cost, null: true
+      DateTime :observed_at, null: false, default: Sequel::CURRENT_TIMESTAMP
+      index :task_id
+      index :rule
+      index :observed_at
+    end
+  end
+
+  down do
+    drop_table?(:observer_events)
+  end
+end

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

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module Detect
+      module Runners
+        module CancelTask
+          def cancel_task(task_id:, **)
+            return { success: false, reason: :data_unavailable } unless defined?(Legion::Data)
+
+            task = Legion::Data::Model::Task[task_id]
+            return { success: false, reason: :not_found } unless task
+            return { success: false, reason: :already_cancelled } if task.respond_to?(:cancelled?) && task.cancelled?
+
+            task.update(cancelled_at: Time.now.utc)
+            { success: true, task_id: task_id, cancelled_at: task.cancelled_at }
+          rescue StandardError => e
+            { success: false, reason: :error, message: e.message }
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,187 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module Detect
+      module Runners
+        module TaskObserver
+          extend self
+
+          def observe(tasks: nil, since: nil, **)
+            return observe_db(since: since) if tasks.nil?
+
+            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 observe_db(since: nil)
+            return { alerts: [], observed: 0 } unless defined?(Legion::Data)
+
+            since ||= Time.now - 60
+            db_tasks = Legion::Data.connection[:tasks]
+                                   .where { started_at > since }
+                                   .all
+
+            alerts = db_tasks.filter_map { |task| evaluate_rules(task) }
+
+            publish_alerts(alerts) if alerts.any?
+            record_observations(db_tasks, alerts)
+
+            { alerts: alerts, observed: db_tasks.size }
+          rescue StandardError => e
+            { alerts: [], observed: 0, error: e.message }
+          end
+
+          def evaluate_rules(task)
+            check_timeout_risk(task) ||
+              check_repeated_failure(task) ||
+              check_cost_spike(task)
+          end
+
+          def check_timeout_risk(task, expected_duration: 120)
+            return nil unless task[:status] == 'running' && task[:started_at]
+
+            elapsed = Time.now - task[:started_at]
+            return nil unless elapsed > (expected_duration * 2)
+
+            {
+              rule:        'timeout_risk',
+              runner:      task[:runner_class],
+              task_id:     task[:id],
+              severity:    'warn',
+              detail:      "Running for #{elapsed.round}s (expected #{expected_duration}s)",
+              observed_at: Time.now.utc
+            }
+          end
+
+          def check_repeated_failure(task)
+            return nil unless defined?(Legion::Data) && task[:runner_class]
+
+            count = Legion::Data.connection[:tasks]
+                                .where(runner_class: task[:runner_class], status: 'failed')
+                                .where { started_at > Time.now - 600 }
+                                .count
+            return nil unless count >= 3
+
+            {
+              rule:        'repeated_failure',
+              runner:      task[:runner_class],
+              task_id:     task[:id],
+              severity:    'critical',
+              detail:      "#{count} failures in last 10 minutes",
+              observed_at: Time.now.utc
+            }
+          rescue StandardError
+            nil
+          end
+
+          def check_cost_spike(_task)
+            nil
+          end
+
+          def publish_alerts(alerts)
+            return unless defined?(Legion::Transport)
+
+            alerts.each do |alert|
+              Legion::Transport::Messages::Dynamic.new(
+                function: 'observer_alert',
+                payload:  alert
+              ).publish
+            end
+          rescue StandardError
+            nil
+          end
+
+          def record_observations(db_tasks, alerts)
+            return unless defined?(Legion::Data::Local)
+
+            db_tasks.each do |task|
+              alert = alerts.find { |a| a[:task_id] == task[:id] }
+              Legion::Data::Local.connection[:observer_events].insert(
+                task_id:     task[:id],
+                runner:      task[:runner_class],
+                rule:        alert&.dig(:rule),
+                severity:    alert&.dig(:severity),
+                duration:    task[:started_at] ? (Time.now - task[:started_at]).round(2) : nil,
+                token_cost:  nil,
+                observed_at: Time.now.utc
+              )
+            end
+          rescue StandardError
+            nil
+          end
+
+          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.2'
+      VERSION = '0.1.4'
     end
   end
 end

data/lib/legion/extensions/detect.rb

@@ -4,6 +4,8 @@ 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'
+require_relative 'detect/runners/cancel_task'
 
 module Legion
   module Extensions
@@ -43,6 +45,7 @@ module Legion
 
       require_relative 'detect/actors/full_scan' if defined?(Legion::Extensions::Actors::Once)
       require_relative 'detect/actors/delta_scan' if defined?(Legion::Extensions::Actors::Every)
+      require_relative 'detect/actors/observer_tick' if defined?(Legion::Extensions::Actors::Every)
 
       if defined?(Legion::Data::Local)
         Legion::Data::Local.register_migrations(

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: lex-detect
 version: !ruby/object:Gem::Version
-  version: 0.1.2
+  version: 0.1.4
 platform: ruby
 authors:
 - Esity
@@ -29,9 +29,13 @@ files:
 - 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/actors/observer_tick.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/local_migrations/20260320000001_create_observer_events.rb
+- lib/legion/extensions/detect/runners/cancel_task.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