textus 0.43.2 → 0.45.1

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

@@ -1,15 +0,0 @@
-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" => session_for(store).uid(key) })
-        end
-      end
-    end
-  end
-end

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

@@ -1,14 +0,0 @@
-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(session_for(store).where(key))
-        end
-      end
-    end
-  end
-end

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

@@ -1,19 +0,0 @@
-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/read/get_or_fetch.rb

@@ -1,69 +0,0 @@
-module Textus
-  module Read
-    # Composes pure `Read::Get` with the fetch orchestrator: runs Get
-    # to obtain the envelope and freshness verdict, then if the verdict
-    # is stale and the rule's `on_stale` policy demands action, hands
-    # off to the orchestrator. Use for interactive reads where the
-    # caller wants the freshest obtainable envelope.
-    #
-    # Pure reads (build, projection, schema tooling) should use
-    # `Read::Get` directly; it has no orchestrator dependency.
-    class GetOrFetch
-      def initialize(container:, call:, get: nil, orchestrator: nil)
-        @container    = container
-        @call         = call
-        @manifest     = container.manifest
-        @get          = get || Read::Get.new(container: container, call: call)
-        @orchestrator = orchestrator || build_orchestrator
-      end
-
-      private
-
-      def hook_context
-        @hook_context ||= Textus::Hooks::Context.for(container: @container, call: @call)
-      end
-
-      def build_orchestrator
-        worker = Textus::Write::FetchWorker.new(
-          container: @container, call: @call,
-        )
-        Textus::Write::FetchOrchestrator.new(
-          worker: worker, store_root: @container.root, events: @container.events,
-          hook_context: hook_context
-        )
-      end
-
-      public
-
-      def call(key)
-        envelope = @get.call(key)
-        return nil if envelope.nil?
-        return envelope unless envelope.freshness&.stale
-
-        policy_set = @manifest.rules.for(key)
-        fetch_policy = policy_set.fetch
-        return envelope if fetch_policy.nil?
-
-        policy = fetch_policy.to_freshness_policy
-        verdict = Textus::Domain::Freshness::Verdict.stale(envelope.freshness.reason)
-        action = policy.decide(verdict)
-        outcome = @orchestrator.execute(action, key: key)
-
-        case outcome
-        when Textus::Domain::Outcome::Skipped
-          envelope
-        when Textus::Domain::Outcome::Fetched
-          outcome.envelope.with(
-            freshness: Textus::Domain::Freshness.build(stale: false, reason: nil, fetching: false),
-          )
-        when Textus::Domain::Outcome::Detached
-          envelope.with(freshness: envelope.freshness.with(fetching: true))
-        when Textus::Domain::Outcome::Failed
-          envelope.with(
-            freshness: envelope.freshness.with(fetch_error: outcome.error.message),
-          )
-        end
-      end
-    end
-  end
-end

data/lib/textus/read/policy_explain.rb

@@ -1,46 +0,0 @@
-module Textus
-  module Read
-    # For one key, surface every matching policy block along with the
-    # per-slot effective value (which loses ties win-by-specificity) and the
-    # effective guard predicate names for every write transition (ADR 0031).
-    class PolicyExplain
-      def initialize(container:, call: nil) # rubocop:disable Lint/UnusedMethodArgument
-        @manifest = container.manifest
-        @schemas  = container.schemas
-      end
-
-      def call(key:)
-        matching = @manifest.rules.explain(key)
-        winners  = @manifest.rules.for(key)
-        factory  = Textus::Domain::Policy::GuardFactory.new(manifest: @manifest, schemas: @schemas)
-
-        {
-          key: key,
-          matched_blocks: matching.map do |b|
-            {
-              match: b.match,
-              fetch: !b.fetch.nil?,
-              handler_allowlist: !b.handler_allowlist.nil?,
-              guard: !b.guard.nil?,
-              retention: !b.retention.nil?,
-            }
-          end,
-          effective: {
-            fetch: winners.fetch && {
-              ttl_seconds: winners.fetch.ttl_seconds,
-              on_stale: winners.fetch.on_stale,
-            },
-            handler_allowlist: winners.handler_allowlist&.handlers,
-            retention: winners.retention && {
-              expire_after: winners.retention.expire_after,
-              archive_after: winners.retention.archive_after,
-            },
-          },
-          guards: Textus::Domain::Policy::BaseGuards::BASE.keys.to_h do |transition|
-            [transition, factory.for(transition, key).predicates.map(&:name)]
-          end,
-        }
-      end
-    end
-  end
-end

data/lib/textus/read/rules.rb

@@ -1,25 +0,0 @@
-module Textus
-  module Read
-    # Effective rule set (fetch + guard) for a key. Was the inlined MCP
-    # `rules` tool; promoted to a first-class verb so MCP is a pure projection
-    # (ADR 0039).
-    class Rules
-      extend Textus::Contract::DSL
-
-      verb     :rules
-      summary  "Return effective rules for a key (fetch, guard, ...)."
-      surfaces :ruby, :mcp
-      arg :key, String, required: true, positional: true,
-                        description: "dotted key whose effective rules you want (fetch ttl/action, write guard, ...)"
-
-      def initialize(container:, call: nil) # rubocop:disable Lint/UnusedMethodArgument
-        @manifest = container.manifest
-      end
-
-      def call(key)
-        set = @manifest.rules.for(key)
-        { "fetch" => set.fetch&.to_h, "guard" => set.guard }.compact
-      end
-    end
-  end
-end