RubyGems - rubocop-legion - Versions diffs - 0.1.6 → 0.1.8 - Mend

rubocop-legion 0.1.6 → 0.1.8

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (22) hide show

checksums.yaml +4 -4
data/.rubocop.yml +9 -0
data/CHANGELOG.md +21 -0
data/CLAUDE.md +19 -77
data/README.md +9 -7
data/config/default.yml +50 -6
data/lib/rubocop/cop/legion/extension/every_actor_requires_time.rb +5 -1
data/lib/rubocop/cop/legion/framework/no_direct_dispatch.rb +109 -0
data/lib/rubocop/cop/legion/framework/no_inline_setting_defaults.rb +110 -0
data/lib/rubocop/cop/legion/framework/no_shape_duck_typing.rb +100 -0
data/lib/rubocop/cop/legion/framework/no_underscore_prefixed_kwargs.rb +89 -0
data/lib/rubocop/cop/legion/helper_migration/direct_cache.rb +17 -7
data/lib/rubocop/cop/legion/helper_migration/direct_crypt.rb +8 -5
data/lib/rubocop/cop/legion/helper_migration/direct_json.rb +14 -5
data/lib/rubocop/cop/legion/helper_migration/direct_knowledge.rb +82 -0
data/lib/rubocop/cop/legion/helper_migration/direct_llm.rb +61 -0
data/lib/rubocop/cop/legion/helper_migration/direct_local_cache.rb +11 -5
data/lib/rubocop/cop/legion/helper_migration/direct_transport.rb +76 -0
data/lib/rubocop/legion/version.rb +1 -1
data/lib/rubocop-legion.rb +7 -1
metadata +9 -3
data/lib/rubocop/cop/legion/helper_migration/direct_llm_embed.rb +0 -43

checksums.yaml CHANGED Viewed

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: f841ecd6e5821651ad020bd243791971cf7ab5dca138178d90d216e8a58a48ba
-  data.tar.gz: acd221dbf9f924e6f81b21569262ea6a8aebbe42d4753356f9750cd3cc0c13a0
+  metadata.gz: '0668cc51aab49685f7ecb368113a7103253ec4d3aca22de2970c88ff4ae351f3'
+  data.tar.gz: abc9644c2e563387778df1459aa7abd81f49e79c14e7cc13e038546ceab40a56
 SHA512:
-  metadata.gz: 5933d7f5010bc89b49a95e3d4c0080d752d583fab9a4c11e5fc3a244a0e45938be35eeb6f6851386452d72eca5c135434b6fe1d7dc6cb2a5be163bf7a0213576
-  data.tar.gz: 62b31e59d175e345383a02764b3c1c32a7599e70af80e31d8f0685730579c5396d9cdd783e19fb16ca18809e43b33cead79b6ad03f444acc77045fe4c2dd6399
+  metadata.gz: 43d9efec4fb9f8fc5af8eced138ed626c29211017382b4c71b84f3191b2b5316624e64821e657cf4e8a61426f51404c147c32522d623c3cce3c50d51f9738afe
+  data.tar.gz: 17807228e3e91cd2e4ac0be778a469256adbe691e7b0f1b6399344cb6d1ecffe6e699a5db7ffcf274a42d1a0df531842b32e218f89230d1ae1ced828ef733fbd

data/.rubocop.yml CHANGED Viewed

@@ -9,6 +9,15 @@ Style/Documentation:
 Metrics/MethodLength:
   Max: 20
+Metrics/AbcSize:
+  Max: 35
+Metrics/CyclomaticComplexity:
+  Max: 20
+Metrics/PerceivedComplexity:
+  Max: 20
 Naming/FileName:
   Exclude:
     - 'lib/rubocop-legion.rb'

data/CHANGELOG.md CHANGED Viewed

@@ -1,5 +1,26 @@
 # Changelog
+## [0.1.8] - 2026-06-16
+### Added
+- New cop `Legion/Framework/NoUnderscorePrefixedKwargs`: ban `_foo:` keyword arguments and `**_rest` splats; autocorrects to plain names / `**opts`
+- New cop `Legion/Framework/NoInlineSettingDefaults`: flag `Legion::Settings[...] || <literal>` and shadow-default patterns (tunables belong in `settings.rb`)
+- New cop `Legion/Framework/NoDirectDispatch`: ban `*_direct` methods on `Legion::LLM` modules (every pipeline exit must route through the governed pipeline)
+- New cop `Legion/Framework/NoShapeDuckTyping` (disabled by default): flag `respond_to?` on canonical shape methods and string-key fallback access on canonical bodies
+## [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 CHANGED Viewed

@@ -1,114 +1,56 @@
 # rubocop-legion
-**Parent**: `/Users/miverso2/rubymine/legion/CLAUDE.md`
-## 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.
-**GitHub**: https://github.com/LegionIO/rubocop-legion
-**RubyGems**: https://rubygems.org/gems/rubocop-legion
-**License**: MIT
+Custom RuboCop plugin gem for the LegionIO ecosystem. Provides 47 AST-based cops across 6 departments. Uses the RuboCop Plugin API (1.72+, lint_roller-based) with auto-discovery via gemspec metadata.
 ## Shared Config Profiles
-The gem ships shared `.rubocop.yml` profiles so repos don't duplicate config:
 - `config/base.yml` — all shared settings (AllCops, Layout, Metrics, Style, Naming, Performance, ThreadSafety)
-- `config/lex.yml` — inherits base, adds plugins (rubocop-legion + performance + thread_safety) + `ParameterLists Max: 8`
-- `config/core.yml` — inherits base, adds plugins (rubocop-legion + performance + thread_safety) + `ParameterLists Max: 10, CountKeywordArgs: false`
-### Bundled Plugins
+- `config/lex.yml` — inherits base, adds plugins + `ParameterLists Max: 8`
+- `config/core.yml` — inherits base, adds plugins + `ParameterLists Max: 10, CountKeywordArgs: false`
-Both profiles load `rubocop-performance` (52 cops) and `rubocop-thread_safety` (6 cops) as runtime dependencies. ThreadSafety defaults tuned for LegionIO: `NewThread` excludes service/connection files, `ClassInstanceVariable` excludes singletons, `RackMiddlewareInstanceVariable` disabled, `DirChdir` allows block form.
+Both profiles load `rubocop-performance` (52 cops) and `rubocop-thread_safety` (6 cops) as runtime dependencies.
 **LEX repos**: `inherit_gem: { rubocop-legion: config/lex.yml }`
 **Core repos**: `inherit_gem: { rubocop-legion: config/core.yml }`
-Repo-specific overrides go below the `inherit_gem` directive. Version-locked with the gem — bump gem version = all repos get updated config.
-## Cop Scoping
-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
-## Departments and Cops
-### Universal — 10 cops
+## Cop Departments
-- **ConstantSafety** (4): `BareDataDefine`, `BareProcess`, `BareJson` (all error, auto-fix) — prefix with `::` inside `module Legion`. `InheritParam` (convention, auto-fix) — pass `false` to `const_defined?`/`const_get`.
-- **RescueLogging** (3): `BareRescue` (warning, auto-fix) — capture with `=> e`. `NoCapture` (convention, no auto-fix) — exception class without capture. `SilentCapture` (warning, no auto-fix) — captured but never logged/re-raised. Skips `_`-prefixed vars. All skip inline rescue modifiers.
-- **Singleton** (1): `UseInstance` (error, auto-fix) — `.instance` not `.new` for configurable singleton classes.
-- **Framework/MutexNestedSync** (1): Nested `synchronize` blocks risk deadlock.
-- **Framework/ModuleFunctionPrivate** (1): `private` after `module_function` resets visibility.
+| Department | Count | Scope |
+|------------|-------|-------|
+| ConstantSafety | 4 | Universal |
+| RescueLogging | 3 | Universal |
+| Singleton | 1 | Universal |
+| Framework | 8 | Universal + Library-specific |
+| HelperMigration | 13 | LEX-only |
+| Extension | 18 | LEX-only |
-### Library-Specific — 6 cops
-- `EagerSequelModel` — `Sequel::Model(:table)` at require time
-- `SinatraHostAuth` — Sinatra 4.0+ `set :host_authorization`
-- `ThorReservedRun` — Thor 1.5+ reserves `run`
-- `FaradayXmlMiddleware` — Faraday 2.0+ removed `:xml`
-- `CacheTimeCoercion` — Time→String after cache round-trip
-- `ApiStringKeys` — `Legion::JSON.load` returns symbol keys (scoped to `lib/legion/extensions/**/*.rb`)
-### 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)`.
-- **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`.
+Cops are scoped by gem type — no per-repo configuration needed. LEX-only cops fire on `lib/legion/extensions/**/*.rb` via Include directive.
 ## Architecture
 ```
 rubocop-legion/
 ├── lib/
-│   ├── rubocop-legion.rb              # Entry point, requires all cops
+│   ├── rubocop-legion.rb              # Entry point
 │   └── rubocop/
-│       ├── legion.rb                  # Namespace declarations
 │       ├── 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)
-│           ├── framework/             # 7 cops (universal + library-specific)
-│           └── extension/             # 17 cops (lex-only)
+│           ├── framework/             # 8 cops (universal + library-specific)
+│           └── extension/             # 18 cops (lex-only)
 ├── config/
 │   └── default.yml                    # All cop defaults, Include/Exclude scoping
 └── spec/                              # mirrors lib/ structure
 ```
-## Key Implementation Details
-- Plugin entry point: `RuboCop::Legion::Plugin` (LintRoller-based, registered via gemspec metadata `default_lint_roller_plugin`)
-- All cops inherit from `RuboCop::Cop::Base`
-- Auto-correctable cops use `extend AutoCorrector`
-- AST matching via `def_node_matcher` and `def_node_search`
-- Specs use `RuboCop::RSpec::Support` with `:config` shared context and `expect_offense`/`expect_correction`
-- `BareRescue` and `NoCapture` skip rescue modifiers (inline `rescue`) to avoid syntax corruption
-- `NoCapture` has no auto-correct to prevent correction loop with `Lint/UselessAssignment`
-- `SilentCapture` skips `_`-prefixed variables (Ruby unused convention)
 ## Development
 ```bash
 bundle install
-bundle exec rspec      # 322 specs
+bundle exec rspec      # 350 specs
 bundle exec rubocop    # Self-linting
 ```
-## Common Per-Repo Overrides
-```yaml
-# Repos using Faraday JSON middleware (string keys, not Legion::JSON symbol keys)
-Legion/Framework/ApiStringKeys:
-  Enabled: false
-```
----
-**Maintained By**: Matthew Iverson (@Esity)

data/README.md CHANGED Viewed

@@ -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 CHANGED Viewed

@@ -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.'
@@ -319,3 +336,30 @@ Legion/Extension/DefinitionCallMismatched:
   Enabled: true
   Severity: error
   VersionAdded: '0.1.4'
+# Legion/Framework — N×N routing guard cops (Phase 6 enforcement)
+Legion/Framework/NoUnderscorePrefixedKwargs:
+  Description: 'Ban underscore-prefixed kwargs and `**_rest` splats. Use plain kwarg, defaulted kwarg, or `**opts`.'
+  Enabled: true
+  Severity: warning
+  VersionAdded: '0.1.8'
+Legion/Framework/NoInlineSettingDefaults:
+  Description: 'Flag `Legion::Settings[...] || <literal>` and shadow-default patterns. Defaults belong in `settings.rb`.'
+  Enabled: true
+  Severity: warning
+  VersionAdded: '0.1.8'
+Legion/Framework/NoDirectDispatch:
+  Description: 'Ban `_direct` methods on `Legion::LLM` modules. All inference routes through the governed pipeline.'
+  Enabled: true
+  Severity: error
+  VersionAdded: '0.1.8'
+Legion/Framework/NoShapeDuckTyping:
+  Description: 'Flag `respond_to?` on canonical shape methods and string-key fallback access. Disabled by default.'
+  Enabled: false
+  Severity: convention
+  VersionAdded: '0.1.8'
+  Safe: false

data/lib/rubocop/cop/legion/extension/every_actor_requires_time.rb CHANGED Viewed

@@ -59,7 +59,11 @@ module RuboCop
             node.body.each_node(:send).any? do |send_node|
               send_node.method_name == :time && send_node.receiver.nil?
-            end
+            end || defines_time_method?(node)
+          end
+          def defines_time_method?(node)
+            node.body.each_node(:def).any? { |def_node| def_node.method_name == :time }
           end
         end
       end

data/lib/rubocop/cop/legion/framework/no_direct_dispatch.rb ADDED Viewed

@@ -0,0 +1,109 @@
+# frozen_string_literal: true
+module RuboCop
+  module Cop
+    module Legion
+      module Framework
+        # Bans defining methods matching `/_direct\z/` on `Legion::LLM` modules.
+        # Per G16, all pipeline bypasses (`chat_direct`, `embed_direct`,
+        # `structured_direct`) are removed — internal callers route through the
+        # governed pipeline with an appropriate profile.
+        #
+        # No auto-correct is provided because the fix requires routing through
+        # the inference pipeline.
+        #
+        # @example
+        #   # bad
+        #   module Legion::LLM
+        #     def chat_direct(message:)
+        #       # bypasses metering, audit, ledger
+        #     end
+        #   end
+        #
+        #   # bad
+        #   module Legion::LLM
+        #     def self.embed_direct(text:)
+        #     end
+        #   end
+        #
+        #   # good
+        #   module Legion::LLM
+        #     def chat(message:)
+        #       # routes through pipeline
+        #     end
+        #   end
+        class NoDirectDispatch < Base
+          MSG = 'Method `%<name>s` matches `/_direct\\z/` on a `Legion::LLM` module. ' \
+                'Pipeline bypasses are not allowed — route through the governed pipeline.'
+          DIRECT_PATTERN = /_direct\z/
+          def on_def(node)
+            return unless node.method_name.to_s.match?(DIRECT_PATTERN)
+            return unless inside_legion_llm?(node)
+            add_offense(node.loc.name, message: format(MSG, name: node.method_name))
+          end
+          def on_defs(node)
+            return unless node.method_name.to_s.match?(DIRECT_PATTERN)
+            return unless inside_legion_llm?(node)
+            add_offense(node.loc.name, message: format(MSG, name: node.method_name))
+          end
+          private
+          def inside_legion_llm?(node)
+            node.each_ancestor(:module, :class).any? do |ancestor|
+              legion_llm_module?(ancestor)
+            end
+          end
+          def legion_llm_module?(mod_node)
+            return false unless mod_node.module_type?
+            # Check compact form: Legion::LLM or Legion::LLM::Something
+            ident = mod_node.identifier
+            return true if compact_legion_llm?(ident)
+            # Check nested form: module Legion; module LLM; ...
+            # The identifier is just `LLM` but parent is `module Legion`
+            return true if nested_legion_llm?(mod_node)
+            false
+          end
+          def compact_legion_llm?(ident)
+            parts = const_parts(ident)
+            parts.length >= 2 && parts[0] == :Legion && parts[1] == :LLM
+          end
+          def nested_legion_llm?(mod_node)
+            return false unless mod_node.identifier.const_type?
+            return false unless mod_node.identifier.children.last == :LLM
+            # Check if parent module is `Legion`
+            parent = mod_node.parent
+            return false unless parent&.module_type?
+            return false unless parent&.identifier&.const_type?
+            parent.identifier.children.last == :Legion
+          end
+          def const_parts(node)
+            return [] unless node&.const_type?
+            child = node.children.first
+            name = node.children.last
+            if child&.const_type?
+              const_parts(child) + [name]
+            else
+              [name]
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/legion/framework/no_inline_setting_defaults.rb ADDED Viewed

@@ -0,0 +1,110 @@
+# frozen_string_literal: true
+module RuboCop
+  module Cop
+    module Legion
+      module Framework
+        # Detects `Legion::Settings[...]` reads combined with inline literal
+        # fallbacks (`|| <literal>`) or shadow-default patterns
+        # (`x = N unless x.positive?`). Per G13, all defaults belong in
+        # `settings.rb` — inline fallbacks are dead code after
+        # `register_defaults!` merge.
+        #
+        # No auto-correct is provided because the fix requires moving the
+        # literal into the appropriate `*_defaults` group in settings.rb.
+        #
+        # @example
+        #   # bad
+        #   max_retries = Legion::Settings[:llm][:max_retries] || 3
+        #   timeout = Legion::Settings[:timeout] || 30
+        #
+        #   # bad (shadow default)
+        #   max_retries = Legion::Settings[:llm][:max_retries]
+        #   max_retries = 200 unless max_retries.positive?
+        #
+        #   # good
+        #   max_retries = Legion::Settings[:llm][:max_retries]
+        class NoInlineSettingDefaults < Base
+          MSG_OR = 'Inline default `%<default>s` after `Legion::Settings` read. ' \
+                   'Move the default into `settings.rb` instead.'
+          MSG_SHADOW = 'Shadow-default pattern after `Legion::Settings` read. ' \
+                       'Move the default into `settings.rb` instead.'
+          def on_or(node)
+            left = node.children.first
+            right = node.children.last
+            return unless settings_read?(left)
+            return unless right && literal?(right)
+            add_offense(node, message: format(MSG_OR, default: right.source))
+          end
+          def on_if(node)
+            cond = node.condition
+            return unless cond&.send_type?
+            receiver = cond.receiver
+            return unless receiver&.lvar_type?
+            method_name = cond.method_name
+            return unless %i[positive? nil? zero? empty? blank?].include?(method_name)
+            var_name = receiver.children.first
+            return unless preceded_by_settings_read?(node, var_name)
+            add_offense(node, message: MSG_SHADOW)
+          end
+          private
+          def settings_read?(node)
+            return false unless node&.send_type?
+            return true if direct_settings_access?(node)
+            return true if nested_settings_access?(node)
+            false
+          end
+          def direct_settings_access?(node)
+            node.method_name == :[] &&
+              node.receiver&.const_type? &&
+              node.receiver.children.last == :Settings &&
+              legion_const?(node.receiver.children.first)
+          end
+          def nested_settings_access?(node)
+            node.method_name == :[] &&
+              node.receiver&.send_type? &&
+              node.receiver.method_name == :[] &&
+              direct_settings_access?(node.receiver)
+          end
+          def legion_const?(node)
+            return true if node.nil?
+            return false unless node.const_type?
+            node.children.last == :Legion
+          end
+          def literal?(node)
+            %i[str int float sym].include?(node.type)
+          end
+          def preceded_by_settings_read?(if_node, var_name)
+            parent = if_node.parent
+            return false unless parent&.begin_type?
+            idx = parent.children.index(if_node)
+            return false unless idx&.positive?
+            prev = parent.children[idx - 1]
+            return false unless prev&.lvasgn_type?
+            return false unless prev.children.first == var_name
+            settings_read?(prev.children.last)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/legion/framework/no_shape_duck_typing.rb ADDED Viewed

@@ -0,0 +1,100 @@
+# frozen_string_literal: true
+module RuboCop
+  module Cop
+    module Legion
+      module Framework
+        # Flags `respond_to?` checks for canonical response shape methods
+        # (`thinking`, `tool_calls`, `content`, `stop_reason`) and string-key
+        # fallback access (`x[:k] || x['k']`). Per R10, downstream consumers
+        # of canonical types should rely on the struct interface, not duck-type.
+        #
+        # Ships **disabled by default**. Enable per-repo or per-directory once
+        # the canonical migration is complete.
+        #
+        # @example
+        #   # bad
+        #   response.respond_to?(:thinking)
+        #   response.respond_to?(:tool_calls)
+        #   tc[:name] || tc['name']
+        #
+        #   # good
+        #   response.thinking
+        #   response.tool_calls
+        #   tc[:name]
+        class NoShapeDuckTyping < Base
+          MSG_RESPOND = 'Use canonical struct access instead of `respond_to?(:%<method>s)`. ' \
+                        'Downstream of translators, the shape is guaranteed.'
+          MSG_FALLBACK = 'String-key fallback `%<key>s` suggests duck-typed access. ' \
+                         'Use canonical struct access or symbol keys consistently.'
+          CANONICAL_METHODS = %w[thinking tool_calls content stop_reason].freeze
+          def on_send(node)
+            check_respond_to(node)
+          end
+          def on_or(node)
+            check_string_key_fallback(node)
+          end
+          private
+          def check_respond_to(node)
+            return unless node.method_name == :respond_to?
+            return unless node.arguments.length == 1
+            arg = node.arguments.first
+            method_name = case arg.type
+                          when :sym then arg.value.to_s
+                          when :str then arg.value
+                          else return
+                          end
+            return unless CANONICAL_METHODS.include?(method_name)
+            add_offense(node, message: format(MSG_RESPOND, method: method_name))
+          end
+          def check_string_key_fallback(node)
+            left = node.children.first
+            right = node.children.last
+            return unless left&.send_type? && right&.send_type?
+            return unless left.method_name == :[] && right.method_name == :[]
+            # Both must access the same receiver
+            left_recv = left.receiver
+            right_recv = right.receiver
+            return unless left_recv && right_recv
+            return unless same_receiver?(left_recv, right_recv)
+            # One must be sym, the other str
+            left_key = left.arguments.first
+            right_key = right.arguments.first
+            return unless left_key && right_key
+            has_sym = left_key.sym_type? || right_key.sym_type?
+            has_str = left_key.str_type? || right_key.str_type?
+            return unless has_sym && has_str
+            # Extract the key name from the symbol side
+            key_node = left_key.sym_type? ? left_key : right_key
+            return unless key_node
+            add_offense(node, message: format(MSG_FALLBACK, key: key_node.value))
+          end
+          def same_receiver?(left, right)
+            # Both lvars with same name
+            return true if left.lvar_type? && right.lvar_type? && left.children.first == right.children.first
+            # Both sends with same method name and no receiver (bare identifier)
+            left.send_type? && right.send_type? &&
+              left.receiver.nil? && right.receiver.nil? &&
+              left.method_name == right.method_name
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/legion/framework/no_underscore_prefixed_kwargs.rb ADDED Viewed

@@ -0,0 +1,89 @@
+# frozen_string_literal: true
+module RuboCop
+  module Cop
+    module Legion
+      module Framework
+        # Bans underscore-prefixed keyword arguments and `**_rest`/`**_` splat
+        # parameters in method definitions. The N×N routing design requires
+        # explicit kwarg signatures: required → plain kwarg, optional → defaulted
+        # kwarg, passthrough → `**opts` at the end.
+        #
+        # @example
+        #   # bad
+        #   def foo(_bar:); end
+        #   def foo(**_rest); end
+        #   def foo(**_); end
+        #
+        #   # good
+        #   def foo(bar:); end
+        #   def foo(bar: nil); end
+        #   def foo(**opts); end
+        class NoUnderscorePrefixedKwargs < Base
+          extend AutoCorrector
+          MSG_KWARG = 'Underscore-prefixed kwarg `%<name>s` is not allowed. ' \
+                      'Use plain kwarg (required), defaulted kwarg (optional), ' \
+                      'or `**opts` for passthrough.'
+          MSG_SPLAT = 'Underscore-prefixed kwarg splat `%<name>s` is not allowed. ' \
+                      'Use `**opts` for passthrough.'
+          def on_def(node)
+            check_params(node)
+          end
+          def on_defs(node)
+            check_params(node)
+          end
+          private
+          def check_params(method_node)
+            args = method_node.arguments
+            return unless args
+            args.each_child_node do |arg|
+              case arg.type
+              when :kwarg, :kwoptarg
+                check_kwarg(arg)
+              when :kwrestarg
+                check_kwrestarg(arg)
+              end
+            end
+          end
+          def check_kwarg(arg)
+            name = arg.children.first
+            return unless name.is_a?(Symbol)
+            return unless name.to_s.start_with?('_')
+            add_offense(arg, message: format(MSG_KWARG, name: name)) do |corrector|
+              corrected = name.to_s.sub(/\A_+/, '')
+              corrected = 'arg' if corrected.empty?
+              corrector.replace(arg.source_range, kwarg_replacement(corrected, arg))
+            end
+          end
+          def check_kwrestarg(arg)
+            name = arg.children.first
+            return unless name.is_a?(Symbol)
+            return unless name.to_s.start_with?('_')
+            add_offense(arg, message: format(MSG_SPLAT, name: name)) do |corrector|
+              corrector.replace(arg.source_range, '**opts')
+            end
+          end
+          def kwarg_replacement(name, arg)
+            if arg.kwoptarg_type?
+              default = arg.children.last
+              "#{name}: #{default.source}"
+            else
+              "#{name}:"
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -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 CHANGED Viewed

@@ -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 CHANGED Viewed

@@ -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 ADDED Viewed

@@ -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 ADDED Viewed

@@ -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 CHANGED Viewed

@@ -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 ADDED Viewed

@@ -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 CHANGED Viewed

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

data/lib/rubocop-legion.rb CHANGED Viewed

@@ -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'
@@ -42,6 +44,10 @@ require 'rubocop/cop/legion/framework/module_function_private'
 require 'rubocop/cop/legion/framework/cache_time_coercion'
 require 'rubocop/cop/legion/framework/api_string_keys'
 require 'rubocop/cop/legion/framework/mutex_nested_sync'
+require 'rubocop/cop/legion/framework/no_underscore_prefixed_kwargs'
+require 'rubocop/cop/legion/framework/no_inline_setting_defaults'
+require 'rubocop/cop/legion/framework/no_direct_dispatch'
+require 'rubocop/cop/legion/framework/no_shape_duck_typing'
 # Legion/Extension
 require 'rubocop/cop/legion/extension/actor_singular_module'

metadata CHANGED Viewed

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: rubocop-legion
 version: !ruby/object:Gem::Version
-  version: 0.1.6
+  version: 0.1.8
 platform: ruby
 authors:
 - Esity
@@ -144,6 +144,10 @@ files:
 - lib/rubocop/cop/legion/framework/faraday_xml_middleware.rb
 - lib/rubocop/cop/legion/framework/module_function_private.rb
 - lib/rubocop/cop/legion/framework/mutex_nested_sync.rb
+- lib/rubocop/cop/legion/framework/no_direct_dispatch.rb
+- lib/rubocop/cop/legion/framework/no_inline_setting_defaults.rb
+- lib/rubocop/cop/legion/framework/no_shape_duck_typing.rb
+- lib/rubocop/cop/legion/framework/no_underscore_prefixed_kwargs.rb
 - lib/rubocop/cop/legion/framework/sinatra_host_auth.rb
 - lib/rubocop/cop/legion/framework/thor_reserved_run.rb
 - lib/rubocop/cop/legion/helper_migration/defined_transport_guard.rb
@@ -151,9 +155,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
@@ -189,7 +195,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 4.0.8
+rubygems_version: 3.6.9
 specification_version: 4
 summary: LegionIO code quality cops for RuboCop
 test_files: []

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

@@ -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