textus 0.15.0 → 0.20.0

data/lib/textus/cli/verb/get.rb

@@ -2,12 +2,14 @@ module Textus
   class CLI
     class Verb
       class Get < Verb
+        command_name "get"
+
         option :as_flag, "--as=ROLE"
 
         def call(store)
           key = positional.shift or raise UsageError.new("get requires a key")
-          result = operations_for(store).reads.get_or_refresh.call(key)
-          raise Textus::UnknownKey.new(key, suggestions: store.manifest.suggestions_for(key)) if result.nil?
+          result = operations_for(store).get_or_refresh(key)
+          raise Textus::UnknownKey.new(key, suggestions: store.manifest.resolver.suggestions_for(key)) if result.nil?
 
           emit(result.to_h_for_wire)
         end

data/lib/textus/cli/verb/hook_run.rb

@@ -2,6 +2,9 @@ module Textus
   class CLI
     class Verb
       class HookRun < Verb
+        command_name "run"
+        parent_group Group::Hook
+
         def parse(argv)
           @raw_argv = argv
         end
@@ -23,13 +26,12 @@ module Textus
             end
           end
 
-          role = Role.resolve(flag: as_flag, env: ENV, root: store.root)
-          callable = store.registry.rpc_callable(:resolve_intake, name)
-          view = Application::Context.new(store: store, role: role)
+          Role.resolve(flag: as_flag, env: ENV, root: store.root)
+          callable = store.bus.rpc_callable(:resolve_intake, name)
 
           begin
             Timeout.timeout(Textus::Application::Refresh::Worker::FETCH_TIMEOUT_SECONDS) do
-              callable.call(config: {}, store: view, args: args)
+              callable.call(config: {}, store: store, args: args)
             end
           rescue Timeout::Error
             raise UsageError.new(

data/lib/textus/cli/verb/hooks.rb

@@ -2,9 +2,12 @@ module Textus
   class CLI
     class Verb
       class Hooks < Verb
+        command_name "list"
+        parent_group Group::Hook
+
         option :event_filter, "--event=E"
 
-        def call(store) # rubocop:disable Metrics/AbcSize, Metrics/CyclomaticComplexity
+        def call(store) # rubocop:disable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
           subcommand = positional.first
           if subcommand
             raise UsageError.new("hook requires 'list'") unless subcommand == "list"
@@ -13,15 +16,15 @@ module Textus
           end
 
           rows = []
-          Textus::Hooks::Registry::EVENTS.each do |event, spec|
+          Textus::Hooks::Bus::EVENTS.each do |event, spec|
             mode = spec[:mode].to_s
             case spec[:mode]
             when :rpc
-              store.registry.rpc_names(event).each do |name|
+              store.bus.rpc_names(event).each do |name|
                 rows << { "event" => event.to_s, "mode" => mode, "name" => name.to_s }
               end
             when :pubsub
-              store.registry.pubsub_handlers(event).each do |h|
+              store.bus.pubsub_handlers(event).each do |h|
                 row = { "event" => event.to_s, "mode" => mode, "name" => h[:name].to_s }
                 row["keys"] = Array(h[:keys]) if h[:keys]
                 rows << row
@@ -29,7 +32,7 @@ module Textus
             end
           end
           store.manifest.entries.each do |e|
-            e.events.each do |evt, defs|
+            (e.respond_to?(:events) ? e.events : {}).each do |evt, defs|
               Array(defs).each do |defn|
                 next unless defn["exec"]
 

data/lib/textus/cli/verb/init.rb

@@ -2,6 +2,8 @@ module Textus
   class CLI
     class Verb
       class Init < Verb
+        command_name "init"
+
         def self.needs_store? = false
 
         def call(_store)

data/lib/textus/cli/verb/intro.rb

@@ -2,6 +2,8 @@ module Textus
   class CLI
     class Verb
       class Intro < Verb
+        command_name "intro"
+
         def call(store)
           emit(Textus::Intro.run(store))
         end

data/lib/textus/cli/verb/key_normalize.rb

@@ -2,13 +2,45 @@ module Textus
   class CLI
     class Verb
       class KeyNormalize < Verb
+        command_name "normalize"
+        parent_group Group::Key
+
         option :write, "--write"
         option :dry_run, "--dry-run"
+        option :upgrade_manifest, "--upgrade-manifest"
 
         def call(store)
-          effective_write = write && !dry_run
-          res = Textus::MigrateKeys.run(store, write: effective_write || false)
-          emit(res, exit_code: res["ok"] ? 0 : 1)
+          if upgrade_manifest
+            run_upgrade_manifest(store)
+          else
+            effective_write = write && !dry_run
+            res = Textus::Application::Tools::MigrateKeys.run(store, write: effective_write || false)
+            emit(res, exit_code: res["ok"] ? 0 : 1)
+          end
+        end
+
+        private
+
+        def run_upgrade_manifest(store)
+          manifest_path = File.join(store.root, "manifest.yaml")
+          orig = File.read(manifest_path)
+          new_yaml = Textus::Application::Tools::MigrateManifestToKinds.upgrade_yaml(orig)
+
+          if dry_run
+            diff_lines = unified_diff(orig, new_yaml, manifest_path)
+            emit({ "protocol" => PROTOCOL, "dry_run" => true, "diff" => diff_lines, "ok" => true }, exit_code: 0)
+          else
+            File.write(manifest_path, new_yaml)
+            puts "upgraded manifest at #{manifest_path}"
+            emit({ "protocol" => PROTOCOL, "upgraded" => manifest_path, "ok" => true }, exit_code: 0)
+          end
+        end
+
+        def unified_diff(before, after, _path)
+          before.lines.zip(after.lines).each_with_object([]) do |(a, b), acc|
+            acc << "- #{a.chomp}" if a && a != b
+            acc << "+ #{b.chomp}" if b && a != b
+          end
         end
       end
     end

data/lib/textus/cli/verb/list.rb

@@ -2,11 +2,13 @@ module Textus
   class CLI
     class Verb
       class List < Verb
+        command_name "list"
+
         option :prefix, "--prefix=KEY"
         option :zone, "--zone=Z"
 
         def call(store)
-          emit({ "entries" => operations_for(store).reads.list.call(prefix: prefix, zone: zone) })
+          emit({ "entries" => operations_for(store).list(prefix: prefix, zone: zone) })
         end
       end
     end

data/lib/textus/cli/verb/mv.rb

@@ -2,13 +2,16 @@ module Textus
   class CLI
     class Verb
       class Mv < Verb
+        command_name "mv"
+        parent_group Group::Key
+
         option :as_flag, "--as=ROLE"
         option :dry_run, "--dry-run"
 
         def call(store)
           old_key = positional.shift or raise UsageError.new("mv requires <old-key> <new-key>")
           new_key = positional.shift or raise UsageError.new("mv requires <old-key> <new-key>")
-          emit(operations_for(store).writes.mv.call(old_key, new_key, dry_run: dry_run || false))
+          emit(operations_for(store).mv(old_key, new_key, dry_run: dry_run || false))
         end
       end
     end

data/lib/textus/cli/verb/published.rb

@@ -2,8 +2,10 @@ module Textus
   class CLI
     class Verb
       class Published < Verb
+        command_name "published"
+
         def call(store)
-          emit({ "published" => operations_for(store).reads.published.call })
+          emit({ "published" => operations_for(store).published })
         end
       end
     end

data/lib/textus/cli/verb/put.rb

@@ -2,6 +2,8 @@ module Textus
   class CLI
     class Verb
       class Put < Verb
+        command_name "put"
+
         option :as_flag, "--as=ROLE"
         option :use_stdin, "--stdin"
         option :fetch_name, "--fetch=NAME"
@@ -15,12 +17,11 @@ module Textus
           raw = @stdin.read
           payload =
             if fetch_name
-              callable = store.registry.rpc_callable(:resolve_intake, fetch_name)
+              callable = store.bus.rpc_callable(:resolve_intake, fetch_name)
               result =
                 begin
                   Timeout.timeout(Textus::Application::Refresh::Worker::FETCH_TIMEOUT_SECONDS) do
-                    callable.call(config: { "bytes" => raw },
-                                  store: Textus::Application::Context.new(store: store, role: role), args: {})
+                    callable.call(config: { "bytes" => raw }, store: store, args: {})
                   end
                 rescue Timeout::Error
                   raise UsageError.new(
@@ -43,7 +44,7 @@ module Textus
           meta = payload["_meta"] || {}
           body = payload["body"] || ""
           if_etag = payload["if_etag"]
-          result = Textus::Operations.for(store, role: role).writes.put.call(key, meta: meta, body: body, if_etag: if_etag)
+          result = Textus::Operations.for(store, role: role).put(key, meta: meta, body: body, if_etag: if_etag)
           emit(result.to_h_for_wire)
         end
       end

data/lib/textus/cli/verb/rdeps.rb

@@ -2,9 +2,11 @@ module Textus
   class CLI
     class Verb
       class Rdeps < Verb
+        command_name "rdeps"
+
         def call(store)
           key = positional.shift or raise UsageError.new("rdeps requires a key")
-          emit({ "key" => key, "rdeps" => operations_for(store).reads.rdeps.call(key) })
+          emit({ "key" => key, "rdeps" => operations_for(store).rdeps(key) })
         end
       end
     end

data/lib/textus/cli/verb/refresh.rb

@@ -6,7 +6,7 @@ module Textus
 
         def call(store)
           key = positional.shift or raise UsageError.new("refresh requires a key")
-          emit(operations_for(store).refresh.worker.run(key).to_h_for_wire)
+          emit(operations_for(store).refresh(key).to_h_for_wire)
         end
       end
     end

data/lib/textus/cli/verb/refresh_stale.rb

@@ -2,13 +2,15 @@ module Textus
   class CLI
     class Verb
       class RefreshStale < Verb
+        command_name "stale"
+        parent_group Group::Refresh
+
         option :prefix, "--prefix=KEY"
         option :zone, "--zone=Z"
         option :as_flag, "--as=ROLE"
 
         def call(store)
-          ctx = context_for(store)
-          result = Textus::Application::Refresh::All.call(ctx, prefix: prefix, zone: zone)
+          result = operations_for(store).refresh_all(prefix: prefix, zone: zone)
           emit(result)
           result["ok"] ? 0 : 1
         end

data/lib/textus/cli/verb/reject.rb

@@ -2,11 +2,13 @@ module Textus
   class CLI
     class Verb
       class Reject < Verb
+        command_name "reject"
+
         option :as_flag, "--as=ROLE"
 
         def call(store)
           key = positional.shift or raise UsageError.new("reject requires a key")
-          emit(operations_for(store).writes.reject.call(key))
+          emit(operations_for(store).reject(key))
         end
       end
     end

data/lib/textus/cli/verb/rule_explain.rb

@@ -2,9 +2,12 @@ module Textus
   class CLI
     class Verb
       class RuleExplain < Verb
+        command_name "explain"
+        parent_group Group::Rule
+
         def call(store)
           key = positional.shift or raise UsageError.new("policy explain requires a KEY")
-          result = operations_for(store).reads.policy_explain.call(key: key)
+          result = operations_for(store).policy_explain(key: key)
           emit({ "verb" => "policy_explain" }.merge(result.transform_keys(&:to_s)))
         end
       end

data/lib/textus/cli/verb/rule_list.rb

@@ -2,6 +2,9 @@ module Textus
   class CLI
     class Verb
       class RuleList < Verb
+        command_name "list"
+        parent_group Group::Rule
+
         def call(store)
           policies = store.manifest.rules.blocks.map do |b|
             row = { "match" => b.match }

data/lib/textus/cli/verb/schema.rb

@@ -2,9 +2,12 @@ module Textus
   class CLI
     class Verb
       class Schema < Verb
+        command_name "show"
+        parent_group Group::Schema
+
         def call(store)
           key = positional.shift or raise UsageError.new("schema requires a key")
-          emit(operations_for(store).reads.schema_envelope.call(key))
+          emit(operations_for(store).schema_envelope(key))
         end
       end
     end

data/lib/textus/cli/verb/schema_diff.rb

@@ -2,6 +2,9 @@ module Textus
   class CLI
     class Verb
       class SchemaDiff < Verb
+        command_name "diff"
+        parent_group Group::Schema
+
         def call(store)
           name = positional.shift or raise UsageError.new("schema diff NAME")
           emit(Textus::Schema::Tools.diff(store, name: name))

data/lib/textus/cli/verb/schema_init.rb

@@ -2,6 +2,9 @@ module Textus
   class CLI
     class Verb
       class SchemaInit < Verb
+        command_name "init"
+        parent_group Group::Schema
+
         option :from_key, "--from=KEY"
 
         def call(store)

data/lib/textus/cli/verb/schema_migrate.rb

@@ -2,6 +2,9 @@ module Textus
   class CLI
     class Verb
       class SchemaMigrate < Verb
+        command_name "migrate"
+        parent_group Group::Schema
+
         option :rename, "--rename=O:N"
 
         def call(store)

data/lib/textus/cli/verb/uid.rb

@@ -2,9 +2,12 @@ module Textus
   class CLI
     class Verb
       class Uid < Verb
+        command_name "uid"
+        parent_group Group::Key
+
         def call(store)
           key = positional.shift or raise UsageError.new("uid requires a key")
-          emit({ "key" => key, "uid" => operations_for(store).reads.uid.call(key) })
+          emit({ "key" => key, "uid" => operations_for(store).uid(key) })
         end
       end
     end

data/lib/textus/cli/verb/where.rb

@@ -2,9 +2,11 @@ module Textus
   class CLI
     class Verb
       class Where < Verb
+        command_name "where"
+
         def call(store)
           key = positional.shift or raise UsageError.new("where requires a key")
-          emit(operations_for(store).reads.where.call(key))
+          emit(operations_for(store).where(key))
         end
       end
     end

data/lib/textus/cli/verb.rb

@@ -22,9 +22,39 @@ module Textus
           true
         end
 
+        # Declarative CLI name. Reader returns the registered name (or nil
+        # for verbs that aren't directly invokable, like the abstract
+        # Verb/Group base classes). Writer registers it.
+        def command_name(name = nil)
+          if name.nil?
+            @command_name
+          else
+            @command_name = name.to_s
+          end
+        end
+
+        # Declares that this verb is a subcommand of `group_klass`. When
+        # set, the verb is NOT a top-level CLI verb — it's listed under
+        # the group's subcommands instead.
+        def parent_group(group_klass = nil)
+          if group_klass.nil?
+            @parent_group
+          else
+            @parent_group = group_klass
+          end
+        end
+
         def inherited(subclass)
           super
           subclass.instance_variable_set(:@options, [])
+          subclass.instance_variable_set(:@command_name, nil)
+          subclass.instance_variable_set(:@parent_group, nil)
+        end
+
+        # Recursive subclass enumeration. Ruby 3.1 ships Class#subclasses
+        # but not Class#descendants, so we expand it ourselves.
+        def descendants
+          subclasses.flat_map { |k| [k] + k.descendants }
         end
       end
 

data/lib/textus/cli.rb

@@ -3,32 +3,23 @@ require "optparse"
 
 module Textus
   class CLI
-    # verb name → Verb subclass. Adding a new verb is a one-line entry here
-    # plus a new file under lib/textus/cli/.
-    VERBS = {
-      "accept" => Verb::Accept,
-      "audit" => Verb::Audit,
-      "blame" => Verb::Blame,
-      "reject" => Verb::Reject,
-      "build" => Verb::Build,
-      "delete" => Verb::Delete,
-      "deps" => Verb::Deps,
-      "doctor" => Verb::Doctor,
-      "freshness" => Verb::Freshness,
-      "get" => Verb::Get,
-      "hook" => Group::Hook,
-      "init" => Verb::Init,
-      "intro" => Verb::Intro,
-      "key" => Group::Key,
-      "list" => Verb::List,
-      "published" => Verb::Published,
-      "put" => Verb::Put,
-      "rdeps" => Verb::Rdeps,
-      "refresh" => Group::Refresh,
-      "rule" => Group::Rule,
-      "schema" => Group::Schema,
-      "where" => Verb::Where,
-    }.freeze
+    # Auto-derived verb table. Every CLI::Verb (or Group) subclass that
+    # declares `command_name "X"` and has no `parent_group` is a top-level
+    # verb. Sorted alphabetically for stable help output. Adding a new
+    # verb requires only a new file declaring its `command_name`.
+    def self.verbs
+      Verb.descendants
+          .select { |k| k.command_name && k.parent_group.nil? }
+          .sort_by(&:command_name)
+          .to_h { |k| [k.command_name, k] }
+    end
+
+    # Backward-compat constant; callers should prefer `CLI.verbs`.
+    def self.const_missing(name)
+      return verbs.freeze if name == :VERBS
+
+      super
+    end
 
     def self.run(argv, stdin: $stdin, stdout: $stdout, stderr: $stderr, cwd: Dir.pwd)
       new(stdin: stdin, stdout: stdout, stderr: stderr, cwd: cwd).run(argv)
@@ -54,7 +45,7 @@ module Textus
         when "--help", "-h"    then print_help
                                     0
         else
-          klass = VERBS[verb] or raise UsageError.new("unknown verb: #{verb}")
+          klass = self.class.verbs[verb] or raise UsageError.new("unknown verb: #{verb}")
           dispatch(klass, argv)
         end
 

data/lib/textus/doctor/check/audit_log.rb

@@ -4,7 +4,7 @@ module Textus
       class AuditLog < Check
         def call
           path = File.join(store.root, "audit.log")
-          Textus::Store::AuditLog.new(store.root).verify_integrity.map do |v|
+          Textus::Infra::AuditLog.new(store.root).verify_integrity.map do |v|
             {
               "code" => "audit.parse_error",
               "level" => "warning",

data/lib/textus/doctor/check/handler_allowlist.rb

@@ -8,8 +8,9 @@ module Textus
         def call
           out = []
           store.manifest.entries.each do |mentry|
-            handler = mentry.intake_handler
-            next if handler.nil?
+            next unless mentry.is_a?(Textus::Manifest::Entry::Intake)
+
+            handler = mentry.handler
 
             allow = store.manifest.rules_for(mentry.key).handler_allowlist
             next if allow.nil?

data/lib/textus/doctor/check/hooks.rb

@@ -8,9 +8,11 @@ module Textus
           return out unless File.directory?(dir)
 
           Dir.glob(File.join(dir, "*.rb")).sort.each do |f| # rubocop:disable Lint/RedundantDirGlobSort
-            registry = Textus::Hooks::Registry.new
-            Textus.with_registry(registry) do
+            bus = Textus::Hooks::Bus.new
+            Textus.drain_hook_blocks
+            begin
               load(f)
+              Textus.drain_hook_blocks.each { |b| b.call(bus) }
             end
           rescue StandardError, ScriptError => e
             out << {

data/lib/textus/doctor/check/illegal_keys.rb

@@ -5,12 +5,13 @@ module Textus
         def call
           out = []
           store.manifest.entries.each do |entry|
-            next unless entry.nested
+            next unless entry.nested?
 
             base = File.join(store.root, "zones", entry.path)
             next unless File.directory?(base)
 
-            entry.index_filename ? check_index_paths(entry, base, out) : check_all_paths(base, out)
+            index_fn = entry.respond_to?(:index_filename) ? entry.index_filename : nil
+            index_fn ? check_index_paths(entry, index_fn, base, out) : check_all_paths(base, out)
           end
           out
         end
@@ -31,8 +32,8 @@ module Textus
         # segments leading to each index file participate in keys. Sibling
         # files and unrelated subtrees are not enumerated and must not be
         # flagged. Each illegal segment is reported once per path.
-        def check_index_paths(entry, base, out)
-          Dir.glob(File.join(base, "**", entry.index_filename)).each do |fp|
+        def check_index_paths(_entry, index_fn, base, out)
+          Dir.glob(File.join(base, "**", index_fn)).each do |fp|
             rel = fp.sub(%r{\A#{Regexp.escape(base)}/?}, "")
             File.dirname(rel).split("/").reject { |s| s.empty? || s == "." }.each do |seg|
               next if seg.match?(Key::Grammar::SEGMENT)
@@ -43,7 +44,7 @@ module Textus
         end
 
         def issue(abs_path, stem)
-          proposed = Textus::MigrateKeys.normalize(stem)
+          proposed = Textus::Application::Tools::MigrateKeys.normalize(stem)
           {
             "code" => "key.illegal",
             "level" => "error",

data/lib/textus/doctor/check/intake_registration.rb

@@ -6,15 +6,15 @@ module Textus
 
         def call
           declared = collect_declared_handlers
-          registered = store.registry.rpc_names(:resolve_intake).to_set
+          registered = store.bus.rpc_names(:resolve_intake).to_set
 
           out = (declared - registered).map do |name|
             {
               "code" => "intake.handler_missing",
               "level" => "error",
               "subject" => name.to_s,
-              "message" => "manifest references intake handler '#{name}' but no Textus.on(:resolve_intake, :#{name}) is registered",
-              "fix" => "create .textus/hooks/#{name}.rb with `Textus.on(:resolve_intake, :#{name}) { ... }`",
+              "message" => "manifest references intake handler '#{name}' but no resolve_intake hook for '#{name}' is registered",
+              "fix" => "create .textus/hooks/#{name}.rb with `Textus.hook { |reg| reg.on(:resolve_intake, :#{name}) { ... } }`",
             }
           end
 
@@ -23,7 +23,7 @@ module Textus
               "code" => "intake.handler_orphan",
               "level" => "warning",
               "subject" => name.to_s,
-              "message" => "Textus.on(:resolve_intake, :#{name}) is registered but no manifest entry references it",
+              "message" => "resolve_intake hook '#{name}' is registered but no manifest entry references it",
               "fix" => "remove the unused handler, or add an entry with `intake.handler: #{name}`",
             }
           end
@@ -36,7 +36,7 @@ module Textus
         def collect_declared_handlers
           set = Set.new
           store.manifest.entries.each do |mentry|
-            set << mentry.intake_handler.to_sym if mentry.intake_handler
+            set << mentry.handler.to_sym if mentry.is_a?(Textus::Manifest::Entry::Intake)
           end
           set
         end

data/lib/textus/doctor/check/manifest_files.rb

@@ -4,7 +4,7 @@ module Textus
       class ManifestFiles < Check
         def call
           store.manifest.entries.each_with_object([]) do |entry, out|
-            next if entry.nested
+            next if entry.nested?
 
             path = Textus::Key::Path.resolve(store.manifest, entry)
             next if File.exist?(path)

data/lib/textus/doctor/check/protocol_version.rb

@@ -19,7 +19,7 @@ module Textus
             "code" => "protocol_mismatch",
             "severity" => "error",
             "message" => "Store reports version=#{version.inspect}; this gem expects textus/3.",
-            "hint" => "Install textus 0.11.x to run the migrator, then upgrade to this version. See https://github.com/patrick204nqh/textus/blob/main/CHANGELOG.md#0110",
+            "hint" => "Upgrade the store's manifest version to textus/3 (see CHANGELOG for breaking changes).",
           }]
         end
 
@@ -38,7 +38,7 @@ module Textus
             "level" => "error",
             "subject" => path,
             "message" => "Store reports version=#{version.inspect}; this gem expects textus/3.",
-            "fix" => "Install textus 0.11.x to run the migrator, then upgrade to this version. See https://github.com/patrick204nqh/textus/blob/main/CHANGELOG.md#0110",
+            "fix" => "Upgrade the store's manifest version to textus/3 (see CHANGELOG for breaking changes).",
           }]
         end
       end

data/lib/textus/doctor/check/schema_violations.rb

@@ -3,7 +3,7 @@ module Textus
     class Check
       class SchemaViolations < Check
         def call
-          res = Textus::Operations.for(store).reads.validate_all.call
+          res = Textus::Operations.for(store).validate_all
           res["violations"].map do |v|
             fix = v["expected"] &&
                   "field '#{v["field"]}' should be written by '#{v["expected"]}' (last writer: #{v["last_writer"]})"