rubocop-legion 0.1.6 → 0.1.7

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: f841ecd6e5821651ad020bd243791971cf7ab5dca138178d90d216e8a58a48ba
-  data.tar.gz: acd221dbf9f924e6f81b21569262ea6a8aebbe42d4753356f9750cd3cc0c13a0
+  metadata.gz: cd43ed49ee3f7013316b5650cfb288d60fd6e1807532acb1f8978865a39a519e
+  data.tar.gz: a620ac1fc4debec154a69eb72a75b5df1c0a2fb8f7974e5a29fbefed46604549
 SHA512:
-  metadata.gz: 5933d7f5010bc89b49a95e3d4c0080d752d583fab9a4c11e5fc3a244a0e45938be35eeb6f6851386452d72eca5c135434b6fe1d7dc6cb2a5be163bf7a0213576
-  data.tar.gz: 62b31e59d175e345383a02764b3c1c32a7599e70af80e31d8f0685730579c5396d9cdd783e19fb16ca18809e43b33cead79b6ad03f444acc77045fe4c2dd6399
+  metadata.gz: bf447d4891c6c75429b9f0fe92a3f3fc441c11782d6bf97d9b57cc45c1ac77fbbf5314319f9aa2af9681701d4af99a609a8d56cddd63415a01db17bc6ae35ff3
+  data.tar.gz: 239ebbc2294b1ac2b366894ea17d7699a3c3532d672677d34cf8c562497bc2a51367ca6f01984af291d955d310df7fbb95bf257085bb5a37531fa10fb038ae7f

data/CHANGELOG.md

@@ -1,5 +1,18 @@
 # Changelog
 
+## [0.1.7] - 2026-03-29
+
+### Added
+- New cop `Legion/HelperMigration/DirectTransport`: use `transport_*` helpers instead of `Legion::Transport::Connection`/`Spool` methods (auto-fix)
+- New cop `Legion/HelperMigration/DirectKnowledge`: use `query_knowledge`/`ingest_knowledge` helpers instead of `Legion::Apollo`/`Legion::Apollo::Local` methods (auto-fix)
+
+### Changed
+- Renamed `Legion/HelperMigration/DirectLlmEmbed` to `Legion/HelperMigration/DirectLlm` — now covers `chat`, `ask`, `structured`, `embed_batch` in addition to `embed`
+- Expanded `Legion/HelperMigration/DirectJson` to cover `parse`, `generate`, `pretty_generate`
+- Expanded `Legion/HelperMigration/DirectCache` to cover `fetch`, `connected?`
+- Expanded `Legion/HelperMigration/DirectLocalCache` to cover `delete`, `fetch`
+- Expanded `Legion/HelperMigration/DirectCrypt` to cover `write`
+
 ## [0.1.6] - 2026-03-29
 
 ### Added

data/CLAUDE.md

@@ -4,7 +4,7 @@
 
 ## What is This?
 
-Custom RuboCop plugin gem for the LegionIO ecosystem. Provides 45 AST-based cops across 6 departments. Uses the new RuboCop Plugin API (1.72+, lint_roller-based) with auto-discovery via gemspec metadata.
+Custom RuboCop plugin gem for the LegionIO ecosystem. Provides 47 AST-based cops across 6 departments. Uses the new RuboCop Plugin API (1.72+, lint_roller-based) with auto-discovery via gemspec metadata.
 
 **GitHub**: https://github.com/LegionIO/rubocop-legion
 **RubyGems**: https://rubygems.org/gems/rubocop-legion
@@ -33,7 +33,7 @@ Cops are scoped by gem type — no per-repo configuration needed:
 
 - **Universal** (9 cops): Fire on all LegionIO gems
 - **Library-specific** (6 cops): Fire on all gems but only trigger when using Sequel, Sinatra, Thor, Faraday, or cache
-- **LEX-only** (28 cops): Scoped to `lib/legion/extensions/**/*.rb` via Include directive — never fire on core `legion-*` libraries
+- **LEX-only** (31 cops): Scoped to `lib/legion/extensions/**/*.rb` via Include directive — never fire on core `legion-*` libraries
 
 ## Departments and Cops
 
@@ -56,7 +56,7 @@ Cops are scoped by gem type — no per-repo configuration needed:
 
 ### LEX-Only — 29 cops
 
-- **HelperMigration** (11): `DirectLogging`, `OldLoggingMethods`, `DirectJson`, `DirectCache`, `DirectLocalCache`, `DirectCrypt`, `DirectData`, `DirectLlmEmbed`, `RequireDefinedGuard` (all auto-fix) — use per-extension helpers, not global singletons. `LoggingGuard` (no auto-fix) — remove unnecessary `respond_to?(:log_warn)` / `defined?(Legion::Logging)` guards. `DefinedTransportGuard` (no auto-fix) — use `transport_connected?` instead of `defined?(Legion::Transport)`.
+- **HelperMigration** (13): `DirectLogging`, `OldLoggingMethods`, `DirectJson`, `DirectCache`, `DirectLocalCache`, `DirectCrypt`, `DirectData`, `DirectLlm`, `DirectTransport`, `DirectKnowledge`, `RequireDefinedGuard` (all auto-fix) — use per-extension helpers, not global singletons. `LoggingGuard` (no auto-fix) — remove unnecessary `respond_to?(:log_warn)` / `defined?(Legion::Logging)` guards. `DefinedTransportGuard` (no auto-fix) — use `transport_connected?` instead of `defined?(Legion::Transport)`.
 - **Extension** (18): `ActorSingularModule` (auto-fix), `RunnerPluralModule` (auto-fix), `CoreExtendGuard` (auto-fix), `RunnerMustBeModule`, `RunnerIncludeHelpers`, `ActorInheritance`, `EveryActorRequiresTime`, `SelfContainedActorRunnerClass`, `HookMissingRunnerClass`, `AbsorberMissingPattern`, `AbsorberMissingAbsorbMethod`, `DefinitionCallMismatched`, `RunnerReturnHash`, `SettingsKeyMethod` (auto-fix), `SettingsBracketMultiArg` (auto-fix), `LlmAskKwargs`, `ActorEnabledSideEffects`, `DataRequiredWithoutMigrations`.
 
 ## Architecture
@@ -71,7 +71,7 @@ rubocop-legion/
 │       │   ├── version.rb
 │       │   └── plugin.rb             # LintRoller::Plugin (auto-discovery)
 │       └── cop/legion/
-│           ├── helper_migration/      # 7 cops (lex-only)
+│           ├── helper_migration/      # 13 cops (lex-only)
 │           ├── constant_safety/       # 4 cops (universal)
 │           ├── singleton/             # 1 cop  (universal)
 │           ├── rescue_logging/        # 3 cops (universal)
@@ -97,7 +97,7 @@ rubocop-legion/
 
 ```bash
 bundle install
-bundle exec rspec      # 322 specs
+bundle exec rspec      # 350 specs
 bundle exec rubocop    # Self-linting
 ```
 

data/README.md

@@ -85,19 +85,21 @@ No per-repo configuration needed for scoping. If a cop doesn't apply to your gem
 | Framework | `CacheTimeCoercion` | cache_get | convention | no | Time objects become Strings after cache round-trip |
 | Framework | `ApiStringKeys` | Legion::JSON.load | warning | yes | `Legion::JSON.load` returns symbol keys — use `body[:key]` |
 
-### LEX Extensions Only (`lib/legion/extensions/**/*.rb`) — 29 cops
+### LEX Extensions Only (`lib/legion/extensions/**/*.rb`) — 31 cops
 
 | Department | Cop | Severity | Auto-fix | Description |
 |---|---|---|---|---|
 | HelperMigration | `DirectLogging` | warning | yes | Use `log.method` instead of `Legion::Logging.method` |
 | HelperMigration | `OldLoggingMethods` | warning | yes | Use `log.method` instead of deprecated `log_method` helpers |
-| HelperMigration | `DirectJson` | convention | yes | Use `json_load`/`json_dump` instead of `Legion::JSON` |
-| HelperMigration | `DirectCache` | warning | yes | Use `cache_get`/`cache_set` instead of `Legion::Cache` |
-| HelperMigration | `DirectLocalCache` | warning | yes | Use `local_cache_get`/`local_cache_set` instead of `Legion::Cache::Local` |
-| HelperMigration | `DirectCrypt` | warning | yes | Use `vault_get`/`vault_exist?` instead of `Legion::Crypt` |
+| HelperMigration | `DirectJson` | convention | yes | Use `json_*` helpers instead of `Legion::JSON` methods |
+| HelperMigration | `DirectCache` | warning | yes | Use `cache_*` helpers instead of `Legion::Cache` methods |
+| HelperMigration | `DirectLocalCache` | warning | yes | Use `local_cache_*` helpers instead of `Legion::Cache::Local` methods |
+| HelperMigration | `DirectCrypt` | warning | yes | Use `vault_*` helpers instead of `Legion::Crypt` methods |
 | HelperMigration | `LoggingGuard` | convention | no | Remove unnecessary `respond_to?(:log_warn)` / `defined?(Legion::Logging)` guards |
 | HelperMigration | `DirectData` | convention | yes | Use `data_connection`/`local_data_*` instead of `Legion::Data::Connection`/`Local` |
-| HelperMigration | `DirectLlmEmbed` | convention | yes | Use `llm_embed` instead of `Legion::LLM.embed` |
+| HelperMigration | `DirectLlm` | convention | yes | Use `llm_*` helpers instead of `Legion::LLM` methods |
+| HelperMigration | `DirectTransport` | convention | yes | Use `transport_*` helpers instead of `Legion::Transport::Connection`/`Spool` |
+| HelperMigration | `DirectKnowledge` | convention | yes | Use `query_knowledge`/`ingest_knowledge` instead of `Legion::Apollo` methods |
 | HelperMigration | `RequireDefinedGuard` | convention | yes | Remove `if defined?(Legion::...)` guard from `require` statements |
 | HelperMigration | `DefinedTransportGuard` | convention | no | Use `transport_connected?` instead of `defined?(Legion::Transport)` |
 | Extension | `ActorSingularModule` | error | yes | Use `module Actor` (singular) — framework discovers `Actor`, not `Actors` |
@@ -119,7 +121,7 @@ No per-repo configuration needed for scoping. If a cop doesn't apply to your gem
 | Extension | `ActorEnabledSideEffects` | convention | no | `enabled?` runs during boot — keep side-effect-free |
 | Extension | `DataRequiredWithoutMigrations` | warning | no | `data_required?` returns true but migrations may be missing |
 
-**Total: 45 custom cops** across 6 departments, 19 auto-correctable.
+**Total: 47 custom cops** across 6 departments, 21 auto-correctable.
 
 ### Bundled Plugins
 

data/config/default.yml

@@ -20,28 +20,32 @@ Legion/HelperMigration/OldLoggingMethods:
   VersionAdded: '0.1'
 
 Legion/HelperMigration/DirectJson:
-  Description: 'Use `json_load`/`json_dump` helpers instead of `Legion::JSON.load`/`.dump`.'
+  Description: 'Use `json_*` helpers instead of `Legion::JSON` methods.'
   Enabled: true
   Severity: convention
   VersionAdded: '0.1'
+  VersionChanged: '0.1.7'
 
 Legion/HelperMigration/DirectCache:
-  Description: 'Use `cache_get`/`cache_set`/`cache_delete` helpers instead of `Legion::Cache` methods.'
+  Description: 'Use `cache_*` helpers instead of `Legion::Cache` methods.'
   Enabled: true
   Severity: warning
   VersionAdded: '0.1'
+  VersionChanged: '0.1.7'
 
 Legion/HelperMigration/DirectLocalCache:
-  Description: 'Use `local_cache_get`/`local_cache_set` helpers instead of `Legion::Cache::Local` methods.'
+  Description: 'Use `local_cache_*` helpers instead of `Legion::Cache::Local` methods.'
   Enabled: true
   Severity: warning
   VersionAdded: '0.1'
+  VersionChanged: '0.1.7'
 
 Legion/HelperMigration/DirectCrypt:
-  Description: 'Use `vault_get`/`vault_exist?` helpers instead of `Legion::Crypt` methods.'
+  Description: 'Use `vault_*` helpers instead of `Legion::Crypt` methods.'
   Enabled: true
   Severity: warning
   VersionAdded: '0.1'
+  VersionChanged: '0.1.7'
 
 Legion/HelperMigration/LoggingGuard:
   Description: 'Remove unnecessary `respond_to?(:log_warn)` or `defined?(Legion::Logging)` guards.'
@@ -55,11 +59,24 @@ Legion/HelperMigration/DirectData:
   Severity: convention
   VersionAdded: '0.1.4'
 
-Legion/HelperMigration/DirectLlmEmbed:
-  Description: 'Use `llm_embed` helper instead of `Legion::LLM.embed`.'
+Legion/HelperMigration/DirectLlm:
+  Description: 'Use `llm_*` helpers instead of `Legion::LLM` methods.'
   Enabled: true
   Severity: convention
   VersionAdded: '0.1.4'
+  VersionChanged: '0.1.7'
+
+Legion/HelperMigration/DirectTransport:
+  Description: 'Use `transport_*` helpers instead of `Legion::Transport::Connection`/`Spool` methods.'
+  Enabled: true
+  Severity: convention
+  VersionAdded: '0.1.7'
+
+Legion/HelperMigration/DirectKnowledge:
+  Description: 'Use `query_knowledge`/`ingest_knowledge` helpers instead of `Legion::Apollo` methods.'
+  Enabled: true
+  Severity: convention
+  VersionAdded: '0.1.7'
 
 Legion/HelperMigration/RequireDefinedGuard:
   Description: 'Remove `if defined?(Legion::...)` guard from `require`/`require_relative` statements.'

data/lib/rubocop/cop/legion/helper_migration/direct_cache.rb

@@ -4,36 +4,42 @@ module RuboCop
   module Cop
     module Legion
       module HelperMigration
-        # Detects direct calls to `Legion::Cache.get`, `.set`, and `.delete`
-        # and suggests using the `cache_get`, `cache_set`, `cache_delete` helpers.
+        # Detects direct calls to `Legion::Cache` methods and suggests using
+        # the `cache_*` helpers instead.
         #
         # @example
         #   # bad
         #   Legion::Cache.get('key')
         #   Legion::Cache.set('key', value)
         #   Legion::Cache.delete('key')
+        #   Legion::Cache.fetch('key') { compute }
+        #   Legion::Cache.connected?
         #
         #   # good
         #   cache_get('key')
         #   cache_set('key', value)
         #   cache_delete('key')
+        #   cache_fetch('key') { compute }
+        #   cache_connected?
         class DirectCache < RuboCop::Cop::Base
           extend AutoCorrector
 
           MSG = 'Use `%<helper>s` instead of `Legion::Cache.%<method>s`. ' \
                 'Include the appropriate cache helper mixin.'
 
-          RESTRICT_ON_SEND = %i[get set delete].freeze
+          RESTRICT_ON_SEND = %i[get set delete fetch connected?].freeze
 
           HELPER_MAP = {
             get: 'cache_get',
             set: 'cache_set',
-            delete: 'cache_delete'
+            delete: 'cache_delete',
+            fetch: 'cache_fetch',
+            connected?: 'cache_connected?'
           }.freeze
 
           # @!method legion_cache_call?(node)
           def_node_matcher :legion_cache_call?, <<~PATTERN
-            (send (const (const nil? :Legion) :Cache) {:get :set :delete} ...)
+            (send (const (const nil? :Legion) :Cache) {:get :set :delete :fetch :connected?} ...)
           PATTERN
 
           def on_send(node)
@@ -44,8 +50,12 @@ module RuboCop
             message = format(MSG, helper: helper, method: method_name)
 
             add_offense(node, message: message) do |corrector|
-              args_source = node.arguments.map(&:source).join(', ')
-              corrector.replace(node, "#{helper}(#{args_source})")
+              if node.arguments.empty?
+                corrector.replace(node, helper)
+              else
+                args_source = node.arguments.map(&:source).join(', ')
+                corrector.replace(node, "#{helper}(#{args_source})")
+              end
             end
           end
         end

data/lib/rubocop/cop/legion/helper_migration/direct_crypt.rb

@@ -4,33 +4,36 @@ module RuboCop
   module Cop
     module Legion
       module HelperMigration
-        # Detects direct calls to `Legion::Crypt.get` and `Legion::Crypt.exist?`
-        # and suggests using the `vault_get` / `vault_exist?` helpers instead.
+        # Detects direct calls to `Legion::Crypt` methods and suggests using
+        # the `vault_*` helpers instead.
         #
         # @example
         #   # bad
         #   Legion::Crypt.get('secret/path')
         #   Legion::Crypt.exist?('secret/path')
+        #   Legion::Crypt.write('secret/path', data)
         #
         #   # good
         #   vault_get('secret/path')
         #   vault_exist?('secret/path')
+        #   vault_write('secret/path', data)
         class DirectCrypt < RuboCop::Cop::Base
           extend AutoCorrector
 
           MSG = 'Use `%<helper>s` instead of `Legion::Crypt.%<method>s`. ' \
                 'Include the appropriate Vault/Crypt helper mixin.'
 
-          RESTRICT_ON_SEND = %i[get exist?].freeze
+          RESTRICT_ON_SEND = %i[get exist? write].freeze
 
           HELPER_MAP = {
             get: 'vault_get',
-            exist?: 'vault_exist?'
+            exist?: 'vault_exist?',
+            write: 'vault_write'
           }.freeze
 
           # @!method legion_crypt_call?(node)
           def_node_matcher :legion_crypt_call?, <<~PATTERN
-            (send (const (const nil? :Legion) :Crypt) {:get :exist?} ...)
+            (send (const (const nil? :Legion) :Crypt) {:get :exist? :write} ...)
           PATTERN
 
           def on_send(node)

data/lib/rubocop/cop/legion/helper_migration/direct_json.rb

@@ -4,33 +4,42 @@ module RuboCop
   module Cop
     module Legion
       module HelperMigration
-        # Detects direct calls to `Legion::JSON.load` and `Legion::JSON.dump`
-        # and suggests using the `json_load` / `json_dump` helpers instead.
+        # Detects direct calls to `Legion::JSON` methods and suggests using
+        # the `json_*` helpers instead.
         #
         # @example
         #   # bad
         #   Legion::JSON.load(str)
         #   Legion::JSON.dump(obj)
+        #   Legion::JSON.parse(str)
+        #   Legion::JSON.generate(obj)
+        #   Legion::JSON.pretty_generate(obj)
         #
         #   # good
         #   json_load(str)
         #   json_dump(obj)
+        #   json_parse(str)
+        #   json_generate(obj)
+        #   json_pretty_generate(obj)
         class DirectJson < RuboCop::Cop::Base
           extend AutoCorrector
 
           MSG = 'Use `%<helper>s` instead of `Legion::JSON.%<method>s`. ' \
                 'Include the appropriate JSON helper mixin.'
 
-          RESTRICT_ON_SEND = %i[load dump].freeze
+          RESTRICT_ON_SEND = %i[load dump parse generate pretty_generate].freeze
 
           HELPER_MAP = {
             load: 'json_load',
-            dump: 'json_dump'
+            dump: 'json_dump',
+            parse: 'json_parse',
+            generate: 'json_generate',
+            pretty_generate: 'json_pretty_generate'
           }.freeze
 
           # @!method legion_json_call?(node)
           def_node_matcher :legion_json_call?, <<~PATTERN
-            (send (const (const nil? :Legion) :JSON) {:load :dump} ...)
+            (send (const (const nil? :Legion) :JSON) {:load :dump :parse :generate :pretty_generate} ...)
           PATTERN
 
           def on_send(node)

data/lib/rubocop/cop/legion/helper_migration/direct_knowledge.rb

@@ -0,0 +1,82 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Legion
+      module HelperMigration
+        # Detects direct calls to `Legion::Apollo` and `Legion::Apollo::Local`
+        # methods and suggests using the `query_knowledge` / `ingest_knowledge`
+        # helpers instead.
+        #
+        # @example
+        #   # bad
+        #   Legion::Apollo.query(text: 'search')
+        #   Legion::Apollo.ingest(content, tags: [:foo])
+        #   Legion::Apollo::Local.query(text: 'search')
+        #   Legion::Apollo::Local.ingest(content)
+        #
+        #   # good
+        #   query_knowledge(text: 'search')
+        #   ingest_knowledge(content, tags: [:foo])
+        #   query_knowledge(text: 'search', scope: :local)
+        #   ingest_knowledge(content, scope: :local)
+        class DirectKnowledge < RuboCop::Cop::Base
+          extend AutoCorrector
+
+          MSG = 'Use `%<helper>s` instead of `%<receiver>s.%<method>s`. ' \
+                'Include the knowledge helper mixin.'
+
+          RESTRICT_ON_SEND = %i[query ingest].freeze
+
+          GLOBAL_MAP = {
+            query: 'query_knowledge',
+            ingest: 'ingest_knowledge'
+          }.freeze
+
+          # @!method apollo_global_call?(node)
+          def_node_matcher :apollo_global_call?, <<~PATTERN
+            (send (const (const nil? :Legion) :Apollo) {:query :ingest} ...)
+          PATTERN
+
+          # @!method apollo_local_call?(node)
+          def_node_matcher :apollo_local_call?, <<~PATTERN
+            (send (const (const (const nil? :Legion) :Apollo) :Local) {:query :ingest} ...)
+          PATTERN
+
+          def on_send(node)
+            if apollo_global_call?(node)
+              register_global_offense(node)
+            elsif apollo_local_call?(node)
+              register_local_offense(node)
+            end
+          end
+
+          private
+
+          def register_global_offense(node)
+            method_name = node.method_name
+            helper = GLOBAL_MAP[method_name]
+            message = format(MSG, helper: helper, receiver: 'Legion::Apollo', method: method_name)
+
+            add_offense(node, message: message) do |corrector|
+              args_source = node.arguments.map(&:source).join(', ')
+              corrector.replace(node, "#{helper}(#{args_source})")
+            end
+          end
+
+          def register_local_offense(node)
+            method_name = node.method_name
+            helper = GLOBAL_MAP[method_name]
+            message = format(MSG, helper: helper, receiver: 'Legion::Apollo::Local', method: method_name)
+
+            add_offense(node, message: message) do |corrector|
+              args_source = node.arguments.map(&:source).join(', ')
+              scope_arg = args_source.empty? ? 'scope: :local' : "#{args_source}, scope: :local"
+              corrector.replace(node, "#{helper}(#{scope_arg})")
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/legion/helper_migration/direct_llm.rb

@@ -0,0 +1,61 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Legion
+      module HelperMigration
+        # Detects direct calls to `Legion::LLM` methods and suggests using
+        # the `llm_*` helpers from `Legion::Extensions::Helpers::LLM`.
+        #
+        # @example
+        #   # bad
+        #   Legion::LLM.embed(text)
+        #   Legion::LLM.chat(message, intent: :moderate)
+        #   Legion::LLM.ask(message: 'hello')
+        #   Legion::LLM.structured(messages: [], schema: {})
+        #   Legion::LLM.embed_batch(texts)
+        #
+        #   # good
+        #   llm_embed(text)
+        #   llm_chat(message, intent: :moderate)
+        #   llm_ask(message: 'hello')
+        #   llm_structured(messages: [], schema: {})
+        #   llm_embed_batch(texts)
+        class DirectLlm < RuboCop::Cop::Base
+          extend AutoCorrector
+
+          MSG = 'Use `%<helper>s` instead of `Legion::LLM.%<method>s`. ' \
+                'Include the LLM helper mixin.'
+
+          RESTRICT_ON_SEND = %i[embed chat ask structured embed_batch].freeze
+
+          HELPER_MAP = {
+            embed: 'llm_embed',
+            chat: 'llm_chat',
+            ask: 'llm_ask',
+            structured: 'llm_structured',
+            embed_batch: 'llm_embed_batch'
+          }.freeze
+
+          # @!method legion_llm_call?(node)
+          def_node_matcher :legion_llm_call?, <<~PATTERN
+            (send (const (const nil? :Legion) :LLM) {:embed :chat :ask :structured :embed_batch} ...)
+          PATTERN
+
+          def on_send(node)
+            return unless legion_llm_call?(node)
+
+            method_name = node.method_name
+            helper = HELPER_MAP[method_name]
+            message = format(MSG, helper: helper, method: method_name)
+
+            add_offense(node, message: message) do |corrector|
+              args_source = node.arguments.map(&:source).join(', ')
+              corrector.replace(node, "#{helper}(#{args_source})")
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/legion/helper_migration/direct_local_cache.rb

@@ -4,33 +4,39 @@ module RuboCop
   module Cop
     module Legion
       module HelperMigration
-        # Detects direct calls to `Legion::Cache::Local.get` and `.set`
-        # and suggests using the `local_cache_get` / `local_cache_set` helpers.
+        # Detects direct calls to `Legion::Cache::Local` methods and suggests
+        # using the `local_cache_*` helpers instead.
         #
         # @example
         #   # bad
         #   Legion::Cache::Local.get('key')
         #   Legion::Cache::Local.set('key', value)
+        #   Legion::Cache::Local.delete('key')
+        #   Legion::Cache::Local.fetch('key') { compute }
         #
         #   # good
         #   local_cache_get('key')
         #   local_cache_set('key', value)
+        #   local_cache_delete('key')
+        #   local_cache_fetch('key') { compute }
         class DirectLocalCache < RuboCop::Cop::Base
           extend AutoCorrector
 
           MSG = 'Use `%<helper>s` instead of `Legion::Cache::Local.%<method>s`. ' \
                 'Include the appropriate local cache helper mixin.'
 
-          RESTRICT_ON_SEND = %i[get set].freeze
+          RESTRICT_ON_SEND = %i[get set delete fetch].freeze
 
           HELPER_MAP = {
             get: 'local_cache_get',
-            set: 'local_cache_set'
+            set: 'local_cache_set',
+            delete: 'local_cache_delete',
+            fetch: 'local_cache_fetch'
           }.freeze
 
           # @!method legion_local_cache_call?(node)
           def_node_matcher :legion_local_cache_call?, <<~PATTERN
-            (send (const (const (const nil? :Legion) :Cache) :Local) {:get :set} ...)
+            (send (const (const (const nil? :Legion) :Cache) :Local) {:get :set :delete :fetch} ...)
           PATTERN
 
           def on_send(node)

data/lib/rubocop/cop/legion/helper_migration/direct_transport.rb

@@ -0,0 +1,76 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Legion
+      module HelperMigration
+        # Detects direct calls to `Legion::Transport::Connection` methods
+        # and suggests using the `transport_*` helpers instead.
+        #
+        # @example
+        #   # bad
+        #   Legion::Transport::Connection.session_open?
+        #   Legion::Transport::Connection.channel_open?
+        #   Legion::Transport::Connection.lite_mode?
+        #   Legion::Transport::Connection.channel
+        #
+        #   # good
+        #   transport_session_open?
+        #   transport_channel_open?
+        #   transport_lite_mode?
+        #   transport_channel
+        class DirectTransport < RuboCop::Cop::Base
+          extend AutoCorrector
+
+          MSG = 'Use `%<helper>s` instead of `%<receiver>s.%<method>s`. ' \
+                'Include the transport helper mixin.'
+
+          RESTRICT_ON_SEND = %i[session_open? channel_open? lite_mode? channel count].freeze
+
+          CONNECTION_MAP = {
+            session_open?: 'transport_session_open?',
+            channel_open?: 'transport_channel_open?',
+            lite_mode?: 'transport_lite_mode?',
+            channel: 'transport_channel'
+          }.freeze
+
+          SPOOL_MAP = {
+            count: 'transport_spool_count'
+          }.freeze
+
+          # @!method transport_connection_call?(node)
+          def_node_matcher :transport_connection_call?, <<~PATTERN
+            (send (const (const (const nil? :Legion) :Transport) :Connection) {:session_open? :channel_open? :lite_mode? :channel} ...)
+          PATTERN
+
+          # @!method transport_spool_call?(node)
+          def_node_matcher :transport_spool_call?, <<~PATTERN
+            (send (const (const (const nil? :Legion) :Transport) :Spool) :count ...)
+          PATTERN
+
+          def on_send(node)
+            if transport_connection_call?(node)
+              register_offense(node, 'Legion::Transport::Connection', CONNECTION_MAP)
+            elsif transport_spool_call?(node)
+              register_offense(node, 'Legion::Transport::Spool', SPOOL_MAP)
+            end
+          end
+
+          private
+
+          def register_offense(node, receiver, helper_map)
+            method_name = node.method_name
+            helper = helper_map[method_name]
+            message = format(MSG, helper: helper, receiver: receiver, method: method_name)
+
+            add_offense(node, message: message) do |corrector|
+              args_source = node.arguments.map(&:source).join(', ')
+              replacement = node.arguments.empty? ? helper : "#{helper}(#{args_source})"
+              corrector.replace(node, replacement)
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/legion/version.rb

@@ -2,6 +2,6 @@
 
 module RuboCop
   module Legion
-    VERSION = '0.1.6'
+    VERSION = '0.1.7'
   end
 end

data/lib/rubocop-legion.rb

@@ -15,7 +15,9 @@ require 'rubocop/cop/legion/helper_migration/direct_local_cache'
 require 'rubocop/cop/legion/helper_migration/direct_crypt'
 require 'rubocop/cop/legion/helper_migration/logging_guard'
 require 'rubocop/cop/legion/helper_migration/direct_data'
-require 'rubocop/cop/legion/helper_migration/direct_llm_embed'
+require 'rubocop/cop/legion/helper_migration/direct_llm'
+require 'rubocop/cop/legion/helper_migration/direct_transport'
+require 'rubocop/cop/legion/helper_migration/direct_knowledge'
 require 'rubocop/cop/legion/helper_migration/require_defined_guard'
 require 'rubocop/cop/legion/helper_migration/defined_transport_guard'
 

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: rubocop-legion
 version: !ruby/object:Gem::Version
-  version: 0.1.6
+  version: 0.1.7
 platform: ruby
 authors:
 - Esity
@@ -151,9 +151,11 @@ files:
 - lib/rubocop/cop/legion/helper_migration/direct_crypt.rb
 - lib/rubocop/cop/legion/helper_migration/direct_data.rb
 - lib/rubocop/cop/legion/helper_migration/direct_json.rb
-- lib/rubocop/cop/legion/helper_migration/direct_llm_embed.rb
+- lib/rubocop/cop/legion/helper_migration/direct_knowledge.rb
+- lib/rubocop/cop/legion/helper_migration/direct_llm.rb
 - lib/rubocop/cop/legion/helper_migration/direct_local_cache.rb
 - lib/rubocop/cop/legion/helper_migration/direct_logging.rb
+- lib/rubocop/cop/legion/helper_migration/direct_transport.rb
 - lib/rubocop/cop/legion/helper_migration/logging_guard.rb
 - lib/rubocop/cop/legion/helper_migration/old_logging_methods.rb
 - lib/rubocop/cop/legion/helper_migration/require_defined_guard.rb

data/lib/rubocop/cop/legion/helper_migration/direct_llm_embed.rb

@@ -1,43 +0,0 @@
-# frozen_string_literal: true
-
-module RuboCop
-  module Cop
-    module Legion
-      module HelperMigration
-        # Detects direct calls to `Legion::LLM.embed` and suggests using the
-        # `llm_embed` helper from `Legion::Extensions::Helpers::LLM`.
-        #
-        # @example
-        #   # bad
-        #   Legion::LLM.embed(text)
-        #   Legion::LLM.embed(text, provider: :bedrock)
-        #
-        #   # good
-        #   llm_embed(text)
-        #   llm_embed(text, provider: :bedrock)
-        class DirectLlmEmbed < RuboCop::Cop::Base
-          extend AutoCorrector
-
-          MSG = 'Use `llm_embed` instead of `Legion::LLM.embed`. ' \
-                'Include `Legion::Extensions::Helpers::LLM` via the LLM helper mixin.'
-
-          RESTRICT_ON_SEND = %i[embed].freeze
-
-          # @!method legion_llm_embed?(node)
-          def_node_matcher :legion_llm_embed?, <<~PATTERN
-            (send (const (const nil? :Legion) :LLM) :embed ...)
-          PATTERN
-
-          def on_send(node)
-            return unless legion_llm_embed?(node)
-
-            add_offense(node, message: MSG) do |corrector|
-              args_source = node.arguments.map(&:source).join(', ')
-              corrector.replace(node, "llm_embed(#{args_source})")
-            end
-          end
-        end
-      end
-    end
-  end
-end