textus 0.22.0 → 0.29.0

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

@@ -16,22 +16,19 @@ module Textus
           end
 
           rows = []
-          Textus::Hooks::Bus::EVENTS.each do |event, spec|
-            mode = spec[:mode].to_s
-            case spec[:mode]
-            when :rpc
-              store.bus.rpc_names(event).each do |name|
-                rows << { "event" => event.to_s, "mode" => mode, "name" => name.to_s }
-              end
-            when :pubsub
-              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
-              end
+          Textus::Hooks::RpcRegistry::EVENTS.each_key do |event|
+            store.rpc.names(event).each do |name|
+              rows << { "event" => event.to_s, "mode" => "rpc", "name" => name.to_s }
+            end
+          end
+          Textus::Hooks::EventBus::EVENTS.each_key do |event|
+            store.events.pubsub_handlers(event).each do |h|
+              row = { "event" => event.to_s, "mode" => "pubsub", "name" => h[:name].to_s }
+              row["keys"] = Array(h[:keys]) if h[:keys]
+              rows << row
             end
           end
-          store.manifest.entries.each do |e|
+          store.manifest.data.entries.each do |e|
             (e.respond_to?(:events) ? e.events : {}).each do |evt, defs|
               Array(defs).each do |defn|
                 next unless defn["exec"]

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

@@ -0,0 +1,24 @@
+module Textus
+  class CLI
+    class Verb
+      class KeyDelete < Verb
+        command_name "delete"
+        parent_group Group::Key
+
+        option :as_flag, "--as=ROLE"
+        option :dry_run, "--dry-run"
+        option :prefix, "--prefix"
+
+        def call(store)
+          if prefix
+            p = positional.shift or raise UsageError.new("key delete --prefix requires <prefix>")
+            emit(session_for(store).key_delete_prefix(prefix: p, dry_run: dry_run || false).to_h)
+          else
+            key = positional.shift or raise UsageError.new("key delete requires <key>")
+            emit(session_for(store).delete(key))
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -8,7 +8,7 @@ module Textus
         option :zone, "--zone=Z"
 
         def call(store)
-          emit({ "entries" => operations_for(store).list(prefix: prefix, zone: zone) })
+          emit({ "entries" => session_for(store).list(prefix: prefix, zone: zone) })
         end
       end
     end

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

@@ -0,0 +1,17 @@
+module Textus
+  class CLI
+    class Verb
+      # Launches the MCP stdio server in the current process. Blocks on
+      # stdin; never returns until stdin closes.
+      class MCPServe < Verb
+        command_name "serve"
+        parent_group Group::MCP
+
+        def call(store)
+          Textus::MCP::Server.new(store: store, stdin: @stdin, stdout: @stdout).run
+          0
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,18 @@
+module Textus
+  class CLI
+    class Verb
+      class Migrate < Verb
+        command_name "migrate"
+
+        option :as_flag, "--as=ROLE"
+        option :dry_run, "--dry-run"
+
+        def call(store)
+          path = positional.shift or raise UsageError.new("migrate requires <plan.yaml>")
+          plan_yaml = File.read(path)
+          emit(session_for(store).migrate(plan_yaml: plan_yaml, dry_run: dry_run || false).to_h)
+        end
+      end
+    end
+  end
+end

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

@@ -7,11 +7,19 @@ module Textus
 
         option :as_flag, "--as=ROLE"
         option :dry_run, "--dry-run"
+        option :prefix, "--prefix"
 
         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).mv(old_key, new_key, dry_run: dry_run || false))
+          if prefix
+            from_p = positional.shift or raise UsageError.new("mv --prefix requires <from-prefix> <to-prefix>")
+            to_p   = positional.shift or raise UsageError.new("mv --prefix requires <from-prefix> <to-prefix>")
+            emit(session_for(store).key_mv_prefix(from_prefix: from_p, to_prefix: to_p,
+                                                  dry_run: dry_run || false).to_h)
+          else
+            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(session_for(store).mv(old_key, new_key, dry_run: dry_run || false))
+          end
         end
       end
     end

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

@@ -5,7 +5,7 @@ module Textus
         command_name "published"
 
         def call(store)
-          emit({ "published" => operations_for(store).published })
+          emit({ "published" => session_for(store).published })
         end
       end
     end

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

@@ -7,7 +7,7 @@ module Textus
         option :since, "--since=N"
 
         def call(store)
-          ops = operations_for(store)
+          ops = session_for(store)
           since_n = (since || "0").to_i
           emit(ops.pulse(since: since_n))
         end

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

@@ -8,7 +8,7 @@ module Textus
         option :use_stdin, "--stdin"
         option :fetch_name, "--fetch=NAME"
 
-        def call(store) # rubocop:disable Metrics/AbcSize
+        def call(store)
           key = positional.shift or raise UsageError.new("put requires a key")
           raise UsageError.new("put requires --stdin in v1") unless use_stdin
 
@@ -17,15 +17,17 @@ module Textus
           raw = @stdin.read
           payload =
             if 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: store, args: {})
+                  Timeout.timeout(Textus::Write::RefreshWorker::FETCH_TIMEOUT_SECONDS) do
+                    store.rpc.invoke(:resolve_intake, fetch_name,
+                                     caps: nil,
+                                     config: { "bytes" => raw },
+                                     args: {})
                   end
                 rescue Timeout::Error
                   raise UsageError.new(
-                    "fetch '#{fetch_name}' exceeded #{Textus::Application::Refresh::Worker::FETCH_TIMEOUT_SECONDS}s timeout",
+                    "fetch '#{fetch_name}' exceeded #{Textus::Write::RefreshWorker::FETCH_TIMEOUT_SECONDS}s timeout",
                   )
                 end
               basename = key.split(".").last
@@ -44,7 +46,7 @@ module Textus
           meta = payload["_meta"] || {}
           body = payload["body"] || ""
           if_etag = payload["if_etag"]
-          result = Textus::Operations.for(store, role: role).put(key, meta: meta, body: body, if_etag: if_etag)
+          result = store.as(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

@@ -6,7 +6,7 @@ module Textus
 
         def call(store)
           key = positional.shift or raise UsageError.new("rdeps requires a key")
-          emit({ "key" => key, "rdeps" => operations_for(store).rdeps(key) })
+          emit({ "key" => key, "rdeps" => session_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(key).to_h_for_wire)
+          emit(session_for(store).refresh(key).to_h_for_wire)
         end
       end
     end

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

@@ -10,7 +10,7 @@ module Textus
         option :as_flag, "--as=ROLE"
 
         def call(store)
-          result = operations_for(store).refresh_all(prefix: prefix, zone: zone)
+          result = session_for(store).refresh_all(prefix: prefix, zone: zone)
           emit(result)
           result["ok"] ? 0 : 1
         end

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

@@ -8,7 +8,7 @@ module Textus
 
         def call(store)
           key = positional.shift or raise UsageError.new("reject requires a key")
-          emit(operations_for(store).reject(key))
+          emit(session_for(store).reject(key))
         end
       end
     end

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

@@ -7,7 +7,7 @@ module Textus
 
         def call(store)
           key = positional.shift or raise UsageError.new("policy explain requires a KEY")
-          result = operations_for(store).policy_explain(key: key)
+          result = session_for(store).policy_explain(key: key)
           emit({ "verb" => "policy_explain" }.merge(result.transform_keys(&:to_s)))
         end
       end

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

@@ -0,0 +1,18 @@
+module Textus
+  class CLI
+    class Verb
+      class RuleLint < Verb
+        command_name "lint"
+        parent_group Group::Rule
+
+        option :against, "--against=FILE"
+
+        def call(store)
+          path = against or raise UsageError.new("rule lint --against=FILE required")
+          yaml = File.read(path)
+          emit(session_for(store).rule_lint(candidate_yaml: yaml).to_h)
+        end
+      end
+    end
+  end
+end

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

@@ -7,7 +7,7 @@ module Textus
 
         def call(store)
           key = positional.shift or raise UsageError.new("schema requires a key")
-          emit(operations_for(store).schema_envelope(key))
+          emit(session_for(store).schema_envelope(key))
         end
       end
     end

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

@@ -7,7 +7,7 @@ module Textus
 
         def call(store)
           key = positional.shift or raise UsageError.new("uid requires a key")
-          emit({ "key" => key, "uid" => operations_for(store).uid(key) })
+          emit({ "key" => key, "uid" => session_for(store).uid(key) })
         end
       end
     end

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

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

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

@@ -0,0 +1,19 @@
+module Textus
+  class CLI
+    class Verb
+      class ZoneMv < Verb
+        command_name "mv"
+        parent_group Group::Zone
+
+        option :as_flag, "--as=ROLE"
+        option :dry_run, "--dry-run"
+
+        def call(store)
+          from = positional.shift or raise UsageError.new("zone mv requires <from> <to>")
+          to   = positional.shift or raise UsageError.new("zone mv requires <from> <to>")
+          emit(session_for(store).zone_mv(from: from, to: to, dry_run: dry_run || false).to_h)
+        end
+      end
+    end
+  end
+end

data/lib/textus/cli/verb.rb

@@ -96,16 +96,16 @@ module Textus
         Role.resolve(flag: flag, env: ENV, root: store.root)
       end
 
-      # Returns an Application::Context bound to the resolved role.
-      # Convenience for verbs whose only pre-call boilerplate is
-      # resolving the role and wrapping it in a context.
+      # Returns a Call value bound to the resolved role. Convenience for
+      # verbs whose only pre-call boilerplate is resolving the role and
+      # wrapping it in a Call.
       def context_for(store)
-        Textus::Operations.for(store, role: resolved_role(store)).ctx
+        Textus::Call.build(role: resolved_role(store))
       end
 
-      # Returns an Operations instance bound to the resolved role.
-      def operations_for(store)
-        Textus::Operations.for(store, role: resolved_role(store))
+      # Returns a RoleScope bound to the resolved role.
+      def session_for(store)
+        store.as(resolved_role(store))
       end
     end
   end

data/lib/textus/cli.rb

@@ -14,13 +14,6 @@ module Textus
           .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)
     end

data/lib/textus/container.rb

@@ -0,0 +1,23 @@
+module Textus
+  # Single capability record handed to every use case. Replaces the
+  # ReadCaps/WriteCaps/HookCaps trio from 0.26.x. Built once per Store.
+  Container = Data.define(
+    :manifest, :file_store, :schemas, :root,
+    :audit_log, :events, :rpc, :authorizer
+  )
+
+  class Container
+    def self.from_store(store)
+      new(
+        manifest: store.manifest,
+        file_store: store.file_store,
+        schemas: store.schemas,
+        root: store.root,
+        audit_log: store.audit_log,
+        events: store.events,
+        rpc: store.rpc,
+        authorizer: Textus::Domain::Authorizer.new(manifest: store.manifest),
+      )
+    end
+  end
+end

data/lib/textus/dispatcher.rb

@@ -0,0 +1,49 @@
+module Textus
+  # Static verb → use-case map. Canonical lookup as of 0.27.0; replaces the
+  # Application::UseCase registry whose entries were populated by file-load
+  # side effects in 0.26.x.
+  module Dispatcher
+    VERBS = {
+      # Write
+      put: Textus::Write::Put,
+      delete: Textus::Write::Delete,
+      mv: Textus::Write::Mv,
+      accept: Textus::Write::Accept,
+      reject: Textus::Write::Reject,
+      publish: Textus::Write::Publish,
+      refresh: Textus::Write::RefreshWorker,
+      refresh_all: Textus::Write::RefreshAll,
+
+      # Read
+      get: Textus::Read::Get,
+      get_or_refresh: Textus::Read::GetOrRefresh,
+      list: Textus::Read::List,
+      where: Textus::Read::Where,
+      uid: Textus::Read::Uid,
+      blame: Textus::Read::Blame,
+      audit: Textus::Read::Audit,
+      freshness: Textus::Read::Freshness,
+      stale: Textus::Read::Stale,
+      deps: Textus::Read::Deps,
+      rdeps: Textus::Read::Rdeps,
+      pulse: Textus::Read::Pulse,
+      policy_explain: Textus::Read::PolicyExplain,
+      published: Textus::Read::Published,
+      schema_envelope: Textus::Read::SchemaEnvelope,
+      validate_all: Textus::Read::ValidateAll,
+      doctor: Textus::Read::Doctor,
+      boot: Textus::Read::Boot,
+
+      # Maintenance
+      migrate: Textus::Maintenance::Migrate,
+      zone_mv: Textus::Maintenance::ZoneMv,
+      key_mv_prefix: Textus::Maintenance::KeyMvPrefix,
+      key_delete_prefix: Textus::Maintenance::KeyDeletePrefix,
+      rule_lint: Textus::Maintenance::RuleLint,
+    }.freeze
+
+    def self.fetch(verb)
+      VERBS.fetch(verb.to_sym) { raise UsageError.new("unknown verb: #{verb.inspect}") }
+    end
+  end
+end

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

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

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

@@ -7,12 +7,12 @@ module Textus
       class HandlerAllowlist < Check
         def call
           out = []
-          store.manifest.entries.each do |mentry|
+          manifest.data.entries.each do |mentry|
             next unless mentry.is_a?(Textus::Manifest::Entry::Intake)
 
             handler = mentry.handler
 
-            allow = store.manifest.rules_for(mentry.key).handler_allowlist
+            allow = manifest.rules.for(mentry.key).handler_allowlist
             next if allow.nil?
             next if allow.allows?(handler)
 

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

@@ -4,15 +4,16 @@ module Textus
       class Hooks < Check
         def call
           out = []
-          dir = File.join(store.root, "hooks")
+          dir = File.join(root, "hooks")
           return out unless File.directory?(dir)
 
           Dir.glob(File.join(dir, "*.rb")).sort.each do |f| # rubocop:disable Lint/RedundantDirGlobSort
-            bus = Textus::Hooks::Bus.new
+            events = Textus::Hooks::EventBus.new
+            rpc    = Textus::Hooks::RpcRegistry.new
             Textus.drain_hook_blocks
             begin
               load(f)
-              Textus.drain_hook_blocks.each { |b| b.call(bus) }
+              Textus.drain_hook_blocks.each { |b| b.call(Textus::Hooks::Loader::Dsl.new(events: events, rpc: rpc)) }
             end
           rescue StandardError, ScriptError => e
             out << {

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

@@ -4,10 +4,10 @@ module Textus
       class IllegalKeys < Check
         def call
           out = []
-          store.manifest.entries.each do |entry|
+          manifest.data.entries.each do |entry|
             next unless entry.nested?
 
-            base = File.join(store.root, "zones", entry.path)
+            base = File.join(root, "zones", entry.path)
             next unless File.directory?(base)
 
             index_fn = entry.respond_to?(:index_filename) ? entry.index_filename : nil

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

@@ -6,7 +6,7 @@ module Textus
 
         def call
           declared = collect_declared_handlers
-          registered = store.bus.rpc_names(:resolve_intake).to_set
+          registered = rpc.names(:resolve_intake).to_set
 
           out = (declared - registered).map do |name|
             {
@@ -35,7 +35,7 @@ module Textus
 
         def collect_declared_handlers
           set = Set.new
-          store.manifest.entries.each do |mentry|
+          manifest.data.entries.each do |mentry|
             set << mentry.handler.to_sym if mentry.is_a?(Textus::Manifest::Entry::Intake)
           end
           set

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

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

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

@@ -23,10 +23,10 @@ module Textus
           }]
         end
 
-        # Doctor check interface: store.root is the .textus/ directory itself,
+        # Doctor check interface: root is the .textus/ directory itself,
         # so manifest.yaml lives directly inside it.
         def call
-          path = File.join(store.root, "manifest.yaml")
+          path = File.join(root, "manifest.yaml")
           return [] unless File.exist?(path)
 
           doc = YAML.safe_load_file(path, aliases: false) || {}

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

@@ -1,7 +1,7 @@
 module Textus
   module Doctor
     class Check
-      # Lists per-key refresh lock files under <store.root>/.locks/ whose
+      # Lists per-key refresh lock files under <root>/.locks/ whose
       # recorded PID is no longer running. These are forensic artifacts only:
       # Refresh::Lock uses flock(2), which the kernel releases on process
       # death, so stale files do not block subsequent acquires. The check
@@ -9,7 +9,7 @@ module Textus
       # (e.g. a refresh path that crashes repeatedly).
       class RefreshLocks < Check
         def call
-          dir = File.join(store.root, ".locks")
+          dir = File.join(root, ".locks")
           return [] unless File.directory?(dir)
 
           Dir.glob(File.join(dir, "*.lock")).filter_map { |path| inspect_lock(path) }

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

@@ -10,8 +10,8 @@ module Textus
 
         def call
           out = []
-          rules = store.manifest.rules
-          store.manifest.entries.each do |mentry|
+          rules = manifest.rules
+          manifest.data.entries.each do |mentry|
             matches = rules.explain(mentry.key)
             next if matches.length < 2
 

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

@@ -7,7 +7,7 @@ module Textus
       # leaving the operator with no signal that a schema is broken.
       class SchemaParseError < Check
         def call
-          dir = File.join(store.root, "schemas")
+          dir = File.join(root, "schemas")
           return [] unless File.directory?(dir)
 
           Dir.glob(File.join(dir, "*.yaml")).each_with_object([]) do |path, out|

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).validate_all
+          res = dispatch(:validate_all)
           res["violations"].map do |v|
             fix = v["expected"] &&
                   "field '#{v["field"]}' should be written by '#{v["expected"]}' (last writer: #{v["last_writer"]})"

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

@@ -4,10 +4,10 @@ module Textus
       class Schemas < Check
         def call
           out = []
-          store.manifest.entries.each do |entry|
+          manifest.data.entries.each do |entry|
             next if entry.schema.nil?
 
-            sp = File.join(store.root, "schemas", "#{entry.schema}.yaml")
+            sp = File.join(root, "schemas", "#{entry.schema}.yaml")
             next if File.exist?(sp)
 
             out << {

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

@@ -3,22 +3,24 @@ module Textus
     class Check
       class Sentinels < Check
         def call
-          dir = File.join(store.root, "sentinels")
-          return [] unless File.directory?(dir)
+          store      = Textus::Ports::SentinelStore.new
+          file_stat  = Textus::Ports::Storage::FileStat.new
+          dir        = File.join(root, "sentinels")
+          return [] unless file_stat.directory?(dir)
 
-          repo_root = File.dirname(store.root)
-          Dir.glob(File.join(dir, "**", "*#{Textus::Domain::Sentinel::SUFFIX}")).flat_map do |sentinel_path|
-            inspect_sentinel(sentinel_path, repo_root)
+          repo_root = File.dirname(root)
+          file_stat.glob(File.join(dir, "**", "*#{Textus::Ports::SentinelStore::SUFFIX}")).flat_map do |sentinel_path|
+            inspect_sentinel(sentinel_path, repo_root, store, file_stat)
           end
         end
 
         private
 
-        def inspect_sentinel(sentinel_path, repo_root)
-          sentinel = Textus::Domain::Sentinel.load(sentinel_path, repo_root)
+        def inspect_sentinel(sentinel_path, repo_root, store, file_stat)
+          sentinel = store.load(sentinel_path, repo_root)
           return [parse_error_issue(sentinel_path)] if sentinel.nil?
-          return [orphan_issue(sentinel_path, sentinel)] if sentinel.orphan?
-          return [drift_issue(sentinel)] if sentinel.drift?
+          return [orphan_issue(sentinel_path, sentinel)] if sentinel.orphan?(file_stat)
+          return [drift_issue(sentinel)] if sentinel.drift?(file_stat)
 
           []
         end